Implementation principle of dynamic data source - SpringBoot

Keywords: Java Spring Spring Boot

Dynamic data source

By using the annotation mode of the method, you can switch the database source used by the method. The method is enhanced through the spring section.

Therefore, our construction steps are annotation - Section - data source principle - Implementation (in no order, only the logic of this article)

Learn how to use annotations

Core concept


  • Retention in English means "keep" and "keep". It means that the annotation exists in the source code (compilation time), bytecode (class loading) or runtime (running in the JVM). Use the enumeration RetentionPolicy in the @ retention annotation to indicate the annotation retention period
  • @Retention(RetentionPolicy.SOURCE). The annotation only exists in the source code and is not included in the class bytecode file
  • @Retention(RetentionPolicy.CLASS), the default retention policy. Annotations exist in the class bytecode file, but cannot be obtained at runtime
  • @Retention(RetentionPolicy.RUNTIME), the annotation will exist in the class bytecode file and can be obtained through reflection at run time
  • If we are user-defined annotations, according to the previous analysis, our user-defined annotations will not work if they are only stored in the source code or bytecode file, and our purpose can only be achieved if they can be obtained during operation. Therefore, @ Retention(RetentionPolicy.RUNTIME) must be used in the user-defined annotations


  • Target means target in English, which is easy to understand. Using @ target meta annotation to represent the scope of our annotation is more specific. It can be class, method, method parameter variable, etc. it also expresses the action type through enumerating class ElementType
  • @Target(ElementType.TYPE) functions as interface, class, enumeration and annotation
  • @Target(ElementType.FIELD) acts as a constant for attribute fields and enumerations
  • @Target(ElementType.METHOD) action method
  • @Target(ElementType.PARAMETER) action method parameter
  • @Target(ElementType.CONSTRUCTOR) function constructor
  • @Target(ElementType.LOCAL_VARIABLE) acts as a local variable
  • @Target(ElementType.ANNOTATION_TYPE) acts on annotation (@ Retention annotation uses this attribute)
  • @Target(ElementType.PACKAGE) acts on the package
  • @Target(ElementType.TYPE_PARAMETER) acts on type generics, that is, generic methods, generic classes and generic interfaces (added by jdk1.8)
  • @Target(ElementType.TYPE_USE) can be used to label any type except class (added by jdk1.8)
  • ElementType.TYPE is commonly used


  • Document means document in English. Its function is to include the elements in the annotation into the Javadoc.


  • Inherited means inheritance in English, but this inheritance is similar to what we usually understand. An annotation annotated by @ inherited modifies a parent class. If its subclass is not modified by other annotations, its subclass also inherits the annotation of the parent class.


  • Repeatable means repeatable in English. As the name suggests, the annotation modified by this meta annotation can act on an object multiple times at the same time, but each action annotation can represent different meanings.

The essence of annotation

  • Annotation is essentially an annotation interface
/**Annotation Interface source code*/
public interface Annotation {

    boolean equals(Object obj);

    int hashCode();

    Class<? extends Annotation> annotationType();

Get annotation properties

There are three main methods to obtain through reflection:

 /**Does the corresponding Annotation object exist*/
  public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
        return GenericDeclaration.super.isAnnotationPresent(annotationClass);

