Spring - AbstractRoutingDataSource

package com.gfg.scripter.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "intern")
public class Intern {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String address;
    private String dob;
    private String branch;
    // Generate Getters and Setters
}

package com.gfg.scripter.constant;

public enum BranchEnum {
    NOIDA, BANGALORE
}

package com.gfg.scripter.config;

import com.gfg.scripter.constant.BranchEnum;

public class BranchContextHolder {

    private static ThreadLocal<BranchEnum> threadLocal = new ThreadLocal<>();

    public static void setBranchContext(BranchEnum branchEnum) {
        threadLocal.set(branchEnum);
    }

    public static BranchEnum getBranchContext() {
        return threadLocal.get();
    }

    public static void clearBranchContext() {
        threadLocal.remove();
    }
}

package com.gfg.scripter.config;

import java.util.HashMap;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import com.gfg.scripter.constant.BranchEnum;

public class DataSourceRouting extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return BranchContextHolder.getBranchContext();
    }

    public void initDatasource(DataSource bangaloreDataSource,
            DataSource noidaDataSource) {
        Map<Object, Object> dataSourceMap = new HashMap<>();
        dataSourceMap.put(BranchEnum.NOIDA, noidaDataSource);
        dataSourceMap.put(BranchEnum.BANGALORE, bangaloreDataSource);
        this.setTargetDataSources(dataSourceMap);
        
          // Here we have to provide default datasource details.
        this.setDefaultTargetDataSource(noidaDataSource);
    }
}

package com.gfg.scripter.config;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.boot.orm.jpa.EntityManagerFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import com.gfg.scripter.entity.Intern;

@Configuration
@EnableJpaRepositories(basePackages = "com.gfg.scripter.repository", transactionManagerRef = "transcationManager", entityManagerFactoryRef = "entityManager")
@EnableTransactionManagement
public class DataSourceConfig {

    @Bean
    @Primary
    @Autowired
    public DataSource dataSource() {
        DataSourceRouting routingDataSource = new DataSourceRouting();
        routingDataSource.initDatasource(noidaDataSource(), bangaloreDataSource());
        return routingDataSource;
    }

    @Bean
    @ConfigurationProperties(prefix = "noida.datasource")
    public DataSource noidaDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "bangalore.datasource")
    public DataSource bangaloreDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "entityManager")
    public LocalContainerEntityManagerFactoryBean entityManagerFactoryBean(EntityManagerFactoryBuilder builder) {
        return builder.dataSource(dataSource()).packages(Intern.class).build();
    }

    @Bean(name = "transcationManager")
    public JpaTransactionManager transactionManager(
            @Autowired @Qualifier("entityManager") LocalContainerEntityManagerFactoryBean entityManagerFactoryBean) {
        return new JpaTransactionManager(entityManagerFactoryBean.getObject());
    }
}

package com.gfg.scripter.config;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import com.gfg.scripter.constant.BranchEnum;

@Component
public class DataSourceInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request,
            HttpServletResponse response, Object handler) throws Exception {

        String branch = request.getHeader("branch");
        if (BranchEnum.BANGALORE.toString().equalsIgnoreCase(branch))
            BranchContextHolder.setBranchContext(BranchEnum.BANGALORE);
        else
            BranchContextHolder.setBranchContext(BranchEnum.NOIDA);
        return super.preHandle(request, response, handler);
    }
}

package com.gfg.scripter.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private DataSourceInterceptor dataSourceInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(dataSourceInterceptor).addPathPatterns("/**");
        WebMvcConfigurer.super.addInterceptors(registry);
    }
}

package com.gfg.scripter.repository;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.gfg.scripter.entity.Intern;

@Repository
public interface InternRepository extends JpaRepository<Intern, Long> {}

package com.gfg.scripter.service;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gfg.scripter.entity.Intern;
import com.gfg.scripter.repository.InternRepository;

@Service
public class InternService {

    @Autowired
    private InternRepository internRepository;

    public List<Intern> getInterns() {
        return internRepository.findAll();
    }
}

package com.gfg.scripter.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import com.gfg.scripter.entity.Intern;
import com.gfg.scripter.service.InternService;

@RestController
public class InternController {

    @Autowired
    private InternService internService;

    @GetMapping(value = "intern")
    public ResponseEntity<List<Intern>> getInterns() {
        return ResponseEntity.status(HttpStatus.ACCEPTED)
                .body(internService.getInterns());
    }
}