在企业级应用开发中，Java多数据源配置是一个常见需求。随着业务的发展，系统可能需要连接多个数据库，如主从复制架构中的读写分离，或者整合多个外部系统的数据。Spring Boot为多数据源配置提供了强大支持，通过合理设计可以优雅地管理多个数据源。本文将详细介绍在Spring Boot中配置和管理多个数据源的方法、最佳实践及相关注意事项。

一、多数据源配置基础

多数据源配置是指在一个应用程序中同时连接和使用多个数据库实例。这种配置在企业级应用中非常常见，例如在微服务架构中，不同的服务可能需要访问不同的数据库；或者在数据集成场景中，应用需要从多个数据源获取数据。在Spring Boot中配置多数据源，需要定义多个数据源Bean，并为每个数据源配置相应的连接信息、事务管理器和JdbcTemplate。

以下是一个基本的多数据源配置示例，展示了如何配置两个数据源：

@Configuration
public class DataSourceConfig {

    // 主数据源配置
    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    // 从数据源配置
    @Bean(name = "secondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    // 主数据源的JdbcTemplate
    @Bean(name = "primaryJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }

    // 从数据源的JdbcTemplate
    @Bean(name = "secondaryJdbcTemplate")
    public JdbcTemplate secondaryJdbcTemplate(
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

在这个配置中，我们定义了两个数据源：primaryDataSource和secondaryDataSource，并为它们分别创建了对应的JdbcTemplate。@Primary注解指定了主数据源，当没有明确指定使用哪个数据源时，将使用主数据源。

二、JPA多数据源配置

对于使用JPA的项目，多数据源配置需要额外配置Entity Manager和Transaction Manager。JPA多数据源配置相对复杂，需要为每个数据源指定对应的实体类扫描路径、实体管理器工厂和事务管理器。这样可以确保不同数据源的实体类和操作相互隔离，避免混淆。

以下是JPA多数据源配置的示例代码：

@Configuration
@EnableJpaRepositories(
        basePackages = "com.example.primary.repository",
        entityManagerFactoryRef = "primaryEntityManager",
        transactionManagerRef = "primaryTransactionManager"
)
public class PrimaryJpaConfig {

    @Primary
    @Bean(name = "primaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.primary.entity")
                .persistenceUnit("primary")
                .build();
    }

    @Primary
    @Bean(name = "primaryTransactionManager")
    public PlatformTransactionManager primaryTransactionManager(
            @Qualifier("primaryEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

@Configuration
@EnableJpaRepositories(
        basePackages = "com.example.secondary.repository",
        entityManagerFactoryRef = "secondaryEntityManagerFactory",
        transactionManagerRef = "secondaryTransactionManager"
)
public class SecondaryJpaConfig {

    @Bean(name = "secondaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean secondaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return builder
                .dataSource(dataSource)
                .packages("com.example.secondary.entity")
                .persistenceUnit("secondary")
                .build();
    }

    @Bean(name = "secondaryTransactionManager")
    public PlatformTransactionManager secondaryTransactionManager(
            @Qualifier("secondaryEntityManagerFactory") EntityManagerFactory entityManagerFactory) {
        return new JpaTransactionManager(entityManagerFactory);
    }
}

在这个配置中，为两个数据源分别创建了实体管理器工厂和事务管理器，并通过@EnableJpaRepositories注解指定了每个数据源对应的仓库接口所在的包路径和实体类所在的包路径。这样，Spring Data JPA就能正确地将不同的仓库接口和实体类与对应的数据源关联起来。

三、动态数据源切换

在某些场景下，需要根据业务需求动态切换数据源，例如在多租户应用中，不同租户可能使用不同的数据库。动态数据源切换可以通过自定义AbstractRoutingDataSource来实现，它是Spring提供的一个抽象类，用于根据当前线程的上下文信息动态选择数据源。

以下是动态数据源切换的实现示例：

// 数据源上下文持有者，用于存储当前线程的数据源键
public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSourceKey(String key) {
        contextHolder.set(key);
    }

    public static String getDataSourceKey() {
        return contextHolder.get();
    }

    public static void clearDataSourceKey() {
        contextHolder.remove();
    }
}

// 动态数据源实现
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceKey();
    }
}

// 动态数据源配置
@Configuration
public class DynamicDataSourceConfig {

    @Bean
    public DataSource dataSource(@Qualifier("primaryDataSource") DataSource primaryDataSource,
                                 @Qualifier("secondaryDataSource") DataSource secondaryDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("primary", primaryDataSource);
        targetDataSources.put("secondary", secondaryDataSource);

        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        dynamicDataSource.setDefaultTargetDataSource(primaryDataSource);
        dynamicDataSource.setTargetDataSources(targetDataSources);
        return dynamicDataSource;
    }
}

// 数据源切换注解
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String value() default "primary";
}

// 数据源切换切面
@Aspect
@Order(1)
@Component
public class DataSourceAspect {

    @Before("@annotation(com.example.demo.datasource.DataSource)")
    public void before(JoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        DataSource dataSource = signature.getMethod().getAnnotation(DataSource.class);
        if (dataSource == null) {
            dataSource = signature.getDeclaringType().getAnnotation(DataSource.class);
        }
        if (dataSource != null) {
            DataSourceContextHolder.setDataSourceKey(dataSource.value());
        }
    }

    @After("@annotation(com.example.demo.datasource.DataSource)")
    public void after(JoinPoint point) {
        DataSourceContextHolder.clearDataSourceKey();
    }
}

在这个实现中，我们首先创建了一个DataSourceContextHolder类，用于在当前线程中存储和获取数据源键。然后实现了DynamicDataSource类，继承自AbstractRoutingDataSource，并重写了determineCurrentLookupKey方法，用于根据当前线程的上下文信息选择数据源。接着配置了动态数据源，将多个实际数据源注册到动态数据源中。最后，通过自定义注解和切面实现了在方法级别动态切换数据源的功能。

四、多数据源事务管理

多数据源环境下的事务管理是一个挑战，因为单个事务可能涉及多个数据库操作。在这种情况下，需要使用分布式事务管理方案，如JTA（Java Transaction API）。Spring Boot提供了对Atomikos和Bitronix等JTA实现的支持，可以帮助我们管理跨数据源的事务。

以下是使用Atomikos实现多数据源分布式事务的配置示例：

@Configuration
public class JtaConfig {

    @Bean
    public UserTransactionManager userTransactionManager() throws Throwable {
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        userTransactionManager.setTransactionTimeout(300);
        userTransactionManager.setForceShutdown(false);
        return userTransactionManager;
    }

    @Bean
    public UserTransaction userTransaction() throws Throwable {
        UserTransactionImp userTransactionImp = new UserTransactionImp();
        userTransactionImp.setTransactionTimeout(300);
        return userTransactionImp;
    }

    @Bean(name = "transactionManager")
    @DependsOn({"userTransaction", "userTransactionManager"})
    public PlatformTransactionManager transactionManager() throws Throwable {
        JtaTransactionManager jtaTransactionManager = new JtaTransactionManager();
        jtaTransactionManager.setUserTransaction(userTransaction());
        jtaTransactionManager.setTransactionManager(userTransactionManager());
        return jtaTransactionManager;
    }
}

// 主数据源配置
@Configuration
@EnableJpaRepositories(
        basePackages = "com.example.primary.repository",
        entityManagerFactoryRef = "primaryEntityManagerFactory",
        transactionManagerRef = "transactionManager"
)
public class PrimaryJtaConfig {

    @Bean(name = "primaryDataSource")
    public DataSource primaryDataSource() {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl("jdbc:mysql://localhost:3306/primary");
        mysqlXaDataSource.setUser("root");
        mysqlXaDataSource.setPassword("password");

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("primaryDataSource");
        return xaDataSource;
    }

    @Bean(name = "primaryEntityManagerFactory")
    public LocalContainerEntityManagerFactoryBean primaryEntityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("primaryDataSource") DataSource dataSource) {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        vendorAdapter.setGenerateDdl(true);

        LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
        factory.setDataSource(dataSource);
        factory.setPackagesToScan("com.example.primary.entity");
        factory.setJpaVendorAdapter(vendorAdapter);
        factory.setJpaProperties(additionalProperties());
        factory.setPersistenceUnitName("primaryPU");
        return factory;
    }

    private Properties additionalProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.hbm2ddl.auto", "update");
        properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL8Dialect");
        properties.setProperty("hibernate.transaction.jta.platform", AtomikosJtaPlatform.class.getName());
        properties.setProperty("javax.persistence.transactionType", "JTA");
        return properties;
    }
}

