SpringBoot常用注解总结

1. 总结

1.1. @SpringBootApplication

定义在main方法入口类处，用于启动sping boot应用项目

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Configuration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {

	/**
	 * Exclude specific auto-configuration classes such that they will never be applied.
	 * @return the classes to exclude
	 */
	Class<?>[] exclude() default {};

}

@Target(ElementType.TYPE)

• @Target 是一个元注解，用于定义自定义注解可以应用到哪些程序元素上。在 ElementType.TYPE 的情况下，这意味着该注解可以应用于类级别（类、接口、枚举），表示注解只能被用于类声明。

@Retention(RetentionPolicy.RUNTIME)

• @Retention 是另一个元注解，它定义了注解的生命周期。当设置为 RetentionPolicy.RUNTIME 时，表示该注解会在编译后的字节码中保留，可以在运行时通过反射访问。这意味着开发者可以在程序运行时通过反射API来读取和处理这些注解信息。

@Documented

• @Documented 是一个元注解，当应用到其他自定义注解上时，它指示文档生成工具（如Javadoc）应将该注解包含在生成的文档中。这样，注解的信息也会出现在最终的API文档中，增加了代码的可读性和可理解性。

@Inherited

• @Inherited 是一个元注解，它指定一个注解是可继承的。如果一个类被使用了 @Inherited 注解的注解，那么它的所有子类都会隐式地具有这个注解，除非子类显式地覆盖了它。但是，需要注意的是，这个规则只适用于类继承，不适用于接口。

@Configuration

• 在 Spring Boot 中，@Configuration 是一个核心注解，它表明一个类是用来定义bean配置的，类似于XML配置文件中的 标签。这个类里的方法（通常使用 @Bean 注解）会被Spring容器用来创建和管理bean。

@EnableAutoConfiguration

• @EnableAutoConfiguration 是 Spring Boot 的一个关键注解，它启动了自动配置机制。当这个注解添加到一个 Spring 应用上下文的主配置类上时，Spring Boot 会根据项目依赖来猜测并自动配置应用的bean。例如，如果你的类路径中有 JPA 相关的库，Spring Boot 将会自动配置数据源、事务管理器以及实体扫描等。

@ComponentScan

• @ComponentScan 是 Spring 框架中的注解，它告诉 Spring 容器去哪个包及其子包下寻找 @Component、@Service、@Repository 和 @Controller 等注解的类，以便将它们注册为bean。这使得Spring能够自动发现和管理这些组件，而不需要显式的配置每个bean。在 Spring Boot 中，通常与 @Configuration 一起使用，以完成整个应用的组件扫描和配置。

1.2. @EnableAutoConfiguration

让spring boot根据类路径中的jar包依赖当前项目进行自动配置

在src/main/resources的META-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration

若有多个自动配置，用","隔开

@EnableAutoConfiguration 是 Spring Boot 中的一个重要注解，它极大地简化了Spring应用程序的初始配置过程。以下是关于 @EnableAutoConfiguration 的详细说明：

1. 自动配置原理：当在应用的主配置类上使用 @EnableAutoConfiguration 时，Spring Boot 会自动扫描项目类路径下的jar依赖，并基于这些依赖自动配置Spring应用上下文。它旨在合理猜测并配置你可能需要的bean，比如数据源、web服务器配置、模板引擎、安全配置等，从而减少手动配置的工作量。
2. 条件配置：自动配置不是盲目进行的，而是基于一系列条件判断（通过 @ConditionalOnClass、@ConditionalOnMissingBean 等注解实现）。只有当特定的类存在或缺失，或者满足其他特定条件时，相应的配置才会生效。这种机制确保了配置的灵活性和非侵入性。
3. 排除特定配置：尽管自动配置非常方便，但在某些情况下，你可能需要禁用特定的自动配置。可以通过在 application.properties 或 application.yml 文件中设置 spring.autoconfigure.exclude 来排除不需要的配置类，或者在 @EnableAutoConfiguration 注解中使用 exclude 属性来排除。
4. 与 @SpringBootApplication 的关系：实际上，@SpringBootApplication 注解是一个组合注解，它包含了 @SpringBootConfiguration, @EnableAutoConfiguration, 和 @ComponentScan 这三个注解。因此，当你在主类上使用 @SpringBootApplication 时，就已经默认启用了自动配置功能。
5. 自定义配置优先：尽管自动配置会自动添加bean，但你始终可以通过提供自己的bean定义来覆盖这些自动配置。Spring Boot 的设计原则之一就是“你编写的任何配置都将自动胜过自动配置”。

