在 Spring Boot 开发中，动态注入 Bean 是一种强大的技术，它允许我们根据特定条件或运行时环境灵活地创建和管理 Bean。

相比于传统的静态 Bean 定义，动态注入提供了更高的灵活性和可扩展性，特别适合构建可插拔的模块化系统和处理复杂的业务场景。

本文将介绍 Spring Boot 中三种动态 Bean 注入技巧。

一、条件化 Bean 配置

1.1 基本原理

条件化 Bean 配置是 Spring Boot 中最常用的动态注入方式，它允许我们根据特定条件决定是否创建 Bean。Spring Boot 提供了丰富的条件注解，可以基于类路径、Bean 存在情况、属性值、系统环境等因素动态决定 Bean 的创建。

1.2 常用条件注解

Spring Boot 提供了多种条件注解，最常用的包括：

• @ConditionalOnProperty：基于配置属性的条件
• @ConditionalOnBean：基于特定 Bean 存在的条件
• @ConditionalOnMissingBean：基于特定 Bean 不存在的条件
• @ConditionalOnClass：基于类路径上有指定类的条件
• @ConditionalOnMissingClass：基于类路径上没有指定类的条件
• @ConditionalOnExpression：基于 SpEL 表达式的条件
• @ConditionalOnWebApplication：基于是否是 Web 应用的条件
• @ConditionalOnResource：基于资源是否存在的条件

1.3 代码示例

下面是一个综合示例，展示如何使用条件注解动态注入不同的数据源 Bean：

@Configuration
public class DataSourceConfig {

    @Bean
    @ConditionalOnProperty(name = "datasource.type", havingValue = "mysql", matchIfMissing = true)
    public DataSource mysqlDataSource() {
        // 创建 MySQL 数据源
        return new MySQLDataSource();
    }

    @Bean
    @ConditionalOnProperty(name = "datasource.type", havingValue = "postgresql")
    public DataSource postgresqlDataSource() {
        // 创建 PostgreSQL 数据源
        return new PostgreSQLDataSource();
    }
    
    @Bean
    @ConditionalOnProperty(name = "datasource.type", havingValue = "mongodb")
    @ConditionalOnClass(name = "com.mongodb.client.MongoClient")
    public DataSource mongodbDataSource() {
        // 创建 MongoDB 数据源，但前提是类路径中有 MongoDB 驱动
        return new MongoDBDataSource();
    }
    
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource defaultDataSource() {
        // 如果没有其他数据源 Bean，创建默认数据源
        return new H2DataSource();
    }
}

在上面的例子中：

• 通过 datasource.type 属性值决定创建哪种数据源
• 如果属性不存在，默认创建 MySQL 数据源
• MongoDB 数据源只有在同时满足属性值条件和类路径条件时才会创建
• 如果所有条件都不满足，则创建默认的 H2 数据源

1.4 自定义条件注解

我们还可以创建自定义条件注解来满足特定业务需求：

// 自定义条件判断逻辑
public class OnEnvironmentCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 获取注解属性
        Map<String, Object> attributes = metadata.getAnnotationAttributes(
                ConditionalOnEnvironment.class.getName());
        String[] envs = (String[]) attributes.get("value");
        
        // 获取当前环境
        String activeEnv = context.getEnvironment().getProperty("app.environment");
        
        // 检查是否匹配
        for (String env : envs) {
            if (env.equalsIgnoreCase(activeEnv)) {
                return true;
            }
        }
        return false;
    }
}

// 自定义条件注解
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnEnvironmentCondition.class)
public @interface ConditionalOnEnvironment {
    String[] value() default {};
}

使用自定义条件注解：

@Configuration
public class EnvironmentSpecificConfig {

    @Bean
    @ConditionalOnEnvironment({"dev", "test"})
    public SecurityConfig developmentSecurityConfig() {
        return new DevelopmentSecurityConfig();
    }
    
    @Bean
    @ConditionalOnEnvironment({"prod", "staging"})
    public SecurityConfig productionSecurityConfig() {
        return new ProductionSecurityConfig();
    }
}

1.5 优缺点与适用场景

优点：

• 配置简单直观，易于理解和维护
• Spring Boot 原生支持，无需额外依赖
• 可组合多个条件，实现复杂的条件逻辑

缺点：

• 条件逻辑主要在编译时确定，运行时灵活性有限
• 对于非常复杂的条件逻辑，代码可能变得冗长

适用场景：

