Micronaut 介绍
1. Micronaut 升级到 Micronaut 3.x
Micronaut 快速开始
1. Micronaut 安装CLI
2. Micronaut 创建服务器应用程序
3. Micronaut 设置IDE
4. Micronaut 创建客户端
5. Micronaut 部署应用程序
Micronaut 控制反转
1. Micronaut 定义 Beans
2. Micronaut 是如何工作的
3. Micronaut BeanContext
4. Micronaut 可注射容器类型
5. Micronaut Bean 限定符
6. Micronaut 限制注射类型
7. Micronaut Scopes
8. Micronaut Bean Factories
9. Micronaut 条件 Beans
10. Micronaut Bean 替换
11. Micronaut Bean 配置
12. Micronaut 生命周期方法
13. Micronaut Context Events
14. Micronaut Bean Events
15. Micronaut Bean 自省
16. Micronaut Bean 验证
17. Micronaut Bean 注释元数据
18. Micronaut 从库中导入 Bean
19. Micronaut 可忽略性注解
20. Micronaut Beans 和 Spring
21. Micronaut 安卓支持
Micronaut 应用配置
1. Micronaut 环境
2. Micronaut 使用 PropertySources 的外部化配置
3. Micronaut 配置注入
4. Micronaut 配置属性
5. Micronaut 自定义类型转换器
6. Micronaut 使用@EachProperty 驱动配置
7. Micronaut 使用@EachBean 驱动配置
8. Micronaut 不可变配置
9. Micronaut Bootstrap 配置
10. Micronaut JMX 支持
Micronaut 面向切面编程
1. Micronaut Around Advice
2. Micronaut 介绍 Advice
3. Micronaut Method Adapter Advice
4. Micronaut Bean 生命周期 Advice
5. Micronaut 验证 Advice
6. Micronaut 缓存 Advice
7. Micronaut 重试 Advice
8. Micronaut 计划任务
9. Micronaut 桥接 Spring AOP
Micronaut HTTP 服务器
1. Micronaut 运行嵌入式服务器
2. Micronaut 在特定端口上运行服务器
3. Micronaut HTTP路由
4. Micronaut 简单请求绑定
5. Micronaut 自定义参数绑定
6. Micronaut 主机解析
7. Micronaut 地域解析
8. Micronaut 客户端IP地址
9. Micronaut HttpRequest 和 HttpResponse
10. Micronaut 响应状态
11. Micronaut 响应 Content-Type
12. Micronaut 接收请求的 Content-Type
13. Micronaut 响应式 HTTP 请求处理
14. Micronaut 用 Jackson 进行 JSON 绑定
15. Micronaut 数据验证
16. Micronaut 服务静态资源
17. Micronaut 错误处理
18. Micronaut API 版本控制
19. Micronaut 处理表单数据
20. Micronaut 写入响应数据
21. Micronaut 文件上传
22. Micronaut 文件传输
23. Micronaut HTTP 过滤器
24. Micronaut HTTP Sessions
25. Micronaut 服务器发送事件
26. Micronaut WebSocket 支持
27. Micronaut HTTP/2 支持
28. Micronaut 服务器事件
29. Micronaut 配置 HTTP 服务器
30. Micronaut 服务器端视图渲染
31. Micronaut OpenAPI / Swagger 支持
32. Micronaut GraphQL 支持
Micronaut HTTP 客户端
1. Micronaut 使用低级 HTTP 客户端
2. Micronaut 使用 ProxyHttpClient 代理请求
3. Micronaut 使用 @Client 的声明式 HTTP 客户端
4. Micronaut HTTP 客户端过滤器
5. Micronaut HTTP/2 支持
6. Micronaut HTTP 客户端示例
Micronaut 云原生特性
1. Micronaut 云配置
2. Micronaut 服务发现
3. Micronaut 客户端负载均衡
4. Micronaut 分布式追踪
Micronaut 无服务器函数
1. Micronaut AWS Lambda
2. Micronaut Google Cloud Function
3. Micronaut Google Cloud Run
4. Micronaut Azure Function
Micronaut 消息驱动的微服务
1. Micronaut Kafka 支持
2. Micronaut RabbitMQ 支持
3. Micronaut Nats.io 支持
Micronaut 独立命令行应用程序
1. Micronaut Picocli 支持
Micronaut 配置
1. Micronaut 响应式编程的配置
2. Micronaut 数据访问配置
Micronaut 日志
1. Micronaut 记录日志
2. Micronaut 配置
3. Micronaut Logback
4. Micronaut 日志系统
Micronaut 语言支持
1. Micronaut Java 支持
2. Micronaut Groovy 支持
3. Micronaut Kotlin 支持
4. Micronaut GraalVM 支持
Micronaut 管理与监控
1. Micronaut 创建 Endpoints
2. Micronaut 内置 Endpoints
Micronaut 安全
Micronaut 多租户
Micronaut CLI
1. Micronaut 创建项目
2. Micronaut 特性
3. Micronaut 命令
4. Micronaut 重载
5. Micronaut 代理配置
Micronaut 国际化
1. Micronaut 资源包
2. Micronaut 本地化消息源
Micronaut 附录
1. Micronaut 架构
2. Micronaut FAQ
3. Micronaut 使用快照
4. Micronaut 常见问题

