How do you configure multiple data sources in Spring?

Table of Contents

• Introduction
• Configuring Multiple Data Sources in Spring
  • Example: Configuring Multiple Data Sources in Spring Boot
    • 1. Defining Multiple DataSource Configuration
      • Primary DataSource Configuration
      • Secondary DataSource Configuration
    • 2. Configuring **application.properties**
    • 3. Using **@Primary** Annotation
    • 4. Repository Configuration
• Handling Dynamic Routing with Multiple Data Sources
  • Example: Dynamic Data Source Routing
• Conclusion
  • Key Steps to Implement Multiple Data Sources:

Introduction

In many enterprise applications, you may need to interact with multiple databases. For example, you might want to use one database for user data, another for orders, and a third for reporting. Configuring and managing multiple data sources in a Spring application allows you to interact with different databases seamlessly. Spring provides several ways to configure multiple data sources, allowing developers to set up various database connections and choose which one to use based on the context or business logic.

This guide explains how to configure multiple data sources in Spring, with a focus on Spring Boot applications. We'll explore various techniques like using @Primary annotation, creating DataSource beans, and employing dynamic routing.

Configuring Multiple Data Sources in Spring

To configure multiple data sources in Spring, you need to:

1. Define Configuration for Each DataSource: This includes properties such as database URL, username, password, and driver class for each data source.
2. Create **DataSource** Beans: You can define beans for each data source in your Spring configuration.
3. Use **@Primary** to Identify the Default DataSource: When working with multiple data sources, you may have a default data source. The @Primary annotation allows you to specify which data source should be the default one when Spring has multiple candidates for injection.
4. Configure **EntityManagerFactory** and **TransactionManager**: Each data source requires a corresponding EntityManagerFactory and TransactionManager for persistence management.

Example: Configuring Multiple Data Sources in Spring Boot

1. Defining Multiple DataSource Configuration

In a Spring Boot application, you can define each data source configuration class using @Configuration and @EnableTransactionManagement. For simplicity, let's assume we need two data sources, one for the primaryDataSource and another for secondaryDataSource.

Primary DataSource Configuration

Secondary DataSource Configuration

2. Configuring **application.properties**

Now, you need to specify the configuration for both data sources in the application.properties file.

3. Using **@Primary** Annotation

The @Primary annotation is used to mark one of the data sources as the default. This is necessary when you have more than one DataSource bean and Spring is required to inject the default one.

In the above example, the primaryDataSource, primaryEntityManagerFactory, and primaryTransactionManager beans are annotated with @Primary to make sure that Spring uses the primary data source by default in case multiple data sources are present.

4. Repository Configuration

When configuring multiple data sources, you may need to specify which repository should use which data source. You can achieve this by setting the basePackages attribute on the @EnableJpaRepositories annotation to ensure each repository is linked to the correct EntityManagerFactory and TransactionManager.

@EnableJpaRepositories(    basePackages = "com.example.repository.primary",    entityManagerFactoryRef = "primaryEntityManagerFactory",    transactionManagerRef = "primaryTransactionManager" )

Handling Dynamic Routing with Multiple Data Sources

In some cases, you may need to dynamically choose which data source to use during runtime, based on the context of the transaction or request. This can be done using a AbstractRoutingDataSource implementation.

Example: Dynamic Data Source Routing

• Dynamic Routing: AbstractRoutingDataSource uses the determineCurrentLookupKey() method to decide which data source to use dynamically, based on runtime conditions (like user session, request parameters, etc.).
• Context Holder: The DataSourceContextHolder stores the current lookup key (e.g., "primary" or "secondary"), and it's used in the routing logic.

Conclusion

Configuring multiple data sources in a Spring application is a common requirement when working with multiple databases. You can achieve this by defining separate DataSource configurations, setting up different EntityManagerFactory and TransactionManager beans, and using @Primary to specify the default data source. Additionally, for more complex scenarios, such as when you need to route data sources dynamically, Spring offers tools like AbstractRoutingDataSource.

Key Steps to Implement Multiple Data Sources:

1. Define separate **DataSource** configurations.
2. Use **@Primary** for the default data source.
3. Configure **EntityManagerFactory** and **TransactionManager** for each data source.
4. Use dynamic data source routing if needed.

By carefully setting up multiple data sources in Spring, you can efficiently handle different data sources and databases in your application, ensuring better data management and performance.