Comprehensive Guide to Configuring and Using Multiple Data Sources in Spring Boot

Introduction

In modern enterprise application development, it is often necessary to connect to multiple databases simultaneously. This requirement may stem from read-write separation architectures, legacy system integration, or different business modules using independent databases. Spring Boot provides a concise and flexible solution for multi-data source configuration through its powerful auto-configuration mechanism.

Fundamentals of Multiple Data Source Configuration

To configure multiple data sources in Spring Boot, you first need to define connection parameters for each data source in the application.properties file. Here is a typical dual data source configuration example:

# Primary data source configuration
spring.datasource.url=jdbc:oracle:thin:@localhost:1521:orcl
spring.datasource.username=admin
spring.datasource.password=secret123
spring.datasource.driverClassName=oracle.jdbc.OracleDriver

# Secondary data source configuration
spring.secondDatasource.url=jdbc:mysql://localhost:3306/seconddb
spring.secondDatasource.username=user
spring.secondDatasource.password=pass456
spring.secondDatasource.driverClassName=com.mysql.jdbc.Driver

The key to this configuration approach lies in using different prefixes to distinguish each data source. Spring Boot's @ConfigurationProperties annotation can automatically bind these properties to corresponding configuration classes.

Data Source Bean Definition

After defining the configuration properties, you need to create corresponding data source beans in the configuration class. The following code demonstrates how to define two data sources:

@Configuration
public class DataSourceConfig {
    
    @Bean
    @Primary
    @ConfigurationProperties(prefix="spring.datasource")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    @ConfigurationProperties(prefix="spring.secondDatasource")
    public DataSource secondaryDataSource() {
        return DataSourceBuilder.create().build();
    }
}

There are several important technical points here:

• The @Primary annotation identifies the primary data source. When multiple beans of the same type exist, Spring will prioritize the bean marked as @Primary
• The @ConfigurationProperties annotation automatically maps properties from the configuration file to the DataSource object
• DataSourceBuilder.create().build() creates a complete data source instance based on configuration properties

Data Source Usage and Injection

In the Repository or Service layer, you can specify which data source to use through the @Qualifier annotation:

@Repository
public class UserRepository {
    
    @Autowired
    @Qualifier("primaryDataSource")
    private DataSource dataSource;
    
    // Use primary data source for database operations
    public void saveUser(User user) {
        // Specific database operation logic
    }
}

@Repository  
public class LogRepository {
    
    @Autowired
    @Qualifier("secondaryDataSource")
    private DataSource dataSource;
    
    // Use secondary data source for logging
    public void logActivity(Activity activity) {
        // Log recording logic
    }
}

Transaction Management Configuration

For applications requiring transaction support, you also need to configure independent transaction managers for each data source:

@Configuration
public class TransactionConfig {
    
    @Bean(name="primaryTransactionManager")
    @Autowired
    @Primary
    public DataSourceTransactionManager primaryTransactionManager(
            @Qualifier("primaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
    
    @Bean(name="secondaryTransactionManager")  
    @Autowired
    public DataSourceTransactionManager secondaryTransactionManager(
            @Qualifier("secondaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

In business methods, you can use transactions for corresponding data sources by specifying the transaction manager:

@Service
public class BusinessService {
    
    @Transactional("primaryTransactionManager")
    public void processWithPrimaryDataSource() {
        // Use primary data source transactions
    }
    
    @Transactional("secondaryTransactionManager")  
    public void processWithSecondaryDataSource() {
        // Use secondary data source transactions
    }
}

Advanced Configuration Considerations

In actual production environments, you also need to consider advanced features such as connection pool configuration, connection timeout settings, and connection validation. You can configure these parameters separately for each data source in application.properties:

# Primary data source connection pool configuration
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000

# Secondary data source connection pool configuration  
spring.secondDatasource.hikari.maximum-pool-size=10
spring.secondDatasource.hikari.connection-timeout=15000
spring.secondDatasource.hikari.idle-timeout=300000

Best Practices and Considerations

When configuring multiple data sources, pay attention to the following points:

• Plan data source usage scenarios reasonably to avoid unnecessary complexity
• Ensure database driver dependencies are correctly added to the project
• In production environments, it is recommended to use connection pools to improve performance
• Regularly monitor connection status and performance metrics for each data source
• Consider using database clusters or read-write separation architectures to optimize multi-data source usage

Conclusion

Although Spring Boot's multi-data source configuration involves multiple steps, through proper configuration and annotation usage, it can well meet the access requirements for multiple databases in enterprise applications. The key is to understand the role of each annotation, correctly configure transaction managers, and pay attention to data source selection and transaction boundary management during usage.