动态数据源切换

      1.适用场景

读写分离；测试、生产数据源切换；大数据连接；其他系统数据连接

      2.设计思路

                  a.实现结果：通过读取注解来连接不同数据源

                  b.实现过程：对所有的service层切入增加一个前置方法，判断当前执行方法的注解对应的数据源名称，切换到该数据源，再后置方法中再移除该数据源

       3.实现步骤

                  本例使用双数据源，多数据源以此类推

1. 数据库两份份连接信息

截图：

 

代码：

#dataSoruceInformation1

driver=com.mysql.jdbc.Driver 

url=jdbc\:mysql\://127.0.0.1/yx?useUnicode\=true&characterEncoding\=utf-8

username=root

password=root

 

#dataSoruceInformation2

localdriver=com.mysql.jdbc.Driver

localurl=jdbc\:mysql\://其他IP/yx?useUnicode\=true&characterEncoding\=utf-8

localusername=root

localpassword=root

 

#commonInformation

initialSize=5 

minIdle=5

maxIdle=20

maxActive=150

 

    2.spring.xml中

    a.创建数据源

截图：

 

代码:

<bean id="bdySource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${driver}"></property>

        <property name="url" value="${url}"></property>

        <property name="username" value="${username}"></property>

        <property name="password" value="${password}"></property>

        <property name="initialSize" value="${initialSize}"></property>

        <property name="minIdle" value="${minIdle}"></property>

        <property name="maxIdle" value="${maxIdle}"></property>

        <property name="maxActive" value="${maxActive}"></property>

    </bean>

    <!-- 创建数据源（数据库连接池使用DBCP） -->

    <bean id="localSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

        <property name="driverClassName" value="${localdriver}"></property>

        <property name="url" value="${localurl}"></property>

        <property name="username" value="${localusername}"></property>

        <property name="password" value="${localpassword}"></property>

        <property name="initialSize" value="${initialSize}"></property>

        <property name="minIdle" value="${minIdle}"></property>

        <property name="maxIdle" value="${maxIdle}"></property>

        <property name="maxActive" value="${maxActive}"></property>

    </bean>

    <bean id="dataSource" class="com.chm.common.dataSource.DynamicDataSource">

        <property name="targetDataSources">

            <map key-type="java.lang.String">

                <entry key="bdySource" value-ref="bdySource"/>

                <entry key="localSource" value-ref="localSource"/>

            </map>

        </property>

        <property name="defaultTargetDataSource" ref="localSource"></property> 

    </bean>

   

 b.定义切面

     截图

 

代码

<!-- 配置数据库注解aop -->

    <bean id="dataSourceAspect" class="com.chm.common.dataSource.DataSourceAspect" />

    <aop:config>

        <aop:aspect id="c" ref="dataSourceAspect">

            <aop:pointcut id="tx" expression="execution (* com.chm.service.*..*.*(..))"/>

            <aop:before pointcut-ref="tx" method="before"/>

            <aop:after pointcut-ref="tx" method="after"/>

        </aop:aspect>

    </aop:config>

    <!-- 配置数据库注解aop -->

 

3.注解  

a.注解枚举类

public enum DataType {

    master("bdySource"),slave("localSource");

    private String value;

    DataType(String name){

        this.value = name;

    }

 

    public String getValue() {

        return value;

    }

 

    public void setValue(String value) {

        this.value = value;

    }

}

 

b.注解

import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;

 

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

public @interface DataSource {

    DataType value() default DataType.master;

}

 

c.数据源的写入、读取类DynamicDataSource、DynamicDataSourceHolder

DynamicDataSource类：

 

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

 

public class DynamicDataSource extends AbstractRoutingDataSource{

    protected Object determineCurrentLookupKey() {

        return DynamicDataSourceHolder.getThreadLocal();

    }

}

 

DynamicDataSourceHolder类：

public  class DynamicDataSourceHolder {

    private static final ThreadLocal<String> threadLocal = new ThreadLocal<String>();

 

