Streamlining Multiple MySQL Datasources in Spring Modulith

Automated Multiple Datasources Configuration in Spring Modulith

This script demonstrates a dynamic approach to configuring multiple MySQL datasources in a Spring Boot application using properties and a shared configuration factory method.

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariDataSource;
@Configuration
@EnableConfigurationProperties(DatasourceProperties.class)
public class MultiDatasourceConfig {
    @Bean
    public DataSource dataSourceOne(DatasourceProperties properties) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(properties.getDbOne().getUrl());
        dataSource.setUsername(properties.getDbOne().getUsername());
        dataSource.setPassword(properties.getDbOne().getPassword());
        return dataSource;
    }
    @Bean
    public DataSource dataSourceTwo(DatasourceProperties properties) {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl(properties.getDbTwo().getUrl());
        dataSource.setUsername(properties.getDbTwo().getUsername());
        dataSource.setPassword(properties.getDbTwo().getPassword());
        return dataSource;
    }
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryOne(DataSource dataSourceOne) {
        LocalContainerEntityManagerFactoryBean factoryBean = new LocalContainerEntityManagerFactoryBean();
        factoryBean.setDataSource(dataSourceOne);
        factoryBean.setPackagesToScan("com.example.module1");
        factoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        return factoryBean;
    }
    @Bean
    public JpaTransactionManager transactionManagerOne(EntityManagerFactory entityManagerFactoryOne) {
        return new JpaTransactionManager(entityManagerFactoryOne);
    }
}

Dynamic Factory Approach for Datasource Management

This script uses a flexible factory-based strategy for creating multiple datasources and entity managers with reusable methods.

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.ConstructorBinding;
import org.springframework.stereotype.Component;
@ConfigurationProperties(prefix = "datasource")
@Component
public class DatasourceProperties {
    private final DbProperties dbOne;
    private final DbProperties dbTwo;
    @ConstructorBinding
    public DatasourceProperties(DbProperties dbOne, DbProperties dbTwo) {
        this.dbOne = dbOne;
        this.dbTwo = dbTwo;
    }
    public DbProperties getDbOne() { return dbOne; }
    public DbProperties getDbTwo() { return dbTwo; }
}
class DbProperties {
    private String url;
    private String username;
    private String password;
    // Getters and setters...
}

Common Questions About Spring Modulith and Multiple Datasources

1. What is the advantage of using @EnableConfigurationProperties?
2. It allows you to bind a Java class to properties files dynamically, improving maintainability and reducing hardcoded values.
3. How can I ensure transactional integrity across multiple datasources?
4. By configuring separate JpaTransactionManager beans for each datasource, you can isolate transactions to prevent conflicts.
5. What is the role of PersistenceUnitManager in datasource configuration?
6. It helps manage advanced settings for persistence units, allowing modular configurations for each database schema.
7. Can Spring profiles help manage multiple environments?
8. Yes, Spring profiles allow you to define separate configurations for development, testing, and production environments.
9. How do I monitor the health of each datasource?
10. Using Spring Boot Actuator, you can expose health check endpoints to track the status of each datasource in real time.
11. What is HikariDataSource and why is it preferred?
12. It’s a high-performance connection pool implementation, providing efficient resource management for high-load systems.
13. Is it possible to reuse entity classes across multiple modules?
14. Yes, you can use setPackagesToScan to target specific entities in each module, allowing reuse where needed.
15. How do I handle lazy loading issues with multiple datasources?
16. By setting proper fetch strategies in your JPA annotations, such as using FetchType.LAZY for non-critical relations.
17. Can I configure multiple datasources without repeating configuration code?
18. Yes, by using a factory-based approach and reusing helper methods, you can reduce code duplication significantly.
19. How does connection pooling enhance performance?
20. Connection pooling reduces the overhead of creating and destroying connections, improving application response times under load.

Key Takeaways for Streamlined Database Configuration

Configuring multiple datasources in Spring Modulith enhances modularity, maintainability, and performance by separating schemas for different modules. Adopting tools like HikariCP and leveraging Spring Boot profiles ensures efficient and environment-specific setups, benefiting scalable applications. This approach reduces complexity and coding effort significantly.

By integrating features such as dynamic transaction management and connection pooling, you can make your application more robust and secure. These practices enable faster responses to failures and provide better resource utilization, ensuring seamless operation across all your modules. 💡