• 基于配置属性选择不同的实现
• 根据环境（开发、测试、生产）加载不同的 Bean
• 处理可选依赖和功能的条件性启用
• 构建可插拔的模块化系统

二、BeanDefinitionRegistryPostProcessor 动态注册 Bean

2.1 基本原理

BeanDefinitionRegistryPostProcessor 是 Spring 容器的扩展点之一，它允许我们在常规 Bean 定义加载完成后、Bean 实例化之前，动态修改应用上下文中的 Bean 定义注册表。

通过实现此接口，我们可以编程式地注册、修改或移除 Bean 定义。

2.2 接口说明

BeanDefinitionRegistryPostProcessor 接口继承自 BeanFactoryPostProcessor，并添加了一个额外的方法：

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}

2.3 代码示例

以下是一个使用
BeanDefinitionRegistryPostProcessor 动态注册服务实现的例子：

@Component
public class ServiceRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Autowired
    private Environment environment;

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 获取服务配置
        String[] serviceTypes = environment.getProperty("app.services.enabled", String[].class, new String[0]);
        
        // 动态注册服务 Bean
        for (String serviceType : serviceTypes) {
            registerServiceBean(registry, serviceType);
        }
    }
    
    private void registerServiceBean(BeanDefinitionRegistry registry, String serviceType) {
        // 根据服务类型确定具体实现类
        Class<?> serviceClass = getServiceClassByType(serviceType);
        if (serviceClass == null) {
            return;
        }
        
        // 创建 Bean 定义
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(serviceClass)
                .setScope(BeanDefinition.SCOPE_SINGLETON)
                .setLazyInit(false);
        
        // 注册 Bean 定义
        String beanName = serviceType + "Service";
        registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
    }
    
    private Class<?> getServiceClassByType(String serviceType) {
        switch (serviceType.toLowerCase()) {
            case "email":
                return EmailServiceImpl.class;
            case "sms":
                return SmsServiceImpl.class;
            case "push":
                return PushNotificationServiceImpl.class;
            default:
                return null;
        }
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 可以进一步处理已注册的 Bean 定义
    }
}

在上面的例子中，我们通过配置属性 app.services.enabled 来确定需要启用哪些服务，然后在
postProcessBeanDefinitionRegistry 方法中动态注册相应的 Bean 定义。

2.4 高级应用：动态模块加载

我们可以利用
BeanDefinitionRegistryPostProcessor 实现动态模块加载，例如：

@Component
public class DynamicModuleLoader implements BeanDefinitionRegistryPostProcessor {

    @Autowired
    private ResourceLoader resourceLoader;
    
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        try {
            // 获取模块目录
            Resource[] resources = resourceLoader.getResource("classpath:modules/")
                    .getURL().listFiles();
            
            if (resources != null) {
                for (Resource moduleDir : resources) {
                    // 加载模块配置
                    Properties moduleProps = loadModuleProperties(moduleDir);
                    if (Boolean.parseBoolean(moduleProps.getProperty("module.enabled", "false"))) {
                        // 加载模块配置类
                        String configClassName = moduleProps.getProperty("module.config-class");
                        if (configClassName != null) {
                            Class<?> configClass = Class.forName(configClassName);
                            // 注册模块配置类
                            registerConfigurationClass(registry, configClass);
                        }
                    }
                }
            }
        } catch (Exception e) {
            throw new BeanCreationException("Failed to load dynamic modules", e);
        }
    }
    
    private void registerConfigurationClass(BeanDefinitionRegistry registry, Class<?> configClass) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(configClass);
        
        String beanName = configClass.getSimpleName();
        registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
    }
    
    private Properties loadModuleProperties(Resource moduleDir) throws IOException {
        Properties props = new Properties();
        Resource propFile = resourceLoader.getResource(moduleDir.getURL() + "/module.properties");
        if (propFile.exists()) {
            try (InputStream is = propFile.getInputStream()) {
                props.load(is);
            }
        }
        return props;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        // 空实现
    }
}

这个例子展示了如何扫描 modules 目录下的各个模块，根据模块配置文件决定是否启用该模块，并动态注册模块的配置类。

2.5 优缺点与适用场景

优点：

• 提供完全编程式的 Bean 注册控制
• 可以在运行时根据外部条件动态创建 Bean
• 能够处理复杂的动态注册逻辑

缺点：

• 实现相对复杂，需要理解 Spring 容器的生命周期
• 难以调试
• 不当使用可能导致不可预测的行为

