SpringBoot的竞争对手——Micronaut之控制反转(IOC)

水深无声 2024-04-18 23:29 50阅读 0赞

上一篇我已经带大家学习了`Micronaut`的入门教程，介绍了Micronaut是什么，有哪些特点，今天我们就带大家来了解一下`Micronaut之控制反转`。

## 1.控制反转 ##

当大多数开发者想到`控制反转`时，会想到`Spring`框架。控制反转又被称为`依赖注入`。

`Micronaut`从`Spring`框架获得灵感，事实上，`Micronaut`的核心开发人员是前`SpringSource / Pivotal`工程师，现在在[OCI][]工作。

`Spring`完全依赖于`运行时`反射和代理，而`Micronaut`使用`编译时`数据来实现`依赖注入`。

Google的[`Dagger`][Dagger]等工具采用的类似方案，其主要是为`Android`而设计一套依赖注入框架。另一方面，`Micronaut`设计用于构建服务端微服务，并提供许多与`Spring`相同的工具和实用程序，不使用反射或缓存过多的反射元数据。

`Micronaut` IoC容器的目标总结如下：

*  使用反射作为最后的手段
 *  避免使用代理
 *  优化启动时间
 *  减少内存占用
 *  提供清晰，易懂的错误处理

**注意**: 由于`Micronaut的IoC`部分可以完全独立于`Micronaut`本身使用，我在构建应用之前，我们需要添加包含`micronaut-inject-java`依赖项作为注解处理器。 例如`Maven`：

<dependencies>
        <dependency>
          <groupId>io.micronaut</groupId>
          <artifactId>micronaut-inject</artifactId>
          <scope>compile</scope>
        </dependency>
        ...
      </dependencies>
      <build>
        <plugins>
            <plugin>
              <groupId>org.apache.maven.plugins</groupId>
              <artifactId>maven-compiler-plugin</artifactId>
              <version>3.7.0</version>
              <configuration>
                <compilerArgs>
                  <arg>-parameters</arg>
                </compilerArgs>
                <annotationProcessorPaths>
                      <path>
                        <groupId>io.micronaut</groupId>
                        <artifactId>micronaut-inject-java</artifactId>
                        <version>${micronaut.version}</version>
                      </path>
                </annotationProcessorPaths>
              </configuration>
              <executions>
                <execution>
                  <id>test-compile</id>
                  <goals>
                    <goal>testCompile</goal>
                  </goals>
                  <configuration>
                    <compilerArgs>
                      <arg>-parameters</arg>
                    </compilerArgs>
                    <annotationProcessorPaths>
                      <path>
                        <groupId>io.micronaut</groupId>
                        <artifactId>micronaut-inject-java</artifactId>
                        <version>${micronaut.version}</version>
                      </path>
                      <path>
                        <groupId>io.micronaut</groupId>
                        <artifactId>micronaut-validation</artifactId>
                        <version>${micronaut.version}</version>
                      </path>
    
                    </annotationProcessorPaths>
                  </configuration>
                </execution>
              </executions>
            </plugin>
          </plugins>
        </pluginManagement>
      </build>

`micronaut-inject-java`: 添加Annotation Processing插件  
`micronaut-inject`:执行依赖注入所需的依赖项

然后，IoC的入口点是[`ApplicationContext`][ApplicationContext]接口，其中包含一个`run`方法。 以下示例演示如何使用它：

运行`ApplicationContext`

try (ApplicationContext context = ApplicationContext.run()) {  
        MyBean myBean = context.getBean(MyBean.class); 
        // do something with your bean
    }

*  运行ApplicationContext
 *  检索已依赖注入的bean

注意：该示例使用Java的[`try-with-resources`][try-with-resources]语法来确保在应用程序退出时干净地关闭[`ApplicationContext`][ApplicationContext]。

## 2.定义Bean ##

`Micronaut`实现了[`JSR-330（javax.inject） - Java规范的依赖注入`][JSR-330_javax.inject_ - Java]，因此使用`Micronaut`只需使用`javax.inject`提供的注解。

以下是一个简单的例子：