// 从数据源配置（类似主数据源配置）

在这个配置中，首先配置了JTA事务管理器，使用Atomikos作为JTA实现。然后为每个数据源配置了XA数据源，XA数据源支持分布式事务。最后，配置实体管理器工厂时，设置了JTA相关属性，确保事务管理器能够正确管理跨数据源的事务。

五、多数据源监控与调优

在多数据源环境下，监控和调优是确保系统性能和稳定性的关键。多数据源会增加系统的复杂度，因此需要特别关注每个数据源的连接状态、性能指标和资源使用情况。Spring Boot Actuator提供了基本的数据源监控功能，而HikariCP等连接池则提供了更详细的性能指标。

以下是配置数据源监控和调优的示例：

// 配置HikariCP连接池监控
@Configuration
public class DataSourceConfig {

    @Primary
    @Bean(name = "primaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        HikariDataSource dataSource = DataSourceBuilder.create().type(HikariDataSource.class).build();
        // 配置连接池参数
        dataSource.setMaximumPoolSize(20);
        dataSource.setMinimumIdle(5);
        dataSource.setIdleTimeout(30000);
        dataSource.setConnectionTimeout(30000);
        dataSource.setMaxLifetime(1800000);
        return dataSource;
    }

    // 其他数据源配置类似
}