适用场景：

• 插件系统或模块化架构
• 基于配置动态加载组件
• 根据外部系统状态动态调整应用结构
• 高度定制化的框架和中间件开发

三、ImportBeanDefinitionRegistrar 实现动态注入

3.1 基本原理

ImportBeanDefinitionRegistrar 是 Spring 框架提供的另一个强大机制，它允许我们在使用 @Import 注解导入配置类时，动态注册 Bean 定义。

与
BeanDefinitionRegistryPostProcessor 不同，
ImportBeanDefinitionRegistrar 更加专注于配置类导入场景，是实现自定义注解驱动功能的理想选择。

3.2 接口说明

ImportBeanDefinitionRegistrar 接口只有一个方法：

public interface ImportBeanDefinitionRegistrar {
    void registerBeanDefinitions(
        AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry);
}

其中：

• importingClassMetadata 提供了导入该注册器的类的元数据信息
• registry 允许注册额外的 Bean 定义

3.3 代码示例

下面我们通过一个案例展示如何使用
ImportBeanDefinitionRegistrar 实现一个自定义的 @EnableHttpClients 注解，自动为指定的接口生成 HTTP 客户端实现：

首先，定义自定义注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(HttpClientRegistrar.class)
public @interface EnableHttpClients {
    String[] basePackages() default {};
    Class<?>[] basePackageClasses() default {};
    Class<?>[] clients() default {};
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface HttpClient {
    String value() default "";  // API 基础URL
    String name() default "";   // Bean名称
}

然后，实现
ImportBeanDefinitionRegistrar：

public class HttpClientRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        // 解析 @EnableHttpClients 注解属性
        Map<String, Object> attributes = metadata.getAnnotationAttributes(EnableHttpClients.class.getName());
        
        // 获取要扫描的包和类
        List<String> basePackages = new ArrayList<>();
        for (String pkg : (String[]) attributes.get("basePackages")) {
            if (StringUtils.hasText(pkg)) {
                basePackages.add(pkg);
            }
        }
        
        for (Class<?> clazz : (Class<?>[]) attributes.get("basePackageClasses")) {
            basePackages.add(ClassUtils.getPackageName(clazz));
        }
        
        // 如果没有指定包，使用导入类的包
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(metadata.getClassName()));
        }
        
        // 创建类路径扫描器
        ClassPathScanningCandidateComponentProvider scanner = new ClassPathScanningCandidateComponentProvider(false);
        scanner.addIncludeFilter(new AnnotationTypeFilter(HttpClient.class));
        
        // 扫描 @HttpClient 注解的接口
        for (String basePackage : basePackages) {
            for (BeanDefinition beanDef : scanner.findCandidateComponents(basePackage)) {
                String className = beanDef.getBeanClassName();
                try {
                    Class<?> interfaceClass = Class.forName(className);
                    registerHttpClient(registry, interfaceClass);
                } catch (ClassNotFoundException e) {
                    throw new BeanCreationException("Failed to load HTTP client interface: " + className, e);
                }
            }
        }
        
        // 处理直接指定的客户端接口
        for (Class<?> clientClass : (Class<?>[]) attributes.get("clients")) {
            registerHttpClient(registry, clientClass);
        }
    }
    
    private void registerHttpClient(BeanDefinitionRegistry registry, Class<?> interfaceClass) {
        if (!interfaceClass.isInterface()) {
            throw new IllegalArgumentException("HTTP client must be an interface: " + interfaceClass.getName());
        }
        
        // 获取 @HttpClient 注解信息
        HttpClient annotation = interfaceClass.getAnnotation(HttpClient.class);
        if (annotation == null) {
            return;
        }
        
        // 确定 Bean 名称
        String beanName = StringUtils.hasText(annotation.name()) 
                ? annotation.name() 
                : StringUtils.uncapitalize(interfaceClass.getSimpleName());
        
        // 创建动态代理工厂的 Bean 定义
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(HttpClientFactoryBean.class)
                .addPropertyValue("interfaceClass", interfaceClass)
                .addPropertyValue("baseUrl", annotation.value());
        
        // 注册 Bean 定义
        registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
    }
}

最后，实现 HTTP 客户端工厂：

public class HttpClientFactoryBean implements FactoryBean<Object>, InitializingBean {
    
    private Class<?> interfaceClass;
    private String baseUrl;
    private Object httpClient;
    
    @Override
    public Object getObject() throws Exception {
        return httpClient;
    }
    
