简单粗暴的数据源切换

一、定义数据源

1、数据源1和数据源2，spring配置如下代码：

2、总数据源

​ 总的数据源Spring配置如下：

• DynamicDataSource的写法后边会介绍

二、定义切面

使用AOP拦截特定的注解去动态的切换数据源，代码如下：

三、具体的代码写法

• 编写AbstractRoutingDataSource的实现类,HandlerDataSource就是提供给我们动态选择数据源的数据的信息，我们这里编写一个根据当前线程来选择数据源，然后通过AOP拦截特定的注解，设置当前的数据源信息，也可以手动的设置当前的数据源，在编程的类中。

• 数据源切换实现类

  /**
   * 动态数据源抽象实现类(获取数据源对应的key)
   * @Description: 
   * @version 1.0
   */
  public class DynamicDataSource extends AbstractRoutingDataSource {
      @Override
      protected Object determineCurrentLookupKey() {
          return DynamicDataSourceHolder.getDataSourceKey();
      }
  }
  

• 设置拦截数据源的注解，可以设置在具体的类上，或者在具体的方法上，dataSource是当前数据源的一个别名用于标识我们的数据源的信息，代码如下：

  @Documented
  @Retention(RetentionPolicy.RUNTIME)
  @Target({ ElementType.TYPE, ElementType.METHOD })
  public @interface DataSource {
  
      /** 数据源名称 */
      DataSourceEnum value();
  }
  

  枚举类：

  public enum DataSourceEnum {
  
      /** 主库数据源 */
      MASTER("master", "主库数据源"),
      
      /** 从库数据源 */
      SLAVE("slave", "从库数据源");
  
  
      private DataSourceEnum(String key, String description) {
          this.key = key;
          this.description = description;
      }
  
      /** 数据源对应的key(用于在Spring配置文件中指定数据源Map中的key使用) */
      private String key;
  
      /** 说明 */
      private String description;
  
      public String getKey() {
          return key;
      }
  
      public void setKey(String key) {
          this.key = key;
      }
  
      public String getDescription() {
          return description;
      }
  
      public void setDescription(String description) {
          this.description = description;
      }
  }
  

• AOP拦截类的实现，通过拦截上面的注解，在其执行之前处理设置当前执行SQL的数据源的信息，主要是环绕通知；

  /**
   * @version 1.0
   * @Description: 数据源切面类
   */
  public class DataSourceAspect {
  
      /**
       * 在数据库调用之前进行数据源设置 注：
  
       * 对于数据源设置采取就近原则： 
  
       * 1、如果方法上有数据源设置则以方法为准 
  
       * 2、如果方法上没有进行数据源设置则以类上的数据源设置为准
       */
      public void before(JoinPoint joinPoint) {
          // 目标类
          Object target = joinPoint.getTarget();
          // 目标类Class字节码
          Class targetClass = target.getClass();
          // 目标方法的签名
          Signature signature = joinPoint.getSignature();
          // 目标方法名
          String methodName = signature.getName();
          // 目标方法的参数类型数组
          Class[] parameterTypes = ((MethodSignature) signature).getMethod().getParameterTypes();
  
          try {
              DataSource dataSource = null;
              Method method = targetClass.getMethod(methodName, parameterTypes);
              if (method != null && method.isAnnotationPresent(DataSource.class)) // 获取方法上的数据源设置
                  dataSource = method.getAnnotation(DataSource.class);
              else if (targetClass.isAnnotationPresent(DataSource.class)) // 获取类上的数据源设置
                  dataSource = targetClass.getAnnotation(DataSource.class);
  
              if (dataSource != null) {
                  DataSourceEnum dataSourceName = dataSource.value();
                  String key = dataSourceName.getKey();
                  DynamicDataSourceHolder.setDataSourceKey(key);
              }
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  
      public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
          // 目标类
          Object target = proceedingJoinPoint.getTarget();
          // 目标类Class字节码
          Class targetClass = target.getClass();
          // 目标方法的签名
          Signature signature = proceedingJoinPoint.getSignature();
          // 目标方法名
          String methodName = signature.getName();
          // 目标方法的参数类型数组
          Class[] parameterTypes = ((MethodSignature) signature).getMethod().getParameterTypes();
  
          try {
              DataSource dataSource = null;
              Method method = targetClass.getMethod(methodName, parameterTypes);
              if (method != null && method.isAnnotationPresent(DataSource.class)) { // 获取方法上的数据源设置
                  dataSource = method.getAnnotation(DataSource.class);
              } else if (targetClass.isAnnotationPresent(DataSource.class)) { // 获取类上的数据源设置
                  dataSource = targetClass.getAnnotation(DataSource.class);
              }
  
              if (dataSource != null) {
                  DataSourceEnum dataSourceName = dataSource.value();
                  DynamicDataSourceHolder.setDataSourceKey(dataSourceName.getKey());
              }
              return proceedingJoinPoint.proceed();
          } finally {
              DynamicDataSourceHolder.clearDataSourceKey();
          }
      }
  
  
  }
  
  

• 根据当前线程来选择具体的数据源

  /**
   * 动态数据源持有者
   * @Description:
   * @version 1.0
   */
  public class DynamicDataSourceHolder {
  
      private static ThreadLocal threadLocal = new ThreadLocal();
  
      /**
       * 设置数据源的对应的key
       * 
       * @param key
       *            数据源的对应的key(数据源枚举常量类中对应的key)
       */
      public static void setDataSourceKey(String key) {
          threadLocal.set(key);
      }
  
      /**
       * 获取数据源对应的key
       * 
       * @return String 数据源对应的key
       */
      public static String getDataSourceKey() {
          return threadLocal.get();
      }
  
  
      /**
       * 清空数据源key
       */
      public static void clearDataSourceKey() {
          threadLocal.remove();
      }
  }
  

• 以上就是动态数据源切换的代码，比如查询的时候，我想用SLAVE从库,在service层加个注解即可，如下：

      @DataSource(DataSourceEnum.SLAVE)
      public Xxxx queryXXXById(String id) {
          return xxxDao.queryXXXById(id);
      }