/** *定义了通用`Engine`接口 */
    public interface Engine {  
        int getCylinders();
        String start();
    }
    /** *定义`V8Engine`实现并添加`@Singleton`注解， *标记该类的作用域`Singleton`，则在整个应用中，只创建bean的一个实 */
    @Singleton
    public class V8Engine implements Engine { 
        public String start() { 
            return "Starting V8";
        }
    
        public int getCylinders() { 
            return cylinders;
        }
    
        public void setCylinders(int cylinders) { 
            this.cylinders = cylinders;
        }
    
        private int cylinders = 8;
    }
    
    @Singleton
    public class Vehicle { 
        private final Engine engine;
    
        // 通过构造函数注入注入`Engine`
        public Vehicle(Engine engine) { 
            this.engine = engine;
        }
    
        public String start() { 
            return engine.start();
        }
    }

*  定义了通用`Engine`接口
 *  定义`V8Engine`实现并添加`@Singleton`注解，标记该类的作用域`Singleton`，则在整个应用中，只创建bean的一个实例。
 *  通过构造函数注入注入`Engine`。

要执行依赖项注入，只需使用`run()`方法运行[`BeanContext`][BeanContext]并使用`getBean（Class）`查找bean，如下例所示：

Vehicle vehicle = BeanContext.run().getBean(Vehicle.class);
    System.out.println(vehicle.start());

![在这里插入图片描述][20190914103716984.png]

`Micronaut`将自动发现在`classpath`下依赖注入的元数据,根据我们定义的注入点将`Bean`连接在一起。

`Micronut`支持以下类型的`依赖注入`：

*  构造函数注入（必须是一个公共构造函数或使用`@Inject`注解的单个构造函数）
 *  Field注入
 *  Java Bean属性注入
 *  方法参数注入

## 3 依赖注入的工作原理 ##

上面我们已经了解了`Micronaut`的依赖注入和Bean的定义，此时，我最想知道`Micronaut`如何在不需要反射的情况下执行上述依赖注入。

关键是一组`AST转换（用于Groovy）`和`注解处理器（用于Java）`，它们生成实现[`BeanDefinition`][BeanDefinition]接口的类。

`ASM字节码库`用于生成类，并且由于`Micronaut`提前知道注入点，因此不需要像运行`Spring`等其他框架一样在`运行时`扫描所有`方法`，`字段`，`构造函数`等。

此外，由于在构造bean时`不使用反射`，因此JVM可以更好地内联和优化代码，从而提高`运行时`性能并减少内存消耗。 这对于`非Singleton作用域的bean`尤为重要，因为应用程序性能取决于`bean创建的性能`。

此外，使用`Micronaut`，我们的应用程序的`启动时间`和`内存消耗`不会像使用反射的框架一样与代码库的大小有关系。 `基于反射的IoC框架`为代码中的每个字段，方法和构造函数加载和缓存反射数据。 因此，随着代码规模的扩大，您的内存需求也会增加，而使用`Micronaut`则不是这样。

## 4 BeanContext 介绍 ##

[`BeanContext`][BeanContext]是所有bean定义的容器对象（它还实现了[`BeanDefinitionRegistry`][BeanDefinitionRegistry]）。

这也是`Micronaut`的初始化点。 但是，一般来说，我们不必直接与`BeanContext` API交互，只需使用`javax.inject`注解和`io.micronaut.context.annotation`包中定义的注解来满足`依赖注入`需求。

## 5 可注入容器类型 ##

除了能够注入Bean，`Micronaut`本身还支持注入以下类型：

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>java.util.Optional</code></td> 
   <td>An <code>Optional</code>of a bean. If the bean doesn’t exist <code>empty()</code> is injected</td> 
   <td><code>Optional&lt;Engine&gt;</code></td> 
  </tr> 
  <tr> 
   <td><code>java.lang.Iterable</code></td> 
   <td>An <code>Iterable</code> or subtype of Iterable (example List, Collection etc.)</td> 
   <td><code>Iterable&lt;Engine&gt;</code></td> 
  </tr> 
  <tr> 
   <td><code>java.util.stream.Stream</code></td> 
   <td>A lazy <code>Stream</code> of beans</td> 
   <td><code>Stream&lt;Engine&gt;</code></td> 
  </tr> 
  <tr> 
   <td><code>Array</code></td> 
   <td>A native array of beans of a given type</td> 
   <td><code>Engine[]</code></td> 
  </tr> 
  <tr> 
   <td><code>Provider</code></td> 
   <td>A <code>javax.inject.Provider</code> if a circular dependency requires it or to instantiate a prototype for each <code>get</code>call.</td> 
   <td><code>Provider&lt;Engine&gt;</code></td> 
  </tr> 
 </tbody> 