    @Override
    public Class<?> getObjectType() {
        return interfaceClass;
    }
    
    @Override
    public boolean isSingleton() {
        return true;
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 创建接口的动态代理实现
        httpClient = Proxy.newProxyInstance(
            interfaceClass.getClassLoader(),
            new Class<?>[] { interfaceClass },
            new HttpClientInvocationHandler(baseUrl)
        );
    }
    
    // Getter and Setter
    public void setInterfaceClass(Class<?> interfaceClass) {
        this.interfaceClass = interfaceClass;
    }
    
    public void setBaseUrl(String baseUrl) {
        this.baseUrl = baseUrl;
    }
    
    // 实际处理 HTTP 请求的 InvocationHandler
    private static class HttpClientInvocationHandler implements InvocationHandler {
        private final String baseUrl;
        
        public HttpClientInvocationHandler(String baseUrl) {
            this.baseUrl = baseUrl;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 实际实现会处理 HTTP 请求，这里简化为打印日志
            System.out.println("Executing HTTP request to " + baseUrl + " for method " + method.getName());
            
            // 根据方法返回类型创建模拟响应
            return createMockResponse(method.getReturnType());
        }
        
        private Object createMockResponse(Class<?> returnType) {
            // 简化实现，实际代码应根据返回类型创建适当的响应对象
            if (returnType == String.class) {
                return "Mock response";
            }
            if (returnType == Integer.class || returnType == int.class) {
                return 200;
            }
            return null;
        }
    }
}

使用自定义注解创建 HTTP 客户端：

// 接口定义
@HttpClient(value = "https://api.example.com", name = "userClient")
public interface UserApiClient {
    User getUser(Long id);
    List<User> getAllUsers();
    void createUser(User user);
}

// 启用 HTTP 客户端
@Configuration
@EnableHttpClients(basePackages = "com.example.api.client")
public class ApiClientConfig {
}

// 使用生成的客户端
@Service
public class UserService {
    
    @Autowired
    private UserApiClient userClient;
    
    public User getUserById(Long id) {
        return userClient.getUser(id);
    }
}

3.4 Spring Boot 自动配置原理

Spring Boot 的自动配置功能就是基于
ImportBeanDefinitionRegistrar 实现的。@EnableAutoConfiguration 注解通过 @Import(
AutoConfigurationImportSelector.class) 导入了一个选择器，该选择器读取 META-INF/spring.factories 文件中的配置类列表，并动态导入符合条件的自动配置类。

我们可以参考这种模式实现自己的模块自动配置：

// 自定义模块启用注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(ModuleConfigurationImportSelector.class)
public @interface EnableModules {
    String[] value() default {};
}

// 导入选择器
public class ModuleConfigurationImportSelector implements ImportSelector {
    
    @Override
    public String[] selectImports(AnnotationMetadata metadata) {
        Map<String, Object> attributes = metadata.getAnnotationAttributes(EnableModules.class.getName());
        String[] moduleNames = (String[]) attributes.get("value");
        
        List<String> imports = new ArrayList<>();
        for (String moduleName : moduleNames) {
            String configClassName = getModuleConfigClassName(moduleName);
            if (isModuleAvailable(configClassName)) {
                imports.add(configClassName);
            }
        }
        
        return imports.toArray(new String[0]);
    }
    
    private String getModuleConfigClassName(String moduleName) {
        return "com.example.module." + moduleName + ".config." + 
               StringUtils.capitalize(moduleName) + "ModuleConfiguration";
    }
    
    private boolean isModuleAvailable(String className) {
        try {
            Class.forName(className);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }
}

3.5 优缺点与适用场景

优点：

• 与 Spring 的注解驱动配置模式无缝集成
• 支持复杂的条件注册逻辑
• 便于实现可重用的配置模块
• 是实现自定义启用注解的理想选择

缺点：

• 需要深入理解 Spring 的配置机制
• 配置类导入顺序可能带来问题
• 不如 BeanDefinitionRegistryPostProcessor 灵活，仅限于配置导入场景

适用场景：

• 开发自定义的"启用"注解（如 @EnableXxx）
• 实现可重用的配置模块
• 框架集成，如 ORM、消息队列等
• 基于注解的自动代理生成

四、方案对比

五、总结

通过合理选择和组合这些技巧，我们可以构建更加灵活、模块化和可扩展的 Spring Boot 应用。

关键是根据实际需求选择合适的技术，保持代码的简洁和可维护性。