使用多个 Spring Boot 和 JDBC 数据源

Question

I have the following issue that I have to solve in my business. I am using Spring for project development I have 8 dataSource to connect.

A request will be made informing the contract number, through this contact number I will have to select one of the 8 dataSource and make the client consultation.

Example: I have the base Brazil = 1 , Spain = 2 and Germany = 3

1. If the contract was id = 1 , then you should get the customer data from Brazil base .
2. If the contract was id = 2 , then you should get the customer data from Spain base .
3. If the contract was id = 3 , then you should fetch customer data from the Germany base .

I don't know how to solve this problem if I use multitenancy or AbstractRouting . And I don't know how to start the code for this.

Would anyone have any solution and an example?

Answer 1

Spring has way to determine datasource dynamically using AbstractRoutingDataSource . But need to use ThreadLocal to bind context to current thread.

This may complicate things if you are spawning multiple threads or using async in your app.

You can refer simple exmaple here

If you really need to create database connection as per different clients then hibernate provides a way to manage Multi-tenancy , Hibernate Guide . As explained general approach would be to use connection pool per-tenant or single connection pool per all tenants sharing same database but different schema.

Below are the two implementation used to switch to multiple tenants -

    public class TestDataSourceBasedMultiTenantConnectionProviderImpl
extends AbstractDataSourceBasedMultiTenantConnectionProviderImpl {

    private static final long serialVersionUID = 14535345L;

    @Autowired
    private DataSource defaultDataSource;

    @Autowired
    private TestDataSourceLookup dataSourceLookup;

    /**
     * 
     * Select datasources in situations where not tenantId is used (e.g. startup
     * processing).
     * 
     */
    @Override
    protected DataSource selectAnyDataSource() {
        //logger.trace("Select any dataSource: " + defaultDataSource);
        return defaultDataSource;
    }

    /**
     * 
     * Obtains a DataSource based on tenantId
     * 
     */

    @Override
    protected DataSource selectDataSource(String tenantIdentifier) {

        DataSource ds = dataSourceLookup.getDataSource(tenantIdentifier);
    //  logger.trace("Select dataSource from " + tenantIdentifier + ": " + ds);
        return ds;

    }

import org.hibernate.context.spi.CurrentTenantIdentifierResolver;
import org.springframework.beans.factory.annotation.Autowired;

public class TestCurrentTenantIdentifierResolverImpl implements CurrentTenantIdentifierResolver  {

    @Autowired
    private RequestContext context;

    @Override
    public String resolveCurrentTenantIdentifier() {
        // TODO Auto-generated method stub
        return context.getTenantID();
    }

    @Override
    public boolean validateExistingCurrentSessions() {
        // TODO Auto-generated method stub
        return true;
    }

}

Answer 2

AbstractRouting would be a way to do it, indeed. You can mix that approach with headers on the request to easily implement multi-tenancy. The link provided in another post on Baeldung does indeed provide a solution using such construct.

Sharding and deploying a separate micro-service for each tenant, with a routing service in front, would be another one and I think it offers several benefits both from coding (no need for thread-locals or other similarly difficult construct) and maintenance perspective (you can take down your service for maintenance/customisation at tenant level), so it would be my solution of choice in your specific case, assuming that business requirements allow for it.

Still, again, the best solution depends on your specific case.

The easiest solution matching the title of the question - for readers that are not necessarily concerned with multi-tenancy - would be to create several dataSource instances in your Spring's @Configuration beans, put them in a Map<Integer, DataSource> and then return that Map<Integer, DataSource> object as a Bean. When you have to access them, you access the Map bean you created and then create your NamedParameterJdbcTemplate or similar resource passing the specific DataSource in the constructor.

Pseudo-code example:

@Configuration
class DataSourceConfig {
    public final static int SPAIN = 2;
    public final static int BRAZIL = 1;

    @Bean
    @Qualifier("dataSources")
    public Map<Integer, DataSource> dataSources() {
        Map<Integer, DataSource> ds = new HashMap<>();
        ds.put(SPAIN, buildSpainDataSource());
        ds.put(BRAZIL, buildBrazilDataSource());
        return ds;
    }

    private DataSource buildSpainDataSource() {
        ...
    }

    private DataSource buildBrazilDataSource() {
        ...
    }

}

@Service
class MyService {
    @Autowired
    @Qualifier("dataSources")
    Map<Integer, DataSource> dataSources;

    Map<String, Object> getObjectForCountry(int country) {
        NamedParameterJdbcTemplate t = new NamedParameterJdbcTemplate(dataSources.get(country));
        return t.queryForMap("select value from mytable", new HashMap<>());
    }
}