Spring Boot提供了多种条件装配技术，允许开发者根据不同条件动态配置应用程序，大大提高了应用的灵活性，本文将介绍Spring Boot中四种常用的条件装配技术。

一、@Conditional注解及派生注解

1. 基本原理

@Conditional注解是Spring 4引入的核心条件装配机制，它允许开发者根据特定条件来决定是否创建某个Bean或启用某个配置。

@Conditional的基本工作原理是：当Spring容器处理带有@Conditional注解的Bean定义时，会先评估指定的条件是否满足，只有当条件满足时，才会创建Bean或应用配置。

2. @Conditional基本用法

使用@Conditional注解时，需要指定一个实现了Condition接口的条件类：

public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

自定义条件类示例：

public class LinuxCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment env = context.getEnvironment();
        String os = env.getProperty("os.name");
        return os != null && os.toLowerCase().contains("linux");
    }
}

public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment env = context.getEnvironment();
        String os = env.getProperty("os.name");
        return os != null && os.toLowerCase().contains("windows");
    }
}

然后，使用这些条件类来决定Bean的创建：

@Configuration
public class OperatingSystemConfig {

    @Bean
    @Conditional(LinuxCondition.class)
    public CommandService linuxCommandService() {
        return new LinuxCommandService();
    }

    @Bean
    @Conditional(WindowsCondition.class)
    public CommandService windowsCommandService() {
        return new WindowsCommandService();
    }
}

上面的配置会根据运行环境的操作系统类型，创建不同的CommandService实现。

3. 常用派生注解

Spring Boot提供了一系列基于@Conditional的派生注解，简化了常见条件判断的配置：

@ConditionalOnClass/@ConditionalOnMissingClass

根据类路径中是否存在特定类来决定配置：

@Configuration
public class JpaConfig {

    @Bean
    @ConditionalOnClass(name = "javax.persistence.EntityManager")
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        // 只有当类路径中存在JPA相关类时，才创建此Bean
        return new LocalContainerEntityManagerFactoryBean();
    }

    @Bean
    @ConditionalOnMissingClass("javax.persistence.EntityManager")
    public JdbcTemplate jdbcTemplate() {
        // 当类路径中不存在JPA相关类时，采用JdbcTemplate
        return new JdbcTemplate();
    }
}

@ConditionalOnBean/@ConditionalOnMissingBean

根据容器中是否存在特定Bean来决定配置：

@Configuration
public class DataSourceConfig {

    @Bean
    @ConditionalOnMissingBean
    public DataSource defaultDataSource() {
        // 当容器中没有DataSource类型的Bean时，创建默认数据源
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .build();
    }

    @Bean
    @ConditionalOnBean(name = "customDataSourceProperties")
    public DataSource customDataSource(CustomDataSourceProperties properties) {
        // 当存在名为customDataSourceProperties的Bean时，创建自定义数据源
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(properties.getUrl());
        dataSource.setUsername(properties.getUsername());
        dataSource.setPassword(properties.getPassword());
        return dataSource;
    }
}

@ConditionalOnProperty

根据配置属性的值来决定配置：

@Configuration
public class CacheConfig {

    @Bean
    @ConditionalOnProperty(name = "cache.type", havingValue = "redis")
    public CacheManager redisCacheManager() {
        // 当cache.type属性值为redis时，配置Redis缓存管理器
        return new RedisCacheManager();
    }

    @Bean
    @ConditionalOnProperty(name = "cache.type", havingValue = "ehcache")
    public CacheManager ehCacheManager() {
        // 当cache.type属性值为ehcache时，配置EhCache缓存管理器
        return new EhCacheCacheManager();
    }

    @Bean
    @ConditionalOnProperty(name = "cache.enabled", havingValue = "false", matchIfMissing = true)
    public CacheManager noOpCacheManager() {
        // 当cache.enabled为false或未设置时，使用空操作缓存管理器
        return new NoOpCacheManager();
    }
}

@ConditionalOnExpression

根据SpEL表达式的结果来决定配置：