</table>

**注意**：属性bean将在每个注入bean的位置创建一个实例。 当一个属性bean作为`Provider`注入时，每次调用`get()`都会创建一个新实例。

## 6.Bean限定符 ##

如果要为要注入的给定接口提供多种可能的实现，则需要使用`限定符`。

`Micronaut`又一次利用`JSR-330`和[`Qualifier`][Qualifier]和 [`Named`][Named] 来支持Bean的限定符。

### 6.1 Named 限定符 ###

要按名称限定，我们可以使用[`@Named`][Named]注解 。 如下面的类：

public interface Engine {  
        int getCylinders();
        String start();
    }
    
    @Singleton
    public class V6Engine implements Engine {   
        public String start() { 
            return "Starting V6";
        }
    
        public int getCylinders() { 
            return 6;
        }
    }
    
    @Singleton
    public class V8Engine implements Engine { 
        public String start() { 
            return "Starting V8";
        }
    
        public int getCylinders() { 
            return 8;
        }
    
    }
    
    @Singleton
    public class Vehicle { 
        private final Engine engine;
    
        @Inject
        public Vehicle(@Named("v8") Engine engine) { 
            this.engine = engine;
        }
    
        public String start() { 
            return engine.start();
        }
    }

*  定义了通用`Engine`接口
 *  定义`V6Engine`实现`Engine`接口
 *  定义`V8Engine`实现`Engine`接口
 *  `@Named("v8")` 注解用于指示需要`V8Engine`实现
 *  调用`start` 方法 输出了: `"Starting V8"`

我们还可以在bean的`类级别`声明[`@Named`][Named]以显式定义bean的名称。

### 6.2 Qualifier 修饰符 ###

除了能够按名称限定之外，我们还可以使用[`Qualifier`][Qualifier]构建自己的限定符。请参考以下注解：

import javax.inject.Qualifier;
    import java.lang.annotation.Retention;
    
    import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    @Qualifier
    @Retention(RUNTIME)
    public @interface V8 { 
    }

上面的注解本身使用`@Qualifier`注解进行定义，以将其指定为限定符。 然后，我们可以在代码中的任何注入点使用`V8`注解。 例如：

@Inject Vehicle(@V8 Engine engine) { 
            this.engine = engine;
        }

### 6.3 `Primary` 和 `Secondary` 限定Bean ###

`Primary`是用来限定bean是在多个可能的接口实现的情况下应该选择的主bean。

请参考以下示例：

public interface ColorPicker { 
        String color();
    }

定义一个通用的`ColorPicker`接口，定义了两个实现`Green`,`Blue`，其中`Green`添加了`@Primary`

import io.micronaut.context.annotation.Primary;
    import javax.inject.Singleton;
    
    @Primary
    @Singleton
    class Green implements ColorPicker { 
    
        @Override
        public String color() { 
            return "green";
        }
    }

@Singleton
    public class Blue implements ColorPicker { 
    
        @Override
        public String color() { 
            return "blue";
        }
    }

`Blue` bean也实现了`ColorPicker`接口，因此在注入`ColorPicker`接口我们有两个可能。 由于`Green`是添加了`@Primary`，它总是默认实现。

package hello.world;
    
    import io.micronaut.http.annotation.Controller;
    import io.micronaut.http.annotation.Get;
    
    @Controller("/test")
    public class TestController { 
    
        protected final ColorPicker colorPicker;
    
        public TestController(ColorPicker colorPicker) { 
            this.colorPicker = colorPicker;
        }
    
        @Get
        public String index() { 
            return colorPicker.color();
        }
    }