 /**Get Annotation object*/
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {

        return (A) annotationData().annotations.get(annotationClass);
 /**Gets an array of all Annotation objects*/   
 public Annotation[] getAnnotations() {
        return AnnotationParser.toArray(annotationData().annotations);

Custom comments are as follows:

public @interface Serize {
    String name() default "Serize";

    String part() default "";

    int version() default 1;

Use cases are as follows:

public class SerizeDemo {
    @Serize(version = 15000)
    public static void TransferVersion(double version) throws NoSuchMethodException {


    private static boolean processSerizeVersion(double version) throws NoSuchMethodException {
        Method transferVersion = SerizeDemo.class.getDeclaredMethod("TransferVersion", double.class);
        boolean present = transferVersion.isAnnotationPresent(Serize.class);
        if (present) {
            Serize serize = transferVersion.getAnnotation(Serize.class);
            int version = serize.version();
            System.out.println("annotation version"+version);
            return true;
        } else {
            return false;

    public static void main(String[] args) throws NoSuchMethodException {

Slice implementation

Here, we use the section directly to enhance the annotation with our custom tags. To achieve method level enhancement, other specific implementation methods can be implemented by querying data.

public class SerizeAspect {
     * Define pointcuts. Pointcuts are all functions under com.serize.annoDemo
    @Pointcut("execution(public * com.serize.annoDemo..*.*(..))")
    public void serizePoint() {

     * Custom annotation pointcuts
    public void noAnnotation() {


     * Pre notification: notification executed before the connection point
     * Same as the method annotated serialize
     * @param joinPoint
     * @throws Throwable
    public void doBefore(JoinPoint joinPoint) throws Throwable {;;;;;;

    @AfterReturning(returning = "ret", pointcut = "serizePoint()")
    public void doAfterReturning(Object ret) throws Throwable {
        // After processing the request, return the content"RESPONSE : " + ret);

Data source principle*

In Java, all connection pools implement the DataSource interface according to the specification. When obtaining the connection, you can obtain the connection through getConnection(), regardless of the underlying database connection pool.

This specification is given by the java package. The code is as follows:

package javax.sql;

public interface DataSource  extends CommonDataSource, Wrapper {

  Connection getConnection() throws SQLException;
  Connection getConnection(String username, String password)
    throws SQLException;

In most systems, we only need one data source, and now WEB systems are usually based on spring. Whether you are xml configuration, javaBean configuration or yml,properties configuration file configuration, the core is to inject a data source to spring for management.

In Spring, AbstractRoutingDataSource is provided by default from version 2.0.1. We inherit its implementation methods and set all required data sources to dynamically switch data sources.

package org.springframework.jdbc.datasource.lookup;

 An abstract data source implementation that routes getConnection() calls to one of the various target data sources according to the lookup key. The latter is usually (but not necessarily) determined by the transaction context bound by a thread.
public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {

	 //Set all data sources
    private Map<Object, Object> targetDataSources;
    //Set the default data source. If no relevant data source is found, the default data source will be returned
    private Object defaultTargetDataSource;
    //Quick failure, negligible
    private boolean lenientFallback = true;
    //Jndi related, negligible
    private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
    //All data sources after parsing, core
    private Map<Object, DataSource> resolvedDataSources;
    //Parsed default data source, core
    private DataSource resolvedDefaultDataSource;

	Specifies the mapping of the target DataSources, using the lookup key as the key. The mapping value can be the corresponding DataSource instance or the data source name string (resolved through DataSourceLookup).
	Keys can be of any type; This class implements only the generic lookup procedure. The specific key representation will be handled by resolvespecifiedlookup key (object) and determineCurrentLookupKey().
	public void setTargetDataSources(Map<Object, Object> targetDataSources) {
		this.targetDataSources = targetDataSources;

	If so, specify the default target data source. The mapping value can be the corresponding DataSource instance or the data source name string (resolved through DataSourceLookup).
	If no keyed targetDataSources match the current lookup key of determineCurrentLookupKey(), this DataSource will be used as the target.
	public void setDefaultTargetDataSource(Object defaultTargetDataSource) {
		this.defaultTargetDataSource = defaultTargetDataSource;

	If a specific data source for the current lookup key cannot be found, specify whether to apply a relaxed fallback to the default data source.
	The default is "true" and accepts a lookup key that does not have a corresponding entry in the target DataSource map -- in this case, simply go back to the default DataSource.
	If you want to apply fallback only when the lookup key is empty, switch this flag to "false". A lookup key without a data source entry will result in an IllegalStateException.
	public void setLenientFallback(boolean lenientFallback) {
		this.lenientFallback = lenientFallback;

	Sets the DataSourceLookup implementation used to resolve the data source name string in the targetDataSources map.
	The default is JNDI datasourcelookup, which allows you to directly specify the JNDI name of the application server DataSources.
	public void setDataSourceLookup(@Nullable DataSourceLookup dataSourceLookup) {
		this.dataSourceLookup = (dataSourceLookup != null ? dataSourceLookup : new JndiDataSourceLookup());

	public void afterPropertiesSet() {
		if (this.targetDataSources == null) {
			throw new IllegalArgumentException("Property 'targetDataSources' is required");
		this.resolvedDataSources = new HashMap<>(this.targetDataSources.size());
		this.targetDataSources.forEach((key, value) -> {
			Object lookupKey = resolveSpecifiedLookupKey(key);
			DataSource dataSource = resolveSpecifiedDataSource(value);
			this.resolvedDataSources.put(lookupKey, dataSource);
		if (this.defaultTargetDataSource != null) {
			this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);

	Resolves the given lookup key object to the actual lookup key in the manner specified in the targetDataSources map to match the current lookup key.
    The default implementation simply returns the given key as is.
    lookupKey—The lookup key object specified by the user
    Match the required lookup key	
	protected Object resolveSpecifiedLookupKey(Object lookupKey) {
		return lookupKey;

	Resolves the specified data source object to a DataSource instance.
    The default implementation handles the DataSource instance and data source name (resolved through DataSourceLookup).
    dataSource—The data source value object specified in the targetDataSources map
    Resolved datasource (never empty)
    IllegalArgumentException-In case of unsupported value type
	protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
		if (dataSource instanceof DataSource) {
			return (DataSource) dataSource;
		else if (dataSource instanceof String) {
			return this.dataSourceLookup.getDataSource((String) dataSource);
		else {
			throw new IllegalArgumentException(
					"Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);

	public Connection getConnection() throws SQLException {
		return determineTargetDataSource().getConnection();

	public Connection getConnection(String username, String password) throws SQLException {
		return determineTargetDataSource().getConnection(username, password);

	public <T> T unwrap(Class<T> iface) throws SQLException {
		if (iface.isInstance(this)) {
			return (T) this;
		return determineTargetDataSource().unwrap(iface);

	public boolean isWrapperFor(Class<?> iface) throws SQLException {
		return (iface.isInstance(this) || determineTargetDataSource().isWrapperFor(iface));

	Retrieves the current target data source. Determine the current lookup key, perform the lookup in the targetDataSources map, and return the specified default target DataSource if necessary.
	protected DataSource determineTargetDataSource() {
		Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
		Object lookupKey = determineCurrentLookupKey();
		DataSource dataSource = this.resolvedDataSources.get(lookupKey);
		if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
			dataSource = this.resolvedDefaultDataSource;
		if (dataSource == null) {
			throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
		return dataSource;

    Determines the current lookup key. This is usually used to check the transaction context of the thread binding.
    Allow any key. The returned key must match the stored lookup key type and be resolved by the resolvespecificedlookup key method.
	protected abstract Object determineCurrentLookupKey();

Note that the AOP order must precede the transaction order. If you don't understand the concept of order, you can baidu.

Dynamic data source code analysis process

Refer to the following blog post: Dynamic data source - springmanagedtransaction & & abstractroutingdatasource source code parsing process

No annotation for dynamic data source

The idea is to directly use aop to intercept the specified method, and use the characteristics of aop to set the part in advance.

public class DysourceController {
    DysourceService dysourceService;

    public Object primary(){
        return dysourceService.getAll();
    public Object secondary(){
        return dysourceService.getAll();

Enhanced under controller:

public class DataSourceAop {
    //Execute before the primary method
    @Before("execution(* com.serize.controller.DysourceController.primary(..))")
    public void setDataSource2test01() {
        System.err.println("Primary business");

    //Execute before using method
    @Before("execution(* com.serize.controller.DysourceController.secondary(..))")
    public void setDataSource2test02() {
        System.err.println("Secondary business");


#Configure master database

##Configure secondary database
public class DynamicDataSource extends AbstractRoutingDataSource {

    protected Object determineCurrentLookupKey() {
        DataSourceType.DataBaseType dataBaseType = DataSourceType.getDataBaseType();
        return dataBaseType;

public class DataSourceType {

    //The internal enumeration class is used to select a specific data type
    public enum DataBaseType {
        Primary, Secondary

    // Using ThreadLocal to ensure thread safety
    private static final ThreadLocal<DataBaseType> TYPE = new ThreadLocal<DataBaseType>();

    // Set the data source type to the current process
    public static void setDataBaseType(DataBaseType dataBaseType) {
        if (dataBaseType == null) {
            throw new NullPointerException();

    // Get data source type
    public static DataBaseType getDataBaseType() {
        DataBaseType dataBaseType = TYPE.get() == null ? DataBaseType.Primary : TYPE.get();
        return dataBaseType;

    // Clear data type
    public static void clearDataBaseType() {
@MapperScan(basePackages = "com.serize.mapper", sqlSessionFactoryRef = "SqlSessionFactory") //basePackages the address of our interface file
public class DynamicDataSourceConfig {

    // Put this object into the Spring container
    @Bean(name = "PrimaryDataSource")
    // Indicates that this data source is the default data source
    // Read the configuration parameters in and map them into an object
    // Prefix indicates the prefix of the parameter
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource getDateSource1() {
        return DataSourceBuilder.create().build();

    @Bean(name = "SecondaryDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.secondary")
    public DataSource getDateSource2() {
        return DataSourceBuilder.create().build();

    @Bean(name = "dynamicDataSource")
    public DynamicDataSource DataSource(@Qualifier("PrimaryDataSource") DataSource primaryDataSource,
                                        @Qualifier("SecondaryDataSource") DataSource secondaryDataSource) {

        //This place is the core of the comparison. The targetDataSource collection is the mapping between our database and the name
        Map<Object, Object> targetDataSource = new HashMap<>();
        targetDataSource.put(DataSourceType.DataBaseType.Primary, primaryDataSource);
        targetDataSource.put(DataSourceType.DataBaseType.Secondary, secondaryDataSource);
        DynamicDataSource dataSource = new DynamicDataSource(); 
        dataSource.setDefaultTargetDataSource(primaryDataSource);//Set default object
        return dataSource;

    @Bean(name = "SqlSessionFactory")
    public SqlSessionFactory SqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dynamicDataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
                new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/**/*Mapper.xml"));//Set our xml file path
        return bean.getObject();

Dynamic data source annotation (method level)

Add dynamic data source annotation

 * Toggle data annotation can be used at class or method level. Method level priority > class level
public @interface DataSource {
    String value() default "primary"; //This value is the key value. The default database is used by default

Add annotation method section

public class DynamicDataSourceAspect {
    @Before("@annotation(dataSource)")//Block our comments
    public void changeDataSource(JoinPoint point, DataSource dataSource) throws Throwable {
        String value = dataSource.value();
        if (value.equals("primary")){
        }else if (value.equals("secondary")){
        }else {
            DataSourceType.setDataBaseType(DataSourceType.DataBaseType.Primary);//The primary database is used by default


    @After("@annotation(dataSource)") //Clear configuration of data source
    public void restoreDataSource(JoinPoint point, DataSource dataSource) {

The summary is to give the method annotated and indicating which database to use to aop and set it before obtaining the connection.

Posted by michealholding on Tue, 21 Sep 2021 01:40:36 -0700