@Configuration
public class SecurityConfig {

    @Bean
    @ConditionalOnExpression("${security.enabled:true} and ${security.type:basic} == 'oauth2'")
    public SecurityFilterChain oauth2SecurityFilterChain(HttpSecurity http) throws Exception {
        // 当security.enabled为true且security.type为oauth2时生效
        return http
                .oauth2Login()
                .and()
                .build();
    }

    @Bean
    @ConditionalOnExpression("${security.enabled:true} and ${security.type:basic} == 'basic'")
    public SecurityFilterChain basicSecurityFilterChain(HttpSecurity http) throws Exception {
        // 当security.enabled为true且security.type为basic时生效
        return http
                .httpBasic()
                .and()
                .build();
    }
}

@ConditionalOnWebApplication/@ConditionalOnNotWebApplication

根据应用是否为Web应用来决定配置：

@Configuration
public class ServerConfig {

    @Bean
    @ConditionalOnWebApplication
    public ServletWebServerFactory servletWebServerFactory() {
        // 只有在Web应用中才创建此Bean
        return new TomcatServletWebServerFactory();
    }

    @Bean
    @ConditionalOnNotWebApplication
    public ApplicationRunner consoleRunner() {
        // 只有在非Web应用中才创建此Bean
        return args -> System.out.println("Running as a console application");
    }
}

4. 实战示例：构建适应不同缓存环境的应用

下面通过一个实际例子，展示如何使用@Conditional系列注解构建一个能够适应不同缓存环境的应用：

@Configuration
public class FlexibleCacheConfiguration {

    @Bean
    @ConditionalOnClass(name = "org.springframework.data.redis.core.RedisTemplate")
    @ConditionalOnProperty(name = "cache.type", havingValue = "redis")
    @ConditionalOnMissingBean(CacheManager.class)
    public CacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheManager.RedisCacheManagerBuilder builder = 
            RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(redisConnectionFactory);
        
        return builder.build();
    }

    @Bean
    @ConditionalOnClass(name = "org.ehcache.jsr107.EhcacheCachingProvider")
    @ConditionalOnProperty(name = "cache.type", havingValue = "ehcache")
    @ConditionalOnMissingBean(CacheManager.class)
    public CacheManager ehCacheCacheManager() {
        return new JCacheCacheManager(getJCacheCacheManager());
    }

    @Bean
    @ConditionalOnProperty(
        name = "cache.type", 
        havingValue = "simple", 
        matchIfMissing = true
    )
    @ConditionalOnMissingBean(CacheManager.class)
    public CacheManager simpleCacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(Arrays.asList(
            new ConcurrentMapCache("users"),
            new ConcurrentMapCache("transactions"),
            new ConcurrentMapCache("products")
        ));
        return cacheManager;
    }

    @Bean
    @ConditionalOnProperty(name = "cache.enabled", havingValue = "false")
    @ConditionalOnMissingBean(CacheManager.class)
    public CacheManager noOpCacheManager() {
        return new NoOpCacheManager();
    }
    
    private javax.cache.CacheManager getJCacheCacheManager() {
        // 创建JCache CacheManager的逻辑...
        return null; // 实际代码需要返回真实的CacheManager
    }
}

在上面的配置中：

• 如果类路径中有Redis相关类，且配置了cache.type=redis，则使用Redis缓存
• 如果类路径中有EhCache相关类，且配置了cache.type=ehcache，则使用EhCache
• 如果配置了cache.type=simple或未指定类型，则使用简单的内存缓存
• 如果配置了cache.enabled=false，则使用不执行任何缓存操作的NoOpCacheManager

5. 优缺点分析

优点：

• 灵活强大，能适应几乎所有条件判断场景
• 与Spring生态系统无缝集成
• 派生注解简化了常见场景的配置
• 条件判断逻辑与业务逻辑分离，保持代码清晰

缺点：

• 复杂条件可能导致配置难以理解和调试
• 条件装配的顺序可能影响最终的Bean定义