    public static String getThreadLocal() {

        return threadLocal.get();

    }

 

    public static void setThreadLocal(String name) {

        threadLocal.set(name);

    }

    public static void clear(){

        threadLocal.remove();

    }

}

 

d.切面类

import java.lang.reflect.Method;

import org.apache.log4j.Logger;

import org.aspectj.lang.JoinPoint;

import com.chm.common.annotation.DataSource;

import com.chm.common.annotation.DataType;

 

public class DataSourceAspect {

    Logger logger = Logger.getLogger(this.getClass());

   

    //切入的类

    //@Pointcut("execution (* com.chm.service.*..*.*(..))")

    public void aspect(){

 

    }

   

    //前置方法---添加数据源

    //@Before("aspect()")

    public void before(JoinPoint joinPoint){

    //获取当前执行的方法名

    String name = joinPoint.getSignature().getName();

   

    //获取class对象

    Class<? extends Object> clazz = joinPoint.getTarget().getClass();

    //获取所有方法

    Method[] methods = clazz.getMethods();

    for (Method method2 : methods) {

        //给当前方法添加数据源

            if(name.equals(method2.getName())){

                //获取当前方法的注解

                DataSource dataSourceKey = (DataSource) method2.getAnnotation(DataSource.class);

                if (dataSourceKey != null) {

                   //在ThreadLocal放入当前注解对应的数据源

                   DynamicDataSourceHolder.setThreadLocal(dataSourceKey.value().getValue());

                   logger.info("---数据源--"+dataSourceKey.value().getValue()+"--添加---");

                   return;

                }else{

                   //注解为空，默认使用master

                    DynamicDataSourceHolder.setThreadLocal(DataType.master.getValue());

                   logger.info("---默认数据源--"+DataType.master.getValue()+"--添加---");

                   return;

                }

            }

        }

   

    }

   

   

    /**

     *

     * <br>Description:TODO 后置方法--移除数据源

     * <br>Author:陈慧明(1648652774@qq.com)

     * <br>Date:2019年8月22日

     */

    //@After("aspect()")

    public void after(){

        DynamicDataSourceHolder.clear();

        logger.info("---数据源--移除---");

    }

}

 

e.测试

截图：

代码

import java.util.List;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.chm.common.annotation.DataSource;
import com.chm.common.annotation.DataType;
import com.chm.dao.user.UserMapper;
import com.chm.model.user.User;
import com.chm.service.user.UserService;
@Service
public class UserServiceImpl implements UserService {
    
    @Resource
    private UserMapper userMapper;
    
    
    @DataSource(DataType.slave) 
    public List<User> getList() {
        return userMapper.getList();
    }
    
    
    @DataSource(DataType.master) 
    public List<User> getList2() {
        return userMapper.getList2();
    }

}

 

多数据源实现请参考上文
Springboot + HikariCp + MybatisPlus多数据源配置 （1）

由于手动切换在我看来并不优雅，但他最主要的是能够让我少写点代码。所以出现了Aop

首先引入aop依赖

	<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-aop</artifactId>
	 </dependency>

定义注解@DB

	@Target({ ElementType.METHOD, ElementType.TYPE })
	@Retention(RetentionPolicy.RUNTIME)
	@Documented
	@Inherited
	public @interface DB
	{
	    /**
	     * 切换数据源名称
	     */
	     DataSourceType value() default DataSourceType.DB1;
	}

