@Configuration
public class DataSourceConfig {

    @Bean
    @ConditionalOnProperty(name = "datasource.type", havingValue = "mysql", matchIfMissing = true)
    public DataSource mysqlDataSource() {
        // 創(chuàng)建 MySQL 數(shù)據(jù)源
        return new MySQLDataSource();
    }

    @Bean
    @ConditionalOnProperty(name = "datasource.type", havingValue = "postgresql")
    public DataSource postgresqlDataSource() {
        // 創(chuàng)建 PostgreSQL 數(shù)據(jù)源
        return new PostgreSQLDataSource();
    }
    
    @Bean
    @ConditionalOnProperty(name = "datasource.type", havingValue = "mongodb")
    @ConditionalOnClass(name = "com.mongodb.client.MongoClient")
    public DataSource mongodbDataSource() {
        // 創(chuàng)建 MongoDB 數(shù)據(jù)源，但前提是類路徑中有 MongoDB 驅(qū)動(dòng)
        return new MongoDBDataSource();
    }
    
    @Bean
    @ConditionalOnMissingBean(DataSource.class)
    public DataSource defaultDataSource() {
        // 如果沒有其他數(shù)據(jù)源 Bean，創(chuàng)建默認(rèn)數(shù)據(jù)源
        return new H2DataSource();
    }
}

// 自定義條件判斷邏輯
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");
        
        // 獲取當(dāng)前環(huán)境
        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();
    }
}

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

@Component
public class ServiceRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

    @Autowired
    private Environment environment;

    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 獲取服務(wù)配置
        String[] serviceTypes = environment.getProperty("app.services.enabled", String[].class, new String[0]);
        
        // 動(dòng)態(tài)注冊(cè)服務(wù) Bean
        for (String serviceType : serviceTypes) {
            registerServiceBean(registry, serviceType);
        }
    }
    
    private void registerServiceBean(BeanDefinitionRegistry registry, String serviceType) {
        // 根據(jù)服務(wù)類型確定具體實(shí)現(xiàn)類
        Class<?> serviceClass = getServiceClassByType(serviceType);
        if (serviceClass == null) {
            return;
        }
        
        // 創(chuàng)建 Bean 定義
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(serviceClass)
                .setScope(BeanDefinition.SCOPE_SINGLETON)
                .setLazyInit(false);
        
        // 注冊(cè) 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 {
        // 可以進(jìn)一步處理已注冊(cè)的 Bean 定義
    }
}

@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);
                            // 注冊(cè)模塊配置類
                            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 {
        // 空實(shí)現(xiàn)
    }
}

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

@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 基礎(chǔ)URL
    String name() default "";   // Bean名稱
}

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));
        }
        
        // 如果沒有指定包，使用導(dǎo)入類的包
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(metadata.getClassName()));
        }
        
        // 創(chuàng)建類路徑掃描器
        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());
        
        // 創(chuàng)建動(dòng)態(tài)代理工廠的 Bean 定義
        BeanDefinitionBuilder builder = BeanDefinitionBuilder
                .genericBeanDefinition(HttpClientFactoryBean.class)
                .addPropertyValue("interfaceClass", interfaceClass)
                .addPropertyValue("baseUrl", annotation.value());
        
        // 注冊(cè) Bean 定義
        registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
    }
}

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 {
        // 創(chuàng)建接口的動(dòng)態(tài)代理實(shí)現(xiàn)
        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;
    }
    
    // 實(shí)際處理 HTTP 請(qǐng)求的 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 {
            // 實(shí)際實(shí)現(xiàn)會(huì)處理 HTTP 請(qǐng)求，這里簡(jiǎn)化為打印日志
            System.out.println("Executing HTTP request to " + baseUrl + " for method " + method.getName());
            
            // 根據(jù)方法返回類型創(chuàng)建模擬響應(yīng)
            return createMockResponse(method.getReturnType());
        }
        
        private Object createMockResponse(Class<?> returnType) {
            // 簡(jiǎn)化實(shí)現(xiàn)，實(shí)際代碼應(yīng)根據(jù)返回類型創(chuàng)建適當(dāng)?shù)捻憫?yīng)對(duì)象
            if (returnType == String.class) {
                return "Mock response";
            }
            if (returnType == Integer.class || returnType == int.class) {
                return 200;
            }
            return null;
        }
    }
}

// 接口定義
@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);
    }
}

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

// 導(dǎo)入選擇器
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;
        }
    }
}