Spring 多数据源动态路由实现原理

悠悠 2022-01-16 13:23 402阅读 0赞

[2019独角兽企业重金招聘Python工程师标准>>> ][2019_Python_] ![hot3.png][]

**概述：**随着业务独立性强，数据量大的时候的，为了提高并发，可能会对表进行分库，分库后，以及读写分离的实现，每一个数据库都需要配置一个数据源。在此，做一个备份~

Spring但数据源的配置此处不再赘述，多数据源的情况也与此类似，下面会对配置做详细的描述。既然是多数据源，必然会引发一个问题：如果在应用运行时，动态的选择合适的数据源？

Spring 2.0.1引入了 AbstractRoutingDataSource 抽象类，实现根据 lookup key 从多个数据源中获取目标数据源。源码如下：最主要的方法：determineTargetDataSource() 决定使用哪一个数据源，方法中调用了determineCurrentLookupKey()来获取当前数据源的 lookup key，所有该抽象类的实现类都要实现这个方法。Spring也提供了一个它的实现类：IsolationLevelDataSourceRouter

public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
    
       private Map<Object, Object> targetDataSources;
    
       private Object defaultTargetDataSource;
    
       private boolean lenientFallback = true;
    
       private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
    
       private Map<Object, DataSource> resolvedDataSources;
    
       private DataSource resolvedDefaultDataSource;
    
        ....//此处省略部分代码
       
       /**
        * Retrieve the current target DataSource. Determines the
        * {@link #determineCurrentLookupKey() current lookup key}, performs
        * a lookup in the {@link #setTargetDataSources targetDataSources} map,
        * falls back to the specified
        * {@link #setDefaultTargetDataSource default target DataSource} if necessary.
        * @see #determineCurrentLookupKey()
        */
       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;
       }
    
       /**
        * Determine the current lookup key. This will typically be
        * implemented to check a thread-bound transaction context.
        * <p>Allows for arbitrary keys. The returned key needs
        * to match the stored lookup key type, as resolved by the
        * {@link #resolveSpecifiedLookupKey} method.
        */
       protected abstract Object determineCurrentLookupKey();
    
    }

IsolationLevelDataSourceRouter的实现如下：该实现类是根据当前事务的隔离级别选择合适的目标数据源，隔离级别的name作为key（TransactionDefinition接口中有具体的定义，此处不做详细描述）

public class IsolationLevelDataSourceRouter extends AbstractRoutingDataSource {
    
       /** Constants instance for TransactionDefinition */
       private static final Constants constants = new Constants(TransactionDefinition.class);
    
       /**
        * Supports Integer values for the isolation level constants
        * as well as isolation level names as defined on the
        * {@link org.springframework.transaction.TransactionDefinition TransactionDefinition interface}.
        */
       @Override
       protected Object resolveSpecifiedLookupKey(Object lookupKey) {
          if (lookupKey instanceof Integer) {
             return lookupKey;
          }
          else if (lookupKey instanceof String) {
             String constantName = (String) lookupKey;
             if (!constantName.startsWith(DefaultTransactionDefinition.PREFIX_ISOLATION)) {
                throw new IllegalArgumentException("Only isolation constants allowed");
             }
             return constants.asNumber(constantName);
          }
          else {
             throw new IllegalArgumentException(
                   "Invalid lookup key - needs to be isolation level Integer or isolation level name String: " + lookupKey);
          }
       }
    
       @Override
       protected Object determineCurrentLookupKey() {
          return TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
       }
    
    }

在具体的业务处理中需要自己实现AbstractRoutingDataSource，通常只需要实现determineCurrentLookupKey()方法即可：

public class DynamicDataSource extends AbstractRoutingDataSource {
    
        @Override
        protected Object determineCurrentLookupKey() {
            return DataSourceHolder.getDataSource();
        }
    }

其中，dataSource是通过 DataSouceHolder 来获取的，代码如下：

public class DataSourceHolder {
    
        private static final ThreadLocal<DataSource> dataSources = new ThreadLocal<DataSource>();
    
        public static void setDataSource(DataSource dataSource) {
            dataSources.set(dataSource);
        }
    
        public static DataSource getDataSource() {
            return dataSources.get();
        }
    
        public static void clearDataSource() {
            dataSources.remove();
        }
    }

**注意**：事务是线程级别的，不同线程之间互不影响，因此使用ThreadLocal来存放当前事务的DataSource。

接下来是多个数据源的配置文件：application-dao.xml，配置了三个数据源，parentDataSource为三个数据源抽出来的公共部分，减少冗余。

然后，需要配置一个动态数据源，类似于目标数据源的代理~ 其中，DynamicDataSource为前面提到的AbstractRoutingDataSource 的实现类，targetDataSources为所有数据源的map，defaultTargetDataSource 可以配置默认使用的数据源。

到此，Spring多数据源的配置已经完成，使用时也十分简单是需要DataSouceHolder.setDataSource(dataSource) 即可（业务中只需要在controller层或者service通过注解的方式注入数据源，在线程级别切换数据库）。

转载于:https://my.oschina.net/u/2260265/blog/1538186

[2019_Python_]: https://my.oschina.net/u/2663968/blog/3061697
[hot3.png]: /images/20220114/075113bf05764a5799043e294a734a7e.png