接下来我们对注解进行Aop，通过注解value切换数据源

	@Aspect
	//配置加载顺序
	@Order(1)
	@Component
	public class DataSourceAspect {
	
	    @Pointcut("@annotation(com.south.system.annotation.DB)")
	    public void doPointCut(){}
	
	    @Around("doPointCut()")
	    public Object around(ProceedingJoinPoint point) throws Throwable {
	        DB dataSource = getDataSource(point);
	        if (!Objects.isNull(dataSource)){
	            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
	        }
	        try {
	            return point.proceed();
	        }
	        finally {
	            // 在执行方法之后 销毁数据源
	            DynamicDataSourceContextHolder.clearDataSourceType();
	        }
	    }
	
	    /**
	     * 获取@DB注解
	     */
	    public DB getDataSource(ProceedingJoinPoint point){
	
	        //获得当前访问的class
	        Class<? extends Object> className = point.getTarget().getClass();
	
	        // 判断是否存在@DateBase注解
	        if (className.isAnnotationPresent(DB.class)) {
	            //获取注解
	            DB targetDataSource = className.getAnnotation(DB.class);
	            return targetDataSource;
	        }
	
	        Method method = ((MethodSignature)point.getSignature()).getMethod();
	        DB dataSource = method.getAnnotation(DB.class);
	        return dataSource;
	
	    }
	}

这时候只需要在方法或者类上加上一个注解，就可以达到切换数据源的效果了

测试

	@Service
	public class DbServiceImpl implements DbService {
	
	    @Autowired
	    private SysUserOneDao sysUserOneDao;
	
	    @Autowired
	    private SysTwoDao sysTwoDao;
	
	    @DB
	    @Override
	    public SysUserOne getUser(long id) {
	        return sysUserOneDao.selectById(id);
	    }
	
	    @DB(DataSourceType.DB2)
	    @Override
	    public SysTwo getTwo(long id) {
	        return sysTwoDao.selectById(id);
	    }
	}

结果：

这里不添加注解的话还是使用的默认数据源

存在问题：

多数据源事务问题

Demo地址：https://github.com/South7i/dynamicdb

Mybatis 自定义注解 自动切换数据源

1.创建数据源枚举 DataSources.java

package mybatis.utils;

public enum DataSources {
	/**
	 * 默认数据源 IT 数据源
	 * 本地数据库
	 */
	DATASOURCE,
	/**
	 * TG
	 */
	TG, 
	/**
	 * WB
	 */
	WB;
}

2.创建数据源管理器 DataSourceTypeManager.java

package mybatis.utils;

/**
 * 数据源管理器
 * @author callens
 *
 */
public class DataSourceTypeManager {
	
	/**
	 * 用于确保多线程安全问题
	 */
	private static final ThreadLocal<DataSources> dataSourceTypes=new InheritableThreadLocal<DataSources>() {

		@Override
		protected DataSources initialValue() {
			return DataSources.DATASOURCE; //设置默认数据源
		}
	};
	
	/**
	 * 获取DataSource的数据源名称
	 * @return
	 */
	public static DataSources get() {
		return dataSourceTypes.get();
	}
	
	/**
	 * 根据数据源名称，设置数据源
	 * @param dataSourceType
	 */
	public static void set(DataSources dataSourceType) {
		dataSourceTypes.set(dataSourceType);
	}
	
	/**
	 * 重置数据源，并设置数据源为默认数据源
	 */
	public static void reset() {
		dataSourceTypes.set(DataSources.DATASOURCE);
	}
}

3.创建 数据源切换管理器 ThreadLocalRountingDataSource.java

package mybatis.utils;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

/**
 * 数据源切换管理器，需继承AbstractRoutingDataSource，此类有Spring提供
 * @author xxyf55
 *
 */
public class ThreadLocalRountingDataSource extends AbstractRoutingDataSource{

	@Override
	protected Object determineCurrentLookupKey() {
		return DataSourceTypeManager.get();
	}
}