通过构造方法注入，默认注入是带有`@Primary`注解的`Green`的bean。  
![在这里插入图片描述][20190914214423442.png]

如果存在多个可能的实现Bean且未定义`@Primary`，则将抛出[`NonUniqueBeanException`][NonUniqueBeanException]。

除了`@Primary`之外，还有一个[`@Secondary`][Secondary] 注解，它会产生相反的效果，并允许对bean进行`去优先级`排序。

## 6.4 作用域 ##

`Micronaut`具有基于`JSR-330`的可扩展bean`作用域`机制。 支持以下默认范围：

#### 6.4.1 内建的作用域 ####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><a href="https://docs.oracle.com/javaee/6/api/javax/inject/Singleton.html" rel="nofollow">@Singleton</a></td> 
   <td><code>Singleton</code>作用域表示只应存在一个bean实例</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Context.html" rel="nofollow">@Context</a></td> 
   <td><code>Context</code>作用域表示应该与<code>ApplicationContext</code>同时创建bean</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Prototype.html" rel="nofollow">@Prototype</a></td> 
   <td><code>Prototype</code>作用域表示每次注入时都会创建一个新的bean实例</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Infrastructure.html" rel="nofollow">@Infrastructure</a></td> 
   <td><code>Infrastructure</code>作用域表示使用<code>@Replaces</code>无法覆盖或替换的bean,因为它对系统的运行至关重要。</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.micronaut.io/latest/api/io/micronaut/runtime/context/scope/ThreadLocal.html" rel="nofollow">@ThreadLocal</a></td> 
   <td><code>@ThreadLocal</code>作用域是一个自定义作用域，它通过<code>ThreadLocal</code>将每个线程的bean关联起来</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.micronaut.io/latest/api/io/micronaut/runtime/context/scope/Refreshable.html" rel="nofollow">@Refreshable</a></td> 
   <td><code>@Refreshable</code> 作用域是一个自定义作用域，允许通过<code>/ refresh</code>端点刷新bean的状态</td> 
  </tr> 
  <tr> 
   <td><a href="https://docs.micronaut.io/latest/api/io/micronaut/runtime/http/scope/RequestScope.html" rel="nofollow">@RequestScope</a></td> 
   <td><code>@RequestScope</code>作用域是一个自定义作用域，表示创建bean的新实例并将其与每个HTTP请求关联</td> 
  </tr> 
 </tbody> 
</table>

**注意**：`@Prototype`注解是`@Bean`的同义词，因为默认作用域是`Prototype`。

`其他作用域`的实现可以通过定义一个`@Singleton`的 bean 并实现[`CustomScope`][CustomScope]接口。

**注意**：默认情况下，使用`Micronaut`启动[`ApplicationContext`][ApplicationContext]时，`Singleton` 作用域的bean会根据需要随时创建。 这样设计可以优化启动时间。

如果我们需要在应用程序启动时，创建bean。那么我们可以选择使用[`@Context`][Context]注解将对象的生命周期绑定到[`ApplicationContext`][ApplicationContext]的生命周期。 换句话说，当[`ApplicationContext`][ApplicationContext]启动时，将会创建bean。

或者，我们可以使用[`@Parallel`][Parallel]注解的任何`@Singleton`作用域bean，它允许并行初始化bean而不会影响整体启动时间。

> 如果我们的bean无法`并行初始化`，那么应用程序将`自动关闭`。

#### 6.4.2 Refreshable作用域 ####

Refreshable作用域是一个作用域，允许通过以下方式刷新bean的状态：

*  `/refresh` 刷新端点
 *  发布[`RefreshEvent`][RefreshEvent]

以下示例说明了`@Refreshable`作用域的行为。

@Refreshable 
    public static class WeatherService { 
        private String forecast;
    
        @PostConstruct
        public void init() { 
            forecast = "Scattered Clouds " + new SimpleDateFormat("dd/MMM/yy HH:mm:ss.SSS").format(new Date());
        }
    
        public String latestForecast() { 
            return forecast;
        }
    }

*  `WeatherService`使用`@Refreshable`作用域进行注解，该作用域存储实例直到触发刷新事件
 *  创建bean时,`forecast`属性的值设置为固定值，并且在刷新bean之前不会更改