二、Profile条件配置

1. 基本原理

Profile是Spring提供的另一种条件装配机制，主要用于按环境（如开发、测试、生产）管理Bean的创建。与@Conditional相比，Profile更专注于环境区分，配置更简单。

2. @Profile注解用法

使用@Profile注解标记Bean或配置类，指定它们在哪些Profile激活时才会被创建：

@Configuration
public class DataSourceConfig {

    @Bean
    @Profile("development")
    public DataSource developmentDataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.H2)
                .build();
    }

    @Bean
    @Profile("production")
    public DataSource productionDataSource() {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/proddb");
        dataSource.setUsername("produser");
        dataSource.setPassword("prodpass");
        return dataSource;
    }
}

也可以在配置类级别应用@Profile注解，控制整个配置类的激活：

@Configuration
@Profile("development")
public class DevelopmentConfig {
    // 开发环境特有的Bean定义...
}

@Configuration
@Profile("production")
public class ProductionConfig {
    // 生产环境特有的Bean定义...
}

3. 激活Profile的方式

有多种方式可以激活指定的Profile：

通过配置文件

在application.properties或application.yml中：

# application.properties
spring.profiles.active=development

或

# application.yml
spring:
  profiles:
    active: development

通过命令行参数

java -jar myapp.jar --spring.profiles.active=production

通过环境变量

export SPRING_PROFILES_ACTIVE=production
java -jar myapp.jar

通过代码激活

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyApplication.class);
        app.setAdditionalProfiles("production");
        app.run(args);
    }
}

4. Profile组合与否定

Spring Boot 2.4及以上版本提供了更灵活的Profile表达式：

使用Profile组

# application.properties
spring.profiles.group.production=proddb,prodmq
spring.profiles.group.development=devdb,devmq

上面的配置定义了两个Profile组：当激活"production"时，会同时激活"proddb"和"prodmq"；当激活"development"时，会同时激活"devdb"和"devmq"。

使用否定表达式

@Bean
@Profile("!development")
public MonitoringService productionMonitoringService() {
    return new DetailedMonitoringService();
}

上面的配置表示，除了"development"之外的所有Profile都会创建这个Bean。

5. 实战示例：基于Profile的消息队列配置

下面通过一个实际例子，展示如何使用Profile来配置不同环境的消息队列连接：

@Configuration
public class MessagingConfig {

    @Bean
    @Profile("local")
    public ConnectionFactory localConnectionFactory() {
        // 本地开发使用内嵌的ActiveMQ
        return new ActiveMQConnectionFactory("vm://localhost?broker.persistent=false");
    }

    @Bean
    @Profile("dev")
    public ConnectionFactory devConnectionFactory() {
        // 开发环境使用开发服务器上的RabbitMQ
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost("dev-rabbitmq.example.com");
        connectionFactory.setUsername("dev_user");
        connectionFactory.setPassword("dev_pass");
        return connectionFactory;
    }

    @Bean
    @Profile("prod")
    public ConnectionFactory prodConnectionFactory() {
        // 生产环境使用生产级RabbitMQ集群
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses("prod-rabbitmq-1.example.com,prod-rabbitmq-2.example.com");
        connectionFactory.setUsername("prod_user");
        connectionFactory.setPassword("prod_pass");
        // 生产环境增加额外配置
        connectionFactory.setPublisherConfirms(true);
        connectionFactory.setPublisherReturns(true);
        return connectionFactory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        // 通用的RabbitTemplate配置，使用当前Profile对应的ConnectionFactory
        return new RabbitTemplate(connectionFactory);
    }
}

结合特定环境的配置文件：

# application-local.yml
spring:
  rabbitmq:
    listener:
      simple:
        concurrency: 1
        max-concurrency: 5

# application-dev.yml
spring:
  rabbitmq:
    listener:
      simple:
        concurrency: 5
        max-concurrency: 10

# application-prod.yml
spring:
  rabbitmq:
    listener:
      simple:
        concurrency: 10
        max-concurrency: 50
        retry:
          enabled: true
          initial-interval: 5000
          max-attempts: 3