4.在spring中进行配置

 
 <bean id="restuctureDataSource" class="mybatis.utils.ThreadLocalRountingDataSource">
    	<property name="defaultTargetDataSource" ref="dataSource" />
    	<property name="targetDataSources">
    		<map key-type="mybatis.utils.DataSources">
    			<entry key="DATASOURCE" value-ref="dataSource"></entry>
    			<entry key="TG" value-ref="tg"></entry>
    			<entry key="WB" value-ref="wb"></entry>
    		</map>
    	</property>
    </bean>
    
    <!-- 配置MyBatis -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 注入数据库连接池 -->
        <property name="dataSource" ref="restuctureDataSource"/>
    </bean>
    
    <!-- 本地数据库 -->
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
		init-method="init" destroy-method="close" lazy-init="false">
		<property name="driverClassName" value="oracle.jdbc.OracleDriver" />
	</bean>
	<bean id="wb" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
		<property name="driverClassName" value="oracle.jdbc.OracleDriver" />
	</bean>
	<bean id="tg" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
		<property name="driverClassName" value="oracle.jdbc.OracleDriver" />
	</bean>

5.添加自定义注解 TargetDataSource.java

package mybatis.utils;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 自定义注解，用于获取当前方法需要调用的数据源
 * <br> 改作用为获取数据源配置信息，使用不同的数据源进行操作数据
 * <br> 当前不支持分布式事物
 * <br> 若使用分布式事物，则需要进行自定义
 * @author callens
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TargetDataSource {

	DataSources dataSource() default DataSources.DATASOURCE;
	
}

6.添加AOP DynamicDataSourceAspect.java

package mybatis.utils.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Repository;

import lombok.extern.slf4j.Slf4j;
import mybatis.utils.DataSourceTypeManager;
import mybatis.utils.DataSources;
import mybatis.utils.TargetDataSource;

@Aspect
@Order(-1)
@Repository
@Slf4j
public class DynamicDataSourceAspect {
	/**
	 * 设置需要拦截的请求
	 */
	@Pointcut("execution(* mybatis.mapper..*(..))")
	public void pointCut() {
		
	}
	
	@Before("@annotation(targetDataSource)")
	public void doBefore(JoinPoint joinPoint,TargetDataSource targetDataSource) throws Throwable {
		if(targetDataSource==null) {
			DataSourceTypeManager.set(DataSources.DATASOURCE);
			log.debug("this used datasource is {}",DataSources.DATASOURCE);
		}else {
			DataSources dataSource=targetDataSource.dataSource();
			log.debug("this used datasource is {}",dataSource);
			DataSourceTypeManager.set(dataSource);
		}
	}
	
	@After("@annotation(targetDataSource)")
	public void doAfter(JoinPoint joinPoint,TargetDataSource targetDataSource) {
		DataSourceTypeManager.reset();
	}
	
	/**
	 * 当AOP切换数据源失败的时候，重置数据源
	 * @param joinPoint
	 * @param targetDataSource
	 * @param e
	 */
	@AfterThrowing(value="@annotation(targetDataSource)",throwing="e")
	public void doException(JoinPoint joinPoint,TargetDataSource targetDataSource,Throwable e) {
		DataSourceTypeManager.reset();
	}
}

7.如何使用

package mybatis.mapper.cc;

import java.util.List;

import com.shine.pb.entity.ScyxProductPO;
import com.shine.pb.query.ShineQueryInfo;
import mybatis.utils.DataSources;
import mybatis.utils.TargetDataSource;

import org.apache.ibatis.annotations.Param;

public  interface CCMapper {

    @TargetDataSource(dataSource=DataSources.tg)
    List<PO> getDetail(@Param("page")Page page, @Param("po")PO po);
    
    List<PO> getList(@Param("page")Page page, @Param("po")PO po);
}

如果在mapper的接口中写入自定的注解，并标注所使用的数据源，则mybatis会自动切换到所标注的数据源

如果不进行定义，则使用默认的数据源

核心逻辑

ThreadLocalRountingDataSource类数据源切换管理器，需继承AbstractRoutingDataSource，此类由Spring提供

DataSourceTypeManager数据源管理器 用于保证线程安全，其所用为设置数据源，获取数据源，重置数据源等

DataSources 枚举类，用于保存数据源的id使其对应到spring中

TargetDataSource 自定义注解

DynamicDataSourceAspect AOP拦截类，拦截Mapper接口请求，获取写入的自定义注解，绑定需要使用的数据源