// 配置Actuator端点
management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: always
  health:
    db:
      enabled: true

在这个配置中，我们使用HikariCP作为连接池，并配置了一些关键参数，如最大连接数、最小空闲连接数、连接超时时间等。这些参数会直接影响系统的性能和稳定性，需要根据实际业务场景进行调优。同时，我们启用了Spring Boot Actuator的所有端点，特别是health端点，以便监控数据源的健康状态。

六、多数据源配置最佳实践

在实际项目中，多数据源配置需要遵循一些最佳实践，以确保系统的可维护性和性能。首先，应该根据业务需求合理划分数据源，避免过度使用多数据源导致系统复杂度增加。其次，对于动态数据源切换，应该有明确的策略和清晰的上下文管理，避免数据源切换混乱。在事务管理方面，应该尽量避免跨数据源事务，如果无法避免，应该使用可靠的分布式事务管理方案。

另外，连接池配置也非常重要，不同的数据源可能有不同的性能需求，需要根据实际情况调整连接池参数。同时，应该建立完善的监控机制，及时发现和解决数据源相关的问题。最后，代码结构应该清晰，将与数据源相关的配置和逻辑集中管理，提高代码的可维护性。

以下是一个遵循最佳实践的多数据源项目结构示例：

src/main/java/com/example/multids/
├── config/
│   ├── DataSourceConfig.java         // 数据源配置
│   ├── JpaConfig.java                // JPA配置
│   ├── TransactionConfig.java        // 事务配置
│   └── DynamicDataSourceConfig.java  // 动态数据源配置
├── datasource/
│   ├── DynamicDataSource.java        // 动态数据源实现
│   └── DataSourceContextHolder.java  // 数据源上下文持有者
├── annotation/
│   └── DataSource.java               // 数据源切换注解
├── aspect/
│   └── DataSourceAspect.java         // 数据源切换切面
├── repository/
│   ├── primary/                      // 主数据源仓库
│   └── secondary/                    // 从数据源仓库
├── service/
│   ├── primary/                      // 主数据源服务
│   └── secondary/                    // 从数据源服务
└── controller/                       // 控制器层

这种结构将与数据源相关的代码集中管理，不同数据源的业务逻辑也分开处理，使代码更加清晰和易于维护。

总结

Java多数据源配置在Spring Boot中是一个常见且重要的技术点。本文详细介绍了在Spring Boot中配置和管理多个数据源的方法，包括基础的多数据源配置、JPA多数据源配置、动态数据源切换、多数据源事务管理以及多数据源监控与调优等方面。通过合理的配置和设计，可以在Spring Boot应用中优雅地管理多个数据源，满足企业级应用的复杂需求。

在实际项目中，需要根据业务场景选择合适的多数据源配置方案。对于简单的多数据源需求，可以使用基础的多数据源配置方式；对于需要动态切换数据源的场景，可以实现自定义的动态数据源；而对于跨数据源的事务管理，则需要使用分布式事务方案。同时，遵循多数据源配置的最佳实践，合理划分数据源、优化连接池配置、建立完善的监控机制等，都是确保系统性能和可维护性的关键。

通过掌握本文介绍的内容，开发者可以在Spring Boot应用中高效地配置和管理多个数据源，为企业级应用开发提供有力支持。