6. 优缺点分析

优点：

• 使用简单直观，专门为环境区分设计
• 与Spring Boot配置系统完美集成
• 支持组合和否定表达式，增强表达能力
• 可以通过多种方式切换Profile，适应不同部署场景

缺点：

• 表达能力有限，不如@Conditional注解灵活
• 主要基于预定义的命名环境，处理动态条件能力较弱

三、自动配置条件

1. 基本原理

自动配置是Spring Boot的核心特性之一，它允许框架根据类路径、已有Bean和配置属性等条件，自动配置应用程序。自动配置条件是实现这一功能的基础，它通过组合使用多种条件注解，实现复杂的条件判断逻辑。

2. 常用自动配置条件组合

在Spring Boot的自动配置类中，经常可以看到多种条件注解的组合使用：

@Configuration
@ConditionalOnClass(DataSource.class)
@ConditionalOnMissingBean(DataSource.class)
@ConditionalOnProperty(prefix = "spring.datasource", name = "enabled", matchIfMissing = true)
public class DataSourceAutoConfiguration {
    // 数据源自动配置...
}

上面的配置表示：

• 只有当类路径中存在DataSource类
• 且容器中没有DataSource类型的Bean
• 且spring.datasource.enabled属性不存在或为true时
• 才会启用这个自动配置类

3. 自定义自动配置类

开发者可以创建自己的自动配置类，使用条件注解控制其激活条件：

@Configuration
@ConditionalOnClass(RedisTemplate.class)
@ConditionalOnMissingBean(CacheManager.class)
@ConditionalOnProperty(prefix = "mycache", name = "type", havingValue = "redis")
@EnableConfigurationProperties(MyCacheProperties.class)
public class RedisCacheAutoConfiguration {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory,
                                   MyCacheProperties properties) {
        RedisCacheManager.RedisCacheManagerBuilder builder = 
            RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(redisConnectionFactory);
        
        if (properties.getExpireTime() > 0) {
            builder.cacheDefaults(RedisCacheConfiguration.defaultCacheConfig()
                    .entryTtl(Duration.ofSeconds(properties.getExpireTime())));
        }
        
        return builder.build();
    }
}

配置属性类：

@ConfigurationProperties(prefix = "mycache")
public class MyCacheProperties {
    
    private String type;
    private int expireTime = 3600;
    
    // getters and setters
}

4. 启用自动配置

要启用自定义的自动配置类，需要创建META-INF/spring.factories文件：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.config.RedisCacheAutoConfiguration

或者在Spring Boot 2.7及以上版本，可以使用
META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件：

com.example.config.RedisCacheAutoConfiguration

5. 自动配置顺序控制

在复杂系统中，可能需要控制自动配置类的加载顺序，这可以通过@AutoConfigureBefore、@AutoConfigureAfter和@AutoConfigureOrder注解实现：

@Configuration
@ConditionalOnClass(DataSource.class)
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class JdbcTemplateAutoConfiguration {
    // JDBC模板自动配置，确保在数据源配置之后
}

@Configuration
@ConditionalOnClass(SecurityFilterChain.class)
@AutoConfigureBefore(WebMvcAutoConfiguration.class)
public class SecurityAutoConfiguration {
    // 安全配置应该在Web MVC配置之前
}

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
public class EarlyInitAutoConfiguration {
    // 需要最先初始化的配置
}

6. 实战示例：自定义监控系统自动配置

下面通过一个实际例子，展示如何使用自动配置条件创建一个可插拔的应用监控组件：

// 配置属性类
@ConfigurationProperties(prefix = "app.monitoring")
public class MonitoringProperties {
    
    private boolean enabled = true;
    private String type = "jmx";
    private int sampleRate = 10;
    private boolean logMetrics = false;
    
    // getters and setters
}