阅读(872) 书签赞(0) 我要纠错

Micronaut Scopes

2023-02-27 15:02 更新

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

内置范围

表 1. Micronaut 内置范围
类型	描述
@Singleton	Singleton 作用域表示将只存在一个 bean 实例
@Context	Context scope表示bean会和ApplicationContext同时创建（eager initialization）
@Prototype	Prototype作用域表示每次注入时都会创建一个新的bean实例
@Infrastructure	Infrastructure 作用域表示不能使用 @Replaces 覆盖或替换的 bean，因为它对系统的功能至关重要。
@ThreadLocal	@ThreadLocal 范围是一个自定义范围，它通过 ThreadLocal 为每个线程关联一个 bean
@Refreshable	@Refreshable 范围是一个自定义范围，它允许通过 /refresh 端点刷新 bean 的状态。
@RequestScope	@RequestScope 作用域是一个自定义作用域，表示创建了一个新的 bean 实例并与每个 HTTP 请求相关联

@Prototype 注解是@Bean 的同义词，因为默认作用域是原型。

可以通过定义实现 CustomScope 接口的 @Singleton bean 来添加其他范围。

请注意，当启动 ApplicationContext 时，默认情况下 @Singleton-scoped beans 是延迟和按需创建的。这是为了优化启动时间而设计的。

如果这对您的用例造成问题，您可以选择使用 @Context 注释，它将对象的生命周期绑定到 ApplicationContext 的生命周期。换句话说，当 ApplicationContext 启动时，您的 bean 将被创建。

或者，使用 @Parallel 注释任何 @Singleton-scoped bean，这允许在不影响整体启动时间的情况下并行初始化 bean。

如果您的 bean 未能并行初始化，应用程序将自动关闭。

单例的急切初始化

在某些情况下，@Singleton bean 的急切初始化可能是可取的，例如在 AWS Lambda 上，分配给 Lambda 构建的 CPU 资源多于执行。

您可以指定是否使用 ApplicationContextBuilder 接口预先初始化 @Singleton-scoped bean：

启用单例的急切初始化

public class Application {

    public static void main(String[] args) {
        Micronaut.build(args)
            .eagerInitSingletons(true) (1)
            .mainClass(Application.class)
            .start();
    }
}

将 eager init 设置为 true 会初始化所有单例

当您在无服务器函数等环境中使用 Micronaut 时，您将没有应用程序类，而是扩展了 Micronaut 提供的类。在这些情况下，Micronaut 提供了一些方法，您可以重写这些方法来增强 ApplicationContextBuilder

覆盖 newApplicationContextBuilder()

