Spring动态Bean装配与外部配置集成指南

// 核心处理管道
class Pipe {
  DBReader reader;
  List<DataProcessor> dataProcessors;

  public Pipe(DBReader reader, List<DataProcessor> dataProcessors) {
    this.reader = reader;
    this.dataProcessors = dataProcessors;
  }
  // ... 其他业务逻辑
}

// 数据读取接口及其实现
interface DBReader {
  Data readData();
}

class JdbcReader implements DBReader {
  private DataSource dataSource; // 依赖DataSource

  public JdbcReader(DataSource dataSource) { this.dataSource = dataSource; }
  // ...
}

class FileReader implements DBReader {
  private String fileName; // 依赖文件名

  public FileReader(String fileName) { this.fileName = fileName; }
  // ...
}

// 数据处理接口及其实现
interface DataProcessor {
  void processData(Data data);
}

class CopyDataProcessor implements DataProcessor {
  private int param1;
  private int param2;

  public CopyDataProcessor(int param1, int param2) { /* ... */ }
  // ...
}

class DevNullDataProcessor implements DataProcessor {
  private String hostName;

  public DevNullDataProcessor(String hostName) { /* ... */ }
  // ...
}

datasources:
  dataSource1:
    connectionString: "postgres://la-la-la"
  dataSource2:
    connectionString: "mysql://la-la-la"

dbReaders:
  reader1:
    type: jdbc
    dataSourceRef: dataSource1 # 引用datasources中的dataSource1
  reader2:
    type: file
    filename: "customers.json"
  reader3:
    type: jdbc
    dataSourceRef: dataSource2

dataProcessors:
  processor1:
    impl: "com.example.processors.CopyDataProcessor"
    param1: 4
    param2: 8
  processor2:
    impl: "com.example.processors.DevNullProcessor"
    hostName: Alpha

pipes:
  pipeA:
    readerRef: reader1 # 引用dbReaders中的reader1
    dataProcessorsRef: [processor1, processor2] # 引用dataProcessors中的列表
  pipeB:
    readerRef: reader2
    dataProcessorsRef: [processor2]

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
import java.util.Arrays;
import java.util.List;
import java.util.Collections;

@Configuration
public class AppConfig {

    // 假设的DataSource实现，实际可能来自连接池配置
    @Bean
    @Qualifier("dataSource1")
    public DataSource postgresDataSource(@Value("${datasources.dataSource1.connectionString}") String connectionString) {
        // 实际中会配置具体的DataSource实现，例如HikariCP
        System.out.println("Creating PostgreSQL DataSource with: " + connectionString);
        return new MockDataSource(connectionString); // 示例：使用模拟DataSource
    }

    @Bean
    @Qualifier("dataSource2")
    public DataSource mysqlDataSource(@Value("${datasources.dataSource2.connectionString}") String connectionString) {
        System.out.println("Creating MySQL DataSource with: " + connectionString);
        return new MockDataSource(connectionString); // 示例：使用模拟DataSource
    }

    // DBReader Beans
    @Bean
    @Qualifier("reader1")
    public DBReader jdbcReader1(@Qualifier("dataSource1") DataSource dataSource) {
        System.out.println("Creating JdbcReader1 with dataSource1");
        return new JdbcReader(dataSource);
    }

    @Bean
    @Qualifier("reader2")
    public DBReader fileReader2(@Value("${dbReaders.reader2.filename}") String filename) {
        System.out.println("Creating FileReader2 with filename: " + filename);
        return new FileReader(filename);
    }

    @Bean
    @Qualifier("reader3")
    public DBReader jdbcReader3(@Qualifier("dataSource2") DataSource dataSource) {
        System.out.println("Creating JdbcReader3 with dataSource2");
        return new JdbcReader(dataSource);
    }

    // DataProcessor Beans
    @Bean
    @Qualifier("processor1")
    public DataProcessor copyDataProcessor1(@Value("${dataProcessors.processor1.param1}") int param1,
                                            @Value("${dataProcessors.processor1.param2}") int param2) {
        System.out.println("Creating CopyDataProcessor1 with param1=" + param1 + ", param2=" + param2);
        return new CopyDataProcessor(param1, param2);
    }

    @Bean
    @Qualifier("processor2")
    public DataProcessor devNullDataProcessor2(@Value("${dataProcessors.processor2.hostName}") String hostName) {
        System.out.println("Creating DevNullDataProcessor2 with hostName: " + hostName);
        return new DevNullDataProcessor(hostName);
    }

    // Pipe Beans
    @Bean
    public Pipe pipeA(@Qualifier("reader1") DBReader reader,
                      @Qualifier("processor1") DataProcessor processor1,
                      @Qualifier("processor2") DataProcessor processor2) {
        System.out.println("Creating PipeA with reader1, processor1, processor2");
        return new Pipe(reader, Arrays.asList(processor1, processor2));
    }

    @Bean
    public Pipe pipeB(@Qualifier("reader2") DBReader reader,
                      @Qualifier("processor2") DataProcessor processor2) {
        System.out.println("Creating PipeB with reader2, processor2");
        return new Pipe(reader, Collections.singletonList(processor2));
    }

    // 模拟的DataSource和Data类，用于示例
    static class MockDataSource implements DataSource {
        private String connectionString;
        public MockDataSource(String connectionString) { this.connectionString = connectionString; }
        // ... 实现DataSource接口方法
    }
    static class Data {}
}

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.config.RuntimeBeanReference;