如果我们两次调用`latestForecast（）`，我们将看到相同的响应结果，例如`Scattered Clouds 01 / Feb / 18 10：29.199`。

当我们调用`/ refresh`端点或发布`RefreshEvent`事件时，实例将失效，并在下次请求对象时`创建新实例`。 例如：

try (ApplicationContext applicationContext = ApplicationContext.run()) { 
                applicationContext.publishEvent(new RefreshEvent());
                WeatherService weatherService = applicationContext.getBean(WeatherService.class);
    // // do something with your bean
               System.out.println(weatherService.latestForecast());
            }

结果显示如下，已经刷新成功。  
![在这里插入图片描述][20190915121105890.png]

#### 6.4.3元注释的作用域 ####

作用域可以在`Meta`注解上定义，然后可以应用于我们的类。 请参考以下示例元注解：

import static java.lang.annotation.RetentionPolicy.RUNTIME;
    
    import io.micronaut.context.annotation.Requires;
    
    import javax.inject.Singleton;
    import java.lang.annotation.Documented;
    import java.lang.annotation.Retention;
    
    @Requires(classes = Car.class ) 
    @Singleton 
    @Documented
    @Retention(RUNTIME)
    public @interface Driver { 
    }

*  作用域使用[`@Requires`][Requires]声明对`Car`类的关联
 *  注解声明为`@Singleton`

在上面的示例中，`@ Singleton`注解应用于`@Driver`注解，这导致每个使用`@Driver`注解的的类被视为`单例`。

**注意**: 在这种情况下，应用注解时无法更改作用域。 例如，以下内容不会覆盖`@Driver`声明的作用域，并且无效：

声明另外一个作用域

@Driver
    @Prototype
    class Foo { 
    }

如果希望作用域可以覆盖，则应该在`@Driver`上使用[`DefaultScope`][DefaultScope]注解，如果没有其他作用域，则允许指定默认作用域：

使用`@DefaultScope`

@Requires(classes = Car.class )
    @DefaultScope(Singleton.class) 
    @Documented
    @Retention(RUNTIME)
    public @interface Driver { 
    }

`DefaultScope`用于声明在没有作用域的时使用的作用域。

## 7 总结 ##

这篇主要介绍了`Micronaut`的`控制反转(IOC)`、`Bean限定符`、`Bean的作用域`，下一篇我们继续学习`Bean 工厂`的基本知识。

[OCI]: https://objectcomputing.com
[Dagger]: https://google.github.io/dagger/
[ApplicationContext]: https://docs.micronaut.io/latest/api/io/micronaut/context/ApplicationContext.html
[try-with-resources]: https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html
[JSR-330_javax.inject_ - Java]: http://javax-inject.github.io/javax-inject/
[BeanContext]: https://docs.micronaut.io/latest/api/io/micronaut/context/BeanContext.html
[20190914103716984.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/d686989123a04ab5938f689fb3b4ed46.png
[BeanDefinition]: https://docs.micronaut.io/latest/api/io/micronaut/inject/BeanDefinition.html
[BeanDefinitionRegistry]: https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/package-summary.html
[Qualifier]: https://docs.oracle.com/javaee/6/api/javax/inject/Qualifier.html
[Named]: https://docs.oracle.com/javaee/6/api/javax/inject/Named.html
[20190914214423442.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/b97af47495714d3aa89372f4fc398cd2.png
[NonUniqueBeanException]: https://docs.micronaut.io/latest/api/io/micronaut/context/exceptions/NonUniqueBeanException.html
[Secondary]: https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Secondary.html
[CustomScope]: https://docs.micronaut.io/latest/api/io/micronaut/context/scope/CustomScope.html
[Context]: https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Context.html
[Parallel]: https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Parallel.html
[RefreshEvent]: https://docs.micronaut.io/latest/api/io/micronaut/runtime/context/scope/refresh/RefreshEvent.html
[20190915121105890.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/5157d42d368d4b3188b6a5563c285682.png
[Requires]: https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/Requires.html
[DefaultScope]: https://docs.micronaut.io/latest/api/io/micronaut/context/annotation/DefaultScope.html