1.3. @ImportResource

加载xml配置，一般是放在启动main类上

@ImportResource("classpath*:/spring/*.xml")  单个

@ImportResource({"classpath*:/spring/1.xml","classpath*:/spring/2.xml"})   多个

@ImportResource 是 Spring 框架提供的一个注解，用于在 Spring 容器中导入 XML 配置文件。这个注解允许你在使用 Java配置类的同时，仍然引入传统的 XML 配置。当你在类上使用 @ImportResource 时，Spring 容器会在启动时加载指定的 XML 配置文件，并将其合并到当前的基于 Java 的配置中。

以下是 @ImportResource 的一些关键点：

1. 属性：主要有一个 locations 属性，用于指定 XML 配置文件的位置。你可以提供一个或多个资源路径，例如 classpath:/applicationContext.xml 或 classpath*:/config/*.xml。
2. 使用场景：在逐步迁移到 Spring Boot 的过程中，可能需要在新的 Java配置类中导入旧的 XML 配置。或者，如果有些特定功能或组件更适合用 XML 配置，也可以使用此注解。
3. 位置：通常，@ImportResource 注解会放在主配置类（即带有 @Configuration 注解的类）上。

注意事项：在 Spring Boot 中，由于其鼓励使用 Java配置和自动配置，所以使用 @ImportResource 可能是相对较少的情况。大多数情况下，可以通过 Java配置类和组件扫描实现相同的功能，但 XML 配置在某些特定场景下仍然是有用的。

1.4. @Value

application.properties定义属性，直接使用@Value注入即可

public class A{
	 @Value("${push.start:0}")    如果缺失，默认值为0
     private Long  id;
}

@Value 是 Spring 框架提供的一个注解，用于注入属性值到 Spring 组件（bean）的字段、方法或方法/构造函数参数。它可以用于注入简单的值（如字符串、数字、布尔值等）以及从外部配置文件（如 application.properties 或 application.yml）中读取的属性值。

以下是 @Value 的关键点：

基本用法：对于硬编码的简单值，可以直接在注解中指定，如 @Value(“Hello, World!”)。

1. SpEL 表达式支持：@Value 也支持 Spring Expression Language (SpEL) 表达式，例如 @Value(“#{systemProperties[‘java.version’]}”)，这可以获取系统属性 java.version 的值。
2. 属性文件注入：从 application.properties 或 application.yml 文件中注入值，使用 $propertyKey形式，如@Value("${my.property}")。这里的 my.property 是配置文件中的键。
3. 数组和集合注入：可以注入数组或集合类型，例如 @Value({“value1”, “value2”}) 或 @Value(“${list.property:#{null}}”)，其中 list.property 是配置文件中的键，如果没有设置默认值为 null。
4. 默认值：如果配置文件中没有指定的属性，可以提供一个默认值，如 @Value(“${my.property:defaultValue}”)，当 my.property 不存在时，将使用 defaultValue。

字段和方法注入：@Value 可以直接应用在字段上，也可以应用在带有参数的setter方法上，Spring 容器会在初始化bean时自动调用setter方法注入值。

1.5. @ConfigurationProperties(prefix=“person”)

可以新建一个properties文件，ConfigurationProperties的属性prefix指定properties的配置的前缀，通过location指定properties文件的位置

@ConfigurationProperties(prefix="person")
public class PersonProperties {
	
	private String name ;
	private int age;
}

@ConfigurationProperties 是 Spring Boot 提供的注解，用于将配置文件中的属性绑定到一个Java对象的字段上，实现了更高级别的属性绑定。prefix 参数用于指定配置文件中对应属性的前缀。

以下是 @ConfigurationProperties 的关键点：

1. 前缀绑定：prefix 参数指定了配置文件中属性的前缀，例如 @ConfigurationProperties(prefix = “person”) 将会匹配 application.properties 或 application.yml 中 person.* 属性。
2. 绑定对象：@ConfigurationProperties 注解通常应用在类级别，这个类的字段将与配置文件中的属性一一对应。字段名应与配置文件中的键匹配，例如 firstName 对应 person.firstName，lastName 对应 person.lastName。
3. 数据验证：通过使用 @Validated 或 javax.validation 注解（如 @NotNull, @Size 等）可以对绑定的对象进行数据验证。
4. 启用绑定：要使 @ConfigurationProperties 生效，你需要在主配置类上启用属性绑定，使用 @EnableConfigurationProperties 注解，并传入配置类的类名。
5. 自动装配：在 Spring Boot 中，如果配置类的类名遵循 XXXProperties 的模式（例如 PersonProperties），并且位于包名为 com.example.application.properties 或 com.example.application.config 的包下，那么 Spring Boot 会自动检测并装配这个配置类。

1.6. @EnableConfigurationProperties

用 @EnableConfigurationProperties注解使 @ConfigurationProperties生效，并从IOC容器中获取bean。

@EnableConfigurationProperties 是 Spring Boot 提供的注解，用于启用 @ConfigurationProperties 注解的属性绑定功能。这个注解通常用在主配置类或一个配置类上，它告诉 Spring Boot 将使用 @ConfigurationProperties 注解的类作为配置源，将配置文件中的属性值映射到这些类的字段上。

以下是 @EnableConfigurationProperties 的关键点：

1. 启用绑定：当 @EnableConfigurationProperties 注解应用于一个配置类时，它会启用属性绑定功能，允许你创建一个或多个类来封装配置文件中的属性，并将这些属性值注入到对应的字段中。
2. 注入对象：注解的参数通常是包含 @ConfigurationProperties 的类，例如 @EnableConfigurationProperties(PersonProperties.class)。这样，PersonProperties 类的实例就会被创建，并且其字段会被配置文件中的相应属性值填充。
3. 自动装配：如果 @ConfigurationProperties 注解的类遵循 XXXProperties 的命名模式（例如 MyProperties），并且位于 com.example.application.properties 或 com.example.application.config 包下，Spring Boot 会自动检测并装配这些类，无需显式使用 @EnableConfigurationProperties。
4. 自定义配置：如果你的 @ConfigurationProperties 类不在自动装配的包路径下，或者你希望显式指定配置类，就需要使用 @EnableConfigurationProperties 注解。
5. 全局启用：如果你在主配置类（通常带有 @SpringBootApplication 注解的类）上使用 @EnableConfigurationProperties 并且不指定类，那么 Spring Boot 会自动扫描并绑定所有 @ConfigurationProperties 注解的类。

@Configuration
@EnableConfigurationProperties({PersonProperties.class})
public class AppConfig {
    // ...
}

在这个例子中，AppConfig 类启用了 PersonProperties 类的配置属性绑定。PersonProperties 类应该包含 @ConfigurationProperties(prefix = "person") 注解，以与配置文件中的 person.* 属性相对应。

1.7. @RequestParam

public List<CopperVO> getOpList(HttpServletRequest request,
 @RequestParam(value = "pageIndex", required = false) Integer pageIndex,
 @RequestParam(value = "pageSize", required = false) Integer pageSize) {

}

1.8. @ResponseBody

支持将返回值放在response体内，而不是返回一个页面。比如Ajax接口，可以用此注解返回数据而不是页面。此注解可以放置在返回值前或方法前

另一个玩法，可以不用@ResponseBody。
继承FastJsonHttpMessageConverter类并对writeInternal方法扩展，在spring响应结果时，再次拦截、加工结果
// stringResult: json返回结果
//HttpOutputMessage outputMessage

 byte[] payload = stringResult.getBytes();
 outputMessage.getHeaders().setContentType(META_TYPE);
 outputMessage.getHeaders().setContentLength(payload.length);
 outputMessage.getBody().write(payload);
 outputMessage.getBody().flush();

@ResponseBody 是 Spring MVC 中的一个注解，用于将方法返回的对象转换成 JSON 或其他内容类型（如 XML），然后直接写入 HTTP 响应体，而不是填充到视图模型并进行视图渲染。这在处理 RESTful API 请求或返回数据而不是HTML页面时非常有用。

以下是 @ResponseBody 的关键点：

1. 内容协商：Spring MVC 会根据请求头中的 Accept 字段，选择合适的 HttpMessageConverter 来将方法返回的对象转换成客户端接受的内容类型。
2. 返回类型：@ResponseBody 通常与控制器方法的返回值结合使用，这个返回值可以是基本类型、字符串、Java 对象，甚至 Map 或 List。Spring MVC 会自动处理这些类型的转换。
3. 与 @Controller 结合：@ResponseBody 通常与 @Controller 或 @RestController 注解一起使用。@Controller 用于定义一个处理HTTP请求的类，而 @RestController 是 @Controller 和 @ResponseBody 的组合，意味着类中的每个方法默认都会返回一个响应体。
4. 避免视图解析：使用 @ResponseBody 的方法不会经过视图解析器，它直接将结果写入响应流，跳过了视图层，提高了效率。
5. 错误处理：如果在处理过程中出现异常，Spring MVC 会尝试将异常信息转换成一个响应体，除非你有自定义的异常处理器。

1.9. @Bean

@Bean(name=“bean的名字”,initMethod=“初始化时调用方法名字”,destroyMethod=“close”)

定义在方法上，在容器内初始化一个bean实例类。

@Bean(destroyMethod="close")
@ConditionalOnMissingBean
public PersonService registryService() {
		return new PersonService();
	}

@Bean 注解是 Spring 框架中的一个注解，主要用于在基于Java的配置中声明一个由Spring IoC容器管理的bean。它通常在配置类（带有 @Configuration 注解的类）的方法上使用。通过使用 @Bean，开发者可以明确地控制如何实例化、配置和初始化一个对象，然后将其注册为Spring应用上下文中的一个bean。

以下是关于 @Bean 的关键点：

1. 声明bean：在配置类的方法上使用 @Bean 注解，该方法的返回值就是将要注册为bean的对象实例。Spring容器负责调用该方法并管理返回的对象生命周期。
2. 依赖注入：@Bean 方法内可以使用 @Autowired 或构造器注入等机制来注入其他bean，这有助于组织和管理bean之间的依赖关系。
3. 初始化与销毁：可以通过实现 InitializingBean、DisposableBean 接口，或者使用 @PostConstruct 和 @PreDestroy 注解来定制bean的初始化和销毁逻辑。
4. 命名bean：默认情况下，@Bean 方法的名称成为bean的名称，但可以通过 @Bean(name = “customName”) 来自定义bean的名称。
5. 配置参数：可以在 @Bean 方法中接收外部配置（如通过 @Value 注入），从而使得bean的配置更加灵活。
6. 作用域：默认情况下，由 @Bean 定义的bean是单例的（Singleton）。可以通过 @Scope(“prototype”) 改变bean的作用域。

1.10. @Service @Controller @Repository @Component

标识型注解

1.11. @PostConstruct

spring容器初始化时，要执行该方法

@PostConstruct  
public void init() {   
}  

@PostConstruct 是 Java EE（Jakarta EE）规范中提供的一个注解，用于标记在bean初始化完成后需要执行的方法。这个注解可以被应用在任何受管理的bean（比如由Spring管理的bean）上的非静态方法上。当bean的依赖注入完成后，容器会在将bean放入服务之前调用标记了 @PostConstruct 的方法。

以下是关于 @PostConstruct 的关键点：

1. 初始化回调：它提供了一个回调入口点，让你能够在bean完全初始化之后执行一些额外的初始化逻辑，比如资源初始化、数据加载或额外的配置设置等。
2. 执行时机：@PostConstruct 注解的方法会在依赖注入完成后，且在该bean被任何其他bean使用之前执行。这是bean生命周期中的一个关键时刻，此时bean的所有依赖都已经准备就绪。
3. 非Spring特定：尽管这里讨论的是在Spring框架中的应用，但要注意 @PostConstruct 是Java EE（现为Jakarta EE）的一部分，因此它也适用于其他遵循Java EE规范的容器，如WildFly、WebLogic等。
4. 替代方案：在Spring框架中，除了 @PostConstruct，还可以使用 InitializingBean 接口的 afterPropertiesSet() 方法，或者通过 @PostConstruct 的Spring专有替代品 @EventListener(ApplicationReadyEvent.class) 来实现类似的功能。
5. 使用限制：@PostConstruct 方法不能声明为抛出已检查异常（checked exception），只能抛出未检查异常（unchecked exception）

1.12. @PathVariable

用来获得请求url中的动态参数

@Controller  
public class TestController {  

     @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET)  
     public String getLogin(@PathVariable("userId") String userId,  
         @PathVariable("roleId") String roleId){
           
         System.out.println("User Id : " + userId);  
         System.out.println("Role Id : " + roleId);  
         return "hello";  
     
     }  
}

1.13. @ComponentScan

注解会告知Spring扫描指定的包来初始化Spring

@ComponentScan(basePackages = "com.bbs.xx")

@ComponentScan 是 Spring 框架中的注解，用于指示 Spring 容器在指定的包及其子包下查找并注册 @Component、@Service、@Repository 和 @Controller 等注解的类，将它们作为bean进行管理。这使得Spring能够自动发现和管理这些组件，而无需显式配置每个bean。

以下是 @ComponentScan 的关键点：

1. 基包扫描：basePackages 或 basePackageClasses 属性用于指定要扫描的包。例如，@ComponentScan(basePackages = {“com.example.myapp”}) 将扫描 com.example.myapp 包及其所有子包。
2. 组件扫描：扫描到的类将根据它们的注解被分类，@Component 作为基础注解，@Service、@Repository 和 @Controller 分别代表不同的组件角色，如业务逻辑层、数据访问层和控制层。
3. 过滤：可以使用 includeFilters 和 excludeFilters 属性来指定哪些类需要被扫描，哪些类需要被忽略。这通常通过自定义过滤规则（如 @Filter 注解）来实现。
4. 组件别名：通过 @ComponentScan 的 nameGenerator 属性，可以自定义bean的别名生成策略。
5. 配置类：@ComponentScan 通常与 @Configuration 注解一起使用，定义在主配置类上，以启动组件扫描并创建bean定义。

1.14. @EnableZuulProxy

路由网关的主要目的是为了让所有的微服务对外只有一个接口，我们只需访问一个网关地址，即可由网关将所有的请求代理到不同的服务中。Spring Cloud是通过Zuul来实现的，支持自动路由映射到在Eureka Server上注册的服务。Spring Cloud提供了注解@EnableZuulProxy来启用路由代理。

1.15. @Autowired

在默认情况下使用 @Autowired 注释进行自动注入时，Spring 容器中匹配的候选 Bean 数目必须有且仅有一个。当找不到一个匹配的 Bean 时，Spring 容器将抛出 BeanCreationException 异常，并指出必须至少拥有一个匹配的 Bean。

当不能确定 Spring 容器中一定拥有某个类的 Bean 时，可以在需要自动注入该类 Bean 的地方可以使用 @Autowired(required = false)，这等于告诉 Spring: 在找不到匹配 Bean 时也不报错

@Autowired 是 Spring 框架中的一个注解，用于实现依赖注入（Dependency Injection, DI）。它可以帮助Spring容器自动将所需的bean注入到字段、构造函数或方法中，从而减少了硬编码的依赖关系，增强了代码的可测试性和可维护性。

以下是关于 @Autowired 的关键点：

1. 自动装配：Spring容器会自动寻找与需要注入的字段或参数类型相匹配的bean，并自动完成注入。这意味着你不需要编写显式的bean查找或依赖设置代码。
2. 位置无关性：@Autowired 可以应用于字段、构造函数、setter方法或具有任意名称和多个参数的方法上。对于字段和方法，它默认按照类型匹配进行注入；对于多个候选bean的情况，可以通过 @Qualifier 注解进一步指定具体的bean名称。
3. 构造函数注入：特别地，当使用构造函数注入时，即使没有显式标注 @Autowired，Spring也会尝试使用构造函数注入，只要构造函数的参数都可以通过类型匹配找到对应的bean。
4. 可选性：默认情况下，@Autowired 标注的字段或方法是必须注入的，如果找不到匹配的bean，Spring会抛出异常。但可以通过设置 required=false 来标记为可选注入，这时如果找不到匹配的bean，则该字段或参数将被置为 null。
5. 泛型支持：@Autowired 也支持泛型类型匹配，但需要注意的是，泛型信息在运行时会被擦除，因此直接基于泛型的注入可能无法工作，通常需要配合其他机制，如 @Qualifier 或自定义的

1.16. @Configuration

@Configuration("name")//表示这是一个配置信息类,可以给这个配置类也起一个名称
@ComponentScan("spring4")//类似于xml中的<context:component-scan base-package="spring4"/>
public class Config {

    @Autowired//自动注入，如果容器中有多个符合的bean时，需要进一步明确
    @Qualifier("compent")//进一步指明注入bean名称为compent的bean
    private Compent compent;

    @Bean//类似于xml中的<bean id="newbean" class="spring4.Compent"/>
    public Compent newbean(){
        return new Compent();
    }   
}

1.17. @Import(Config1.class)

@Configuration
public class CDConfig {

    @Bean   // 将SgtPeppers注册为 SpringContext中的bean
    public CompactDisc compactDisc() {
        return new CompactDisc();  // CompactDisc类型的
    }
}

@Configuration
@Import(CDConfig.class)  //导入CDConfig的配置
public class CDPlayerConfig {

    @Bean(name = "cDPlayer")
    public CDPlayer cdPlayer(CompactDisc compactDisc) {  
         // 这里会注入CompactDisc类型的bean
         // 这里注入的这个bean是CDConfig.class中的CompactDisc类型的那个bean
        return new CDPlayer(compactDisc);
    }
}

@Import 是 Spring 框架中的一个注解，用于引入其他配置类。这个注解允许你在当前配置类中引用其他配置类，使得它们的配置生效，而不需要在XML配置文件中显式声明。这在使用Java配置时尤其有用，可以将相关的配置分散到多个类中，提高代码的可读性和可维护性。

以下是 @Import 的关键点：

1. 引入配置：@Import 注解的参数是一个或多个配置类的类名。当Spring容器处理当前配置类时，它会把导入的配置类也一并处理，如同它们在同一个配置文件中。
2. 模块化配置：通过 @Import，可以将配置职责分解到多个类中，每个类专注于一个特定的领域，如数据访问、服务层、安全配置等。
3. 导入Bean定义：被导入的配置类可以定义自己的bean，这些bean会被合并到当前配置类的bean定义中。
4. 简化XML配置：在基于XML的配置中，可以使用 标签达到类似的效果，而 @Import 则是Java配置的对应方式。
5. 导入特定的bean：如果只需要导入某个特定的bean，可以使用 @ImportResource 注解，它允许导入XML配置文件。

1.18. @Order

@Order(1)，值越小优先级超高，越先运行 s

1.19. @ConditionalOnExpression

@Configuration
@ConditionalOnExpression("${enabled:false}")
public class BigpipeConfiguration {
    @Bean
    public OrderMessageMonitor orderMessageMonitor(ConfigContext configContext) {
        return new OrderMessageMonitor(configContext);
    }
}

开关为true的时候才实例化bean

@ConditionalOnExpression 是 Spring Boot 提供的一个条件注解，用于基于SpEL（Spring Expression Language）表达式的评估结果来决定是否创建一个特定的bean或是否启用某个配置。这使得bean的创建或配置的激活可以根据运行时环境或配置属性的值动态决定。

以下是关于 @ConditionalOnExpression 的关键点：

1. 条件判断：该注解接受一个SpEL表达式作为参数，Spring在启动时会计算这个表达式。如果表达式评估为 true，则对应的bean或配置将会被处理；如果为 false，则忽略。
2. SpEL表达式：SpEL表达式可以访问环境变量、配置属性、系统属性等，支持逻辑运算符、比较运算符、函数调用等，非常灵活。
3. 动态配置：通过这种方式，可以实现更细粒度的配置控制，比如根据不同的环境（开发、测试、生产）或特定条件启用或禁用某些功能。
4. 用法：此注解可以应用于类级别、方法级别（如 @Bean 方法）或配置类级别

这个注解使用的时候要搭配 @Autowired(required = false) 来用, 这样即使没有这个 Bean 也不会报错

1.20. @ConditionalOnProperty

这个注解能够控制某个 @Configuration 是否生效。具体操作是通过其两个属性name以及havingValue来实现的，其中name用来从application.properties中读取某个属性值，如果该值为空，则返回false;如果值不为空，则将该值与havingValue指定的值进行比较，如果一样则返回true;否则返回false。如果返回值为false，则该configuration不生效；为true则生效。

@Configuration
@ConditionalOnProperty(name = "database.enabled", havingValue = "true")
public class DatabaseConfig {
}

ConditionalOnProperty 是 Spring Boot 提供的另一个条件注解，用于基于特定的配置属性来决定是否创建一个bean或是否启用某个配置。这个注解允许你根据应用的配置属性值来控制bean的创建，提供了一种简洁的方式来实现条件化配置。

以下是关于 @ConditionalOnProperty 的关键点：

1. 属性检查：该注解允许你指定一个或多个属性名称，只有当这些属性在配置中存在并且值满足条件时，对应的bean或配置才会生效。
2. 属性值：你可以指定一个预期的属性值，如果属性值与预期值相等，那么条件成立。也可以不指定预期值，只检查属性是否存在。
3. 前缀支持：通常，Spring Boot 应用的属性都有前缀，如 spring.datasource.url。在 @ConditionalOnProperty 中，你可以指定前缀，如 spring.datasource，然后只提供属性的剩余部分，如 url。
4. 条件控制：可以使用 havingValue 方法来指定期望的属性值，或者使用 matchIfMissing 方法来控制如果属性不存在时的行为。

---

场景描述 : 可以在配置文件中配置具体使用哪种登录方式, 根据不同的登录方式启用不同的配置或者 Service

# 登录方式
login:
  method:
    name: wechat
# 默认配置
default:
  config:
    login:
      username: admin
      password: 123456

wechat:
  config:
    login:
      wechat-no: 15565946702
      wechat-secret: 9f0f0e9f0f0e9f0f0e9f0f0e9f0f0e9f0f0e
@Configuration
@ConditionalOnProperty(name = "login.method.name" , havingValue = "default")
@ConfigurationProperties(prefix = "default.config.login")
@Data
public class DefaultLoginConfig {

    private String username;
    private String password;
}


@Configuration
@ConditionalOnProperty(name = "login.method.name" , havingValue = "wechat")
@ConfigurationProperties(prefix = "wechat.config.login")
@Data
public class WeChatLoginConfig {

    private String wechatNo;
    private String wechatSecret;
}

@ConditionalOnProperty(name = "login.method.name" , havingValue = "wechat") 根据具体的配置信息决定要将哪个 Bean 注册到 Spring 容器中

public interface AccountService {

    String login();
}

@Component
@ConditionalOnProperty(name = "login.method.name" , havingValue = "default")
public class AccountServiceImpl implements AccountService{

    @Resource
    DefaultLoginConfig defaultLoginConfig;

    @Override
    public String login() {
        System.out.println("AccountServiceImpl login ... ");
        return "AccountServiceImpl login ... " + defaultLoginConfig.getUsername() +":" + defaultLoginConfig.getPassword() ;
    }
}


@Component
@ConditionalOnProperty(name = "login.method.name" , havingValue = "wechat")
public class AccountWeChatServiceImpl implements AccountService{

    @Resource
    private WeChatLoginConfig config;

    @Override
    public String login() {
        System.out.println("AccountWeChatServiceImpl login ... ");
        return "AccountWeChatServiceImpl login ... " + config.getWechatNo() + ":" + config.getWechatSecret();
    }
}

@Autowired(required = false)
AccountService accountService;

这样根据不同的配置来实现对应的功能

---

matchIfMissing 参数说明

• matchIfMissing = false**（默认值）**：当配置属性不存在时，相应的配置或 Bean 不会被加载。
• matchIfMissing = true：当配置属性不存在时，相应的配置或 Bean 会被加载

假设你有一个服务 ExampleService，希望根据配置属性 example.feature.enabled 的值来决定是否加载该服务。matchIfMissing = false 当 matchIfMissing 设置为 false（默认值），如果配置文件中没有 example.feature.enabled 属性，ExampleService 将不会被加载. 当 matchIfMissing 设置为 true，即使配置文件中没有 example.feature.enabled 属性，ExampleService 也会被加载

场景 1：默认启用功能

如果某个功能是默认启用的，只在某些情况下才需要显式禁用，则可以设置 matchIfMissing = true。这样即使没有配置该属性，该功能也会默认启用：

场景 2：默认禁用功能

如果某个功能是默认禁用的，只在需要时才启用，则可以保持 matchIfMissing = false（默认值）。这样只有在配置了该属性且值为 true 时，该功能才会启用：

1.21. @ConditionalOnClass

@ConditionalOnClass 是 Spring Boot 的一种条件注解，它用于在目标类存在的情况下才配置相应的 Bean。这个注解通常用于自动配置类上，确保只有当指定的类在应用类路径（classpath）中存在时，该自动配置类才会生效。

以下是 @ConditionalOnClass 注解的一些关键点：

1. 作用：决定一个 Bean 是否应该被添加到 Spring 容器中。如果注解中指定的类在类路径中找到，那么包含该注解的 Bean 将会被创建并注册到 Spring 容器。否则，该 Bean 不会被注册。
2. 参数：value 参数是一个或多个类的全限定名（FQN）。如果这些类全部存在于类路径中，那么条件满足。
3. 应用场景：常用于自动配置场景，例如，如果你有一个自动配置类想要配置某个特定的第三方库，但你希望这个配置只在应用已经包含了该库的情况下生效，就可以使用 @ConditionalOnClass。
4. 与 @ConditionalOnMissingClass 区别：@ConditionalOnMissingClass 是相反的情况，它表示只有当指定的类不在类路径中时，Bean 才会被注册。
5. 配合使用：@ConditionalOnClass 可以和 @ConditionalOnProperty，@ConditionalOnWebApplication 等其他条件注解一起使用，以实现更复杂的条件判断

@Configuration
@ConditionalOnClass(WebSocket.class) // 如果 WebSocket 类存在，则配置生效
public class WebSocketConfig {
    // ...
}

在这个例子中，WebSocketConfig 类中的配置只会当 WebSocket 类在类路径中时被激活。如果 WebSocket 类不存在，那么 Spring 将不会创建或处理 WebSocketConfig 中定义的任何 Bean。

1.22. @ConditionalOnMisssingClass

@ConditionalOnMissingClass 是 Spring Boot 的另一个条件注解，它用于在目标类不存在的情况下才配置相应的 Bean。这个注解通常用在自动配置类上，确保只有当指定的类不在应用类路径（classpath）中时，该自动配置类才会生效。比如默认 xxx 配置不存在的时候自动启用默认配置

以下是 @ConditionalOnMissingClass 注解的关键点：

1. 作用：与 @ConditionalOnClass 相反，它会检查类路径中是否存在指定的类，如果这些类不存在，那么包含该注解的 Bean 将会被创建并注册到 Spring 容器。
2. 参数：value 参数是一个或多个类的全限定名（FQN）。如果这些类全部不在类路径中，那么条件满足，Bean 会被注册。
3. 应用场景：常用于自动配置场景，当你希望在应用没有依赖某些特定库或者没有特定类时进行某些配置，可以使用此注解。
4. 与 @ConditionalOnClass 区别：@ConditionalOnClass 是在类存在时生效，而 @ConditionalOnMissingClass 是在类不存在时生效。
5. 配合使用：可以与其他条件注解一起使用，以实现更复杂的逻辑判断。

@Configuration
@ConditionalOnMissingClass({ApplicationManager.class})
public class AlternativeConfig {
    // ...
}

在这个例子中，AlternativeConfig 类中的配置只有当 ApplicationManager 类不在类路径中时才会生效。如果 ApplicationManager 类存在，那么 Spring 将不会创建或处理 AlternativeConfig 中定义的任何 Bean。这可能是因为存在一个备用的或替代的配置，当主要的 ApplicationManager 类不可用时使用。

1.23. @ConditionalOnMissingBean

@ConditionalOnMissingBean。这是 Spring Framework 提供的一个条件注解，用于基于容器中是否缺少某个特定名称或类型的 Bean 来决定是否创建一个新的 Bean。下面是关于 @ConditionalOnMissingBean 的一些关键信息：

1. 作用：此注解用于确保只有当 Spring 应用上下文中不存在指定名称或类型的 Bean 时，才执行配置类中的 Bean 定义方法或整个配置类。

2. 参数:

3. 1. name：指定要检查的 Bean 名称。如果提供了名称，那么只有当具有该确切名称的 Bean 不存在时，条件才满足。
   2. value 或 type：指定要检查的 Bean 类型。如果类型匹配的 Bean 不存在，则条件满足。value 是 type 的别名。
   3. annotation：可选参数，用于检查是否存在具有特定注解的 Bean。
   4. 其他参数还包括 search（搜索模式）等，用于细粒度控制 Bean 的查找范围。

4. 应用场景：此注解常用于避免重复的 Bean 定义，比如在自动配置场景下，当用户可能已经自定义了某个 Bean 时，框架提供的默认配置就不会覆盖用户的配置。

@Configuration
public class MyAutoConfiguration {

   @Bean
   @ConditionalOnMissingBean(name = "example")
   public ExampleBean exampleBean() {
       return new ExampleBean();
   }
}
   

在这个例子中，exampleBean 方法只有在当前应用上下文中没有名为 “example” 的 Bean 时才会被调用，从而创建并注册一个新的 ExampleBean 实例。

2. 参考

SpringBoot入门 - 开发中还有哪些常用注解