精华内容
下载资源
问答
  • druid多数据源 AOP注解切换数据源
    更多相关内容
  • 本项目是:SpringBoot 基于注解,实现多数据源切换(辅助用到:Druid连接池 + 事务 + MyBatis 等),项目下载后只需要修改一下.yml文件中的 MySQL 的URL连接,即可成功启动,欢迎大家下载
  • 基于spring boot mybatis的多数据源配置,使用Druid配置连接池,使用注解自动切换数据源,完美运行!
  • 本篇文章主要介绍了Java注解实现动态数据源切换的实例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • spring boot整合druid连接池,采用注解方式实现多数据源动态切换 jdk版本1.8 spring boot版本1.5.14
  • 动态数据源切换 1.适用场景 读写分离;测试、生产数据源切换;...实现过程:对所有的service层切入增加一个前置方法,判断当前执行方法的注解对应的数据源名称,切换到该数据源,再后置方法中再移除该数据源 ...

    动态数据源切换

          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.数据源的写入、读取类DynamicDataSourceDynamicDataSourceHolder

    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:2019822

         */

        //@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> <...

    多数据源实现请参考上文
    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

    展开全文
  • 使用注解配置实现Spring动态数据源切换,实现原理 1、自定义动态数据源类DynamicDataSource: 实现spring类AbstractRoutingDataSource的方法determineCurrentLookupKey 2、自定义Spring AOP类DataSourceAspect 3、...
  • Mybatis 自定义注解 自动切换数据源 1.创建数据源枚举 DataSources.java package mybatis.utils; public enum DataSources { /** * 默认数据源 IT 数据源 * 本地数据库 */ DATASOURCE, /** * TG */ ...

    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接口请求,获取写入的自定义注解,绑定需要使用的数据源

    展开全文
  • 使用springboot项目时用到了多数据源配置,在网上看了很多总感觉达不到自己的要求,所以浏览完之后决定自己写一个。 废话不说,上代码 pom.xml需要用到的支持 <?xml version="1.0" encoding="UTF-8"?> &...
  • 使用@DS注解切换数据源失败了吗?

    千次阅读 2021-03-23 20:04:00
    提示:文章写完后,目录可以自动生成,如何生成可参考右边...(@DS注解切换数据源失败了吗? 是也不是.) 一、问题描述 这里我就不对多数据源配置等进行多余赘述了,需要的可以自己去搜索一下,如配置使用,底层原理,与@Tra
  • 在同一项目中,如果要使用多个数据库进行分库,切换数据源实现如下: 导入POM.XML依赖 <!--切换数据源--> <dependency> <groupId>com.baomidou</groupId> <artifactId>dynamic...
  • 用springboot 集成mybatis多数据源,用aop实现的动态切换,支持事务,不会使aop动态切换失效。注意:此代码不涉及分布式事务,如果需要分布式事务 需要采取其他方案。
  • SpringBoot多数据源使用注解切换
  • 自定义注解实现多数据源切换,AbstractRoutingDataSource
  • 通过AOP自动切换,实现读写分离和读取的简单负载均衡
  • MyBatis-Plus 注解切换数据源 <groupId>com.baomidou</groupId> <artifactId>dynamic-datasource-spring-boot-starter ${version} </dependency>
  • springmvc+mybatis结合,多数据源配置,并实现注解aop动态切换,可实现数据库读写分离,maven结构。
  • 数据源配置 #数据源1 spring.datasource.bashsource.url=jdbc:mysql://地址:端口/数据库名称?useUnicode=true&characterEncoding=UTF-8&characterSetResults=UTF-8&useSSL=false&serverTimezone=...
  • 该资源仅为备份
  • SpringBoot 动态数据源注解切换

    千次阅读 2018-10-30 16:47:14
    动态切换数据源,mysql ,oracle 在项目中动态切换,或者 两个mysql进行切换 引入依赖 <dependency> <groupId>com.alibaba</groupId> <artifactId>druid-spring-boot-starter</...
  • springboot 基于注解实现多数据源切换

    千次阅读 2020-05-09 23:05:48
    1 背景 ...springboot 提供的AbstractRoutingDataSource实现多数据源动态切换的核心逻辑是:通过AOP的方式在程序运行时,把数据源通过 AbstractRoutingDataSource 动态织入到程序中,灵活地进行数据源
  • 最近公司有个需求,客户试用我们的产品到期了,签了正式的合同,准备迁移到生产环境,但是又想要保留测试的时候数据,因此我们开发组准备设计一个迁移程序,要考虑后期拓展与重复使用。这其中有个重...
  • 最终效果就是,通过在service层类或方法上,注解声明需要的数据源名称,从而实现切换数据源的目的 理论知识就不说了,直接上代码(不支持分布式事务)* 1.准备多数据源properties文件 &lt;!-- 数据库1 --&...
  • 先说一下我自己的情况,在测试类中手动切换数据源有效,但是使用@Datasource注解切换数据源不起作用 原因:数据源实现自动切换需要数据库的配置类需要加载到spring容器中,在测试类中没法加载到spring容器中去,...
  • 许多项目都有主库与从库,主库用来写,从库用来读。 那么在开发中,为了方便切库,我们通过可以用注解来标志,标志这个方法是使用主库还是从库 ...我们配置的多个数据源会放在AbstractRoutingDataSource的 t...
  • java多数据源切换(注解方式)

    千次阅读 2019-08-02 12:06:15
    前言 : 都说手动切换数据源比较傻,其实手动切换更好更清晰,注解方式有可能会出现意外情况;当然注解方式比较简洁,具体使用哪种方式,看个人喜欢吧! 一.配置多数据源映射关系 <!-- spring 配置文件的配置多数源映射...
  • 当一个项目中有多个数据源(也可以是主从库)的时候,我们可以利用注解在mapper接口上标注数据源,从而来实现多个数据源在运行时的动态切换。实现原理在Spring 2.0.1中引入了AbstractRoutingDataSource, 该类充当了...
  • } } } 7、使用切换数据源注解 @Service public class AreaServiceImpl implements AreaService { @Autowired CommonMapper mapper; @DataSource(value = DataSourceType.LOCAL) public List queryAreaLocal(Map ...
  • Spring+SpringMvc+MybatisPlus实现多数据源切换、利用自定义Aop注解,只需要在需要切换数据库的方法上加上注解即可实现、极大避免了代码冗余。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 80,820
精华内容 32,328
关键字:

注解切换数据源