// JMX监控自动配置
@Configuration
@ConditionalOnProperty(prefix = "app.monitoring", name = "enabled", havingValue = "true", matchIfMissing = true)
@ConditionalOnProperty(prefix = "app.monitoring", name = "type", havingValue = "jmx", matchIfMissing = true)
@ConditionalOnClass(name = "javax.management.MBeanServer")
@EnableConfigurationProperties(MonitoringProperties.class)
public class JmxMonitoringAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public MetricsCollector metricsCollector(MonitoringProperties properties) {
        JmxMetricsCollector collector = new JmxMetricsCollector();
        collector.setSampleRate(properties.getSampleRate());
        return collector;
    }
    
    @Bean
    @ConditionalOnMissingBean
    public MetricsExporter metricsExporter(MonitoringProperties properties) {
        JmxMetricsExporter exporter = new JmxMetricsExporter();
        exporter.setLogMetrics(properties.isLogMetrics());
        return exporter;
    }
}

// Prometheus监控自动配置
@Configuration
@ConditionalOnProperty(prefix = "app.monitoring", name = "enabled", havingValue = "true")
@ConditionalOnProperty(prefix = "app.monitoring", name = "type", havingValue = "prometheus")
@ConditionalOnClass(name = "io.prometheus.client.CollectorRegistry")
@EnableConfigurationProperties(MonitoringProperties.class)
public class PrometheusMonitoringAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public MetricsCollector metricsCollector(MonitoringProperties properties) {
        PrometheusMetricsCollector collector = new PrometheusMetricsCollector();
        collector.setSampleRate(properties.getSampleRate());
        return collector;
    }
    
    @Bean
    @ConditionalOnMissingBean
    public MetricsExporter metricsExporter(MonitoringProperties properties) {
        PrometheusMetricsExporter exporter = new PrometheusMetricsExporter();
        exporter.setLogMetrics(properties.isLogMetrics());
        return exporter;
    }
    
    @Bean
    public CollectorRegistry collectorRegistry() {
        return new CollectorRegistry(true);
    }
    
    @Bean
    public HttpHandler prometheusEndpoint(CollectorRegistry registry) {
        return new PrometheusHttpHandler(registry);
    }
}

// 日志监控自动配置
@Configuration
@ConditionalOnProperty(prefix = "app.monitoring", name = "enabled", havingValue = "true")
@ConditionalOnProperty(prefix = "app.monitoring", name = "type", havingValue = "log")
@EnableConfigurationProperties(MonitoringProperties.class)
public class LogMonitoringAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public MetricsCollector metricsCollector(MonitoringProperties properties) {
        LogMetricsCollector collector = new LogMetricsCollector();
        collector.setSampleRate(properties.getSampleRate());
        return collector;
    }
    
    @Bean
    @ConditionalOnMissingBean
    public MetricsExporter metricsExporter() {
        return new LogMetricsExporter();
    }
}

META-INF/spring.factories文件：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.monitoring.JmxMonitoringAutoConfiguration,\
com.example.monitoring.PrometheusMonitoringAutoConfiguration,\
com.example.monitoring.LogMonitoringAutoConfiguration

使用示例：

# 使用JMX监控(默认)
app:
  monitoring:
    enabled: true
    type: jmx
    sample-rate: 5
    log-metrics: true

# 或使用Prometheus监控
app:
  monitoring:
    enabled: true
    type: prometheus
    sample-rate: 10

# 或使用日志监控
app:
  monitoring:
    enabled: true
    type: log
    sample-rate: 30

# 或完全禁用监控
app:
  monitoring:
    enabled: false

7. 优缺点分析

优点：

• 实现真正的"约定优于配置"原则
• 可以创建可插拔的组件，极大提高代码复用性
• 与Spring Boot生态系统无缝集成

缺点：

• 学习曲线陡峭，需要了解多种条件注解的组合使用
• 自动配置类过多可能导致应用启动时间增加
• 调试困难，排查问题需要深入了解Spring Boot启动机制

八、总结

通过合理利用Spring Boot提供的条件装配技术，开发者可以构建出灵活、可配置的应用程序，满足不同环境和业务场景的需求。