spring 多数据源的使用

• 在同一个项目中需要使用多个数据源，这就需要根据不同的场景进行切换数据源，spring给我们提供一种很方便的方式，那就是使用 AbstractRoutingDataSource 进行切换数据源。

• 首先来看 AbstractRoutingDataSource 这个类，下面是这个类源码。

  public abstract class AbstractRoutingDataSource extends AbstractDataSource implements InitializingBean {
      // 需要存储的所有数据源，需要在 bean 生成后进行注入，key 为获得数据源名称，value 为数据源
      private Map<Object, Object> targetDataSources;
  
      private Object defaultTargetDataSource;  // 初始设计的默认数据源
  
      // 如果在查找数据源时，找不到相应的数据源时是否使用默认数据源
      private boolean lenientFallback = true;
  
      // 通过 JNDI 方式的来获取一个数据源
      private DataSourceLookup dataSourceLookup = new JndiDataSourceLookup();
  
      // 将 targetDataSources 通过转化得到的数据源的集合。（如果不使用 JNDI 方式，它和 targetDataSources 是一样的）
      private Map<Object, DataSource> resolvedDataSources;
  
      // 转化后的默认数据源，如果在数据源的 key 为 null 时会使用，默认数据源，当然还有其他情况，下面会介绍
      private DataSource resolvedDefaultDataSource;
  
      public void setTargetDataSources(Map<Object, Object> targetDataSources) {
          this.targetDataSources = targetDataSources;
      }
  
      public void setDefaultTargetDataSource(Object defaultTargetDataSource) {
          this.defaultTargetDataSource = defaultTargetDataSource;
      }
  
      public void setLenientFallback(boolean lenientFallback) {
          this.lenientFallback = lenientFallback;
      }
  
      public void setDataSourceLookup(DataSourceLookup dataSourceLookup) {
          this.dataSourceLookup = (dataSourceLookup != null ? dataSourceLookup : new JndiDataSourceLookup());
      }
  
  
      /**
       * 因为该类实现了 InitializingBean，所以会在 bean 生成之后（@Bean 注解执行之后，或者 xml 解析完之后）执行该方法
       */
      @Override
      public void afterPropertiesSet() {
          if (this.targetDataSources == null) {  // 必须在 Bean 生成后注入数据源
              throw new IllegalArgumentException("Property ‘targetDataSources‘ is required");
          }
          this.resolvedDataSources = new HashMap<Object, DataSource>(this.targetDataSources.size());
          for (Map.Entry<Object, Object> entry : this.targetDataSources.entrySet()) {
              Object lookupKey = resolveSpecifiedLookupKey(entry.getKey());  // 对数据源名称进行重定义
              DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());    // 获取数据源
              this.resolvedDataSources.put(lookupKey, dataSource);
          }
          if (this.defaultTargetDataSource != null) {  // 设置默认数据源
              this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
          }
      }
  
      /**
       * 变换 lookupKey，由子类实现， 默认是 targetDataSources 的原始 key
       */
      protected Object resolveSpecifiedLookupKey(Object lookupKey) {
          return lookupKey;
      }
  
      /**
       * 获取数据，直接获取，或者是通过 JNDI 的方法进行获取
       */
      protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
          if (dataSource instanceof DataSource) {  // targetDataSources 中直接存储的就是数据源
              return (DataSource) dataSource;
          }
          else if (dataSource instanceof String) {  // 通过 JNDI 的方法获取数据源
              return this.dataSourceLookup.getDataSource((String) dataSource);
          }
          else {
              throw new IllegalArgumentException(
                      "Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
          }
      }
  
  
      /**
       * 获取数据源的数据库连接
       */
      @Override
      public Connection getConnection() throws SQLException {
          return determineTargetDataSource().getConnection();
      }
  
      /**
       * 通过用户名和密码的方式获取数据库连接
       */
      @Override
      public Connection getConnection(String username, String password) throws SQLException {
          return determineTargetDataSource().getConnection(username, password);
      }
  
      @Override
      @SuppressWarnings("unchecked")
      public <T> T unwrap(Class<T> iface) throws SQLException {
          if (iface.isInstance(this)) {
              return (T) this;
          }
          return determineTargetDataSource().unwrap(iface);
      }
  
      @Override
      public boolean isWrapperFor(Class<?> iface) throws SQLException {
          return (iface.isInstance(this) || determineTargetDataSource().isWrapperFor(iface));
      }
  
      /**
       * 通过 lookupKey 来获取数据源
       */
      protected DataSource determineTargetDataSource() {
          Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");
          Object lookupKey = determineCurrentLookupKey();  // 获取需要数据源的 lookupKey
          // 从已经转化过的数据源查找相应的数据源
          DataSource dataSource = this.resolvedDataSources.get(lookupKey);
  
          // 如果没有找到数据源，或者可以使用默认数据源，或者 lookupKey 为 null，则使用默认数据源
          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;
      }
  
      /**
       * 由子类实现，返回需要获取的数据源的 lookupKey
       */
      protected abstract Object determineCurrentLookupKey();
  
  }
  
  