public class MyFunctionHandler extends MicronautRequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
...
    @Nonnull
    @Override
    protected ApplicationContextBuilder newApplicationContextBuilder() {
        ApplicationContextBuilder builder = super.newApplicationContextBuilder();
        builder.eagerInitSingletons(true);
        return builder;
    }
    ...
}

@ConfigurationReader beans，例如@EachProperty 或@ConfigurationProperties 是单例bean。要急切地初始化配置但保持其他 @Singleton-scoped bean 创建惰性，请使用 eagerInitConfiguration：

启用配置的急切初始化

public class Application {

    public static void main(String[] args) {
        Micronaut.build(args)
            .eagerInitConfiguration(true) (1)
            .mainClass(Application.class)
            .start();
    }
}

将 eager init 设置为 true 会初始化所有配置读取器 bean。

可刷新 Scope

Refreshable 范围是一个自定义范围，允许通过以下方式刷新 bean 的状态：

/refresh endpoint.
RefreshEvent 的发布。

以下示例说明了 @Refreshable 范围行为。

Java Groovy Kotlin

@Refreshable // (1)
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());// (2)
    }

    public String latestForecast() {
        return forecast;
    }
}

@Refreshable // (1)
static class WeatherService {

    String forecast

    @PostConstruct
    void init() {
        forecast = "Scattered Clouds ${new SimpleDateFormat("dd/MMM/yy HH:mm:ss.SSS").format(new Date())}" // (2)
    }

    String latestForecast() {
        return forecast
    }
}

@Refreshable // (1)
open class WeatherService {
    private var forecast: String? = null

    @PostConstruct
    open fun init() {
        forecast = "Scattered Clouds " + SimpleDateFormat("dd/MMM/yy HH:mm:ss.SSS").format(Date())// (2)
    }

    open fun latestForecast(): String? {
        return forecast
    }
}

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

如果调用 latestForecast() 两次，您将看到相同的响应，例如“Scattered Clouds 01/Feb/18 10:29.199”。

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

Java	Groovy	Kotlin
`applicationContext.publishEvent(new RefreshEvent());`	`applicationContext.publishEvent(new RefreshEvent())`	`applicationContext.publishEvent(RefreshEvent())`

元注释的范围

可以在元注释上定义范围，然后您可以将其应用于您的类。考虑以下示例元注释：

Driver.java Annotation

Java Groovy Kotlin

import io.micronaut.context.annotation.Requires;

import jakarta.inject.Singleton;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;

import static java.lang.annotation.RetentionPolicy.RUNTIME;

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

import io.micronaut.context.annotation.Requires

import jakarta.inject.Singleton
import java.lang.annotation.Documented
import java.lang.annotation.Retention

import static java.lang.annotation.RetentionPolicy.RUNTIME

@Requires(classes = Car.class) // (1)
@Singleton // (2)
@Documented
@Retention(RUNTIME)
@interface Driver {
}

import io.micronaut.context.annotation.Requires
import jakarta.inject.Singleton
import kotlin.annotation.AnnotationRetention.RUNTIME

@Requires(classes = [Car::class]) // (1)
@Singleton // (2)
@MustBeDocumented
@Retention(RUNTIME)
annotation class Driver

该范围使用 Requires 声明对 Car 类的要求
注解声明为@Singleton

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

请注意，在这种情况下，无法在应用注释时更改范围。例如，以下不会覆盖@Driver 声明的范围并且是无效的：

Declaring Another Scope

@Driver
@Prototype
class Foo {}

对于可覆盖的范围，请改为使用 @Driver 上的 DefaultScope 批注，它允许在不存在其他范围的情况下指定默认范围：

Using @DefaultScope

Java Groovy Kotlin

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

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

@Requires(classes = [Car::class])
@DefaultScope(Singleton::class) (1)
@Documented
@Retention(RUNTIME)
annotation class Driver

如果未指定，则 DefaultScope 声明要使用的范围

以上内容是否对您有帮助：

← Micronaut 限制注射类型

Micronaut Bean Factories →

写笔记

我要补充