• 如果要实现多数据源的方式就必须要继承类，然后实现其抽象方法，下面给出一种我的实现方式：

• 多数据源的的实现：

  public class MultipleDataSource extends AbstractRoutingDataSource {
  
      // 通过 ThreadLocal 的方式来为每个线程一存储个不同的数据源名称
      private static final ThreadLocal<String> dataSourceKey = new ThreadLocal<>();
  
      /**
       * 设置数据源，可以考虑使用注解 aop 的方式，在每个方法执行进行拦截，然后将数据源名称(lookupKey) 设置进行去
       */
      public static void setDataSourceKey(String dataSource) {
          dataSourceKey.set(dataSource);
      }
  
      /**
       * 实现父类的获取数据名称的方法
       */
      @Override
      protected Object determineCurrentLookupKey() {
          String dsName = dataSourceKey.get();
          dataSourceKey.remove();  // 注意要删除，否则可能内存泄漏
          return dsName;
      }
  }
  
  

• 多数据源的注入 spring 容器：

  @Bean("master")
  public DataSource masterDataSource(){
      return new C3p0SingleDataSource();
  }
  
  @Bean("slaver")
  public DataSource slaverDataSource(){
      return new BladeDataSource();
  }
  
  @Bean
  public DataSource dataSource(@Qualifier("master") DataSource master, @Qualifier("slaver") DataSource slaver){
      Map<Object, Object> targetDataSources = new HashMap<>();
      targetDataSources.put("master", master);
      targetDataSources.put("slaver", slaver);
  
      MultipleDataSource multipleDataSource = new MultipleDataSource();
      multipleDataSource.setTargetDataSources(targetDataSources);  // 注入
      multipleDataSource.setDefaultTargetDataSource(master);  // 设置默认数据源
      return multipleDataSource;
  }
  

• 注意上面的 master 和 slaver 数据源都是随便 new 的，具体使用时还需要自己设置数据库的相应属性。

• 再考虑写一个多数据源的注解和 aop，可以加在方法和类上面，可以进行多数据源的使用：

  @Target({ElementType.METHOD, ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  public @interface DataSource {
      String value() default "";
  }
  

  @Aspect
  @Component
  public class DataSourceAspect {
      public DataSourceAspect() {
      }
  
      @Around("@within(dataSource) || @annotation(dataSource)")
      public Object around(ProceedingJoinPoint joinPoint, DataSource dataSource) throws Throwable {
          if (null == dataSource) {
              dataSource = (DataSource)extractClassLevelAnnotation(joinPoint, DataSource.class);
          }
          
          MultipleDataSource.setDataSourceKey(dataSource.value());
          return joinPoint.proceed();
      }
      
      public static Annotation extractClassLevelAnnotation(JoinPoint joinPoint, Class clazz) {
          for(Annotation annotation : joinPoint.getTarget().getClass().getAnnotations()) {
              if (annotation.annotationType() == clazz) {
                  return annotation;
              }
          }
          throw new RuntimeException("类:" + joinPoint.getTarget().getClass().getSimpleName() + "没有找到" + clazz.getName() + "注解");
      }
  }
  
  

• DataSource 注解可以类上面，表示类中的所有方法都使用该数据源，也可以加在方法上面，如果都加了，则会使用方法上面的那个。

  @DataSource("slave")
  public interface UserDao {
  
      @DataSource("master")
      int insert(UserPO userPO);
  }