【java】 浅谈动态数据源切换和Spring两种代理JDK和CGLIB的区别

最新推荐文章于 2023-06-20 22:03:05 发布
原创 最新推荐文章于 2023-06-20 22:03:05 发布 · 516 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#JDK动态代理 #CGLIB代理 #AOP #Dynamic DataSource

本文介绍了一种在多数据源环境下动态切换数据源的方法。利用Spring AOP技术，结合ThreadLocal实现不同业务场景下的数据源选择。代码示例展示了如何为特定包下的DAO层设置不同的数据源。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在做拆库的项目时，我们针对DAO层做动态数据源（Dynamic DataSource）切换，指定package来使用哪个数据源，这种动态切换数据源的方式，我们使用的是Spring Aop来实现的：

项目用的Hibernate、SpringJDBC、Mybatis组合来实现ORM，改造的过程中曾经遇到过不能切换数据源的情况，启动服务报错，具体报错忘记记录了，但是报错的根源是针对Spring Aop的动态代理的使用出现问题，先来看两种代码的介绍：

（1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类和接口；
（2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，因为是继承，所以类的方法最好不要声明成final；

通过介绍我们也已经很清楚使用方法了，更多的Spring Aop的动态代理知识自行解决，网上资源很多。我们在改造的过程中，出现的问题就是我们对JDK动态代理使用错误，我们针对接口使用了，这个错误印象比较深刻，等等类似的情况不介绍了。
  

下面同时也记录下动态数据源的切换，后续项目开发可以直接只用了，代码不介绍了，自行解决，网上也是资源很多的：

/**
 * @Description: 多数据源配置
 */
public class DataBaseContextHolder {

	/**
	 * 注意：数据源标识保存在线程变量中，避免多线程操作数据源时互相干扰
	 */
	private static final ThreadLocal<String> THREAD_DATA_SOURCE = new ThreadLocal<String>();

	public static String getDataSource() {
		return THREAD_DATA_SOURCE.get();
	}

	public static void setDataSource(String dateSource) {
		THREAD_DATA_SOURCE.set(dateSource);
	}

	public static void clearDataSource() {
		THREAD_DATA_SOURCE.remove();
	}

}
/**
 * @Description: 动态数据源配置
 */
public class DynamicDataSource extends AbstractRoutingDataSource {

	private static final Logger logger = Logger.getLogger(DynamicDataSource.class);

	@Override
	protected Object determineCurrentLookupKey() {

		String dataSource = DataBaseContextHolder.getDataSource();

		logger.info("\n\n=======The Current DateBase:" + dataSource + "=======\n\n");

		return dataSource;
	}

}

/**
 * @Description: 动态数据源拦截器
 */
public class DataSourceInterceptor {

	private static final Logger logger = Logger.getLogger(DataSourceInterceptor.class);

	public Object nsDataSource(ProceedingJoinPoint pjp) throws Throwable {

		DataBaseContextHolder.setDataSource("nsDataSource");

		String className = pjp.getTarget().getClass().getSimpleName();

		String methodName = pjp.getSignature().getName();

		logger.debug(className + "." + methodName + "[" + DataBaseContextHolder.getDataSource() + "](......)");

		return pjp.proceed();
	}
	
	public Object collateDataSource(ProceedingJoinPoint pjp) throws Throwable {

		DataBaseContextHolder.setDataSource("collateDataSource");

		String className = pjp.getTarget().getClass().getSimpleName();

		String methodName = pjp.getSignature().getName();

		logger.debug(className + "." + methodName + "[" + DataBaseContextHolder.getDataSource() + "](......)");

		return pjp.proceed();
	}

	public Object naDataSource(ProceedingJoinPoint pjp) throws Throwable {

		DataBaseContextHolder.setDataSource("naDataSource");

		String className = pjp.getTarget().getClass().getSimpleName();

		String methodName = pjp.getSignature().getName();

		logger.debug(className + "." + methodName + "[" + DataBaseContextHolder.getDataSource() + "](......)");

		return pjp.proceed();
	}

	public Object ntDataSource(ProceedingJoinPoint pjp) throws Throwable {

		DataBaseContextHolder.setDataSource("ntDataSource");

		String className = pjp.getTarget().getClass().getSimpleName();

		String methodName = pjp.getSignature().getName();

		logger.debug(className + "." + methodName + "[" + DataBaseContextHolder.getDataSource() + "](......)");

		return pjp.proceed();
	}

	public void clearDBType() {

		logger.debug("clearDataSource...");

		DataBaseContextHolder.clearDataSource();
	}

}


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:util="http://www.springframework.org/schema/util"
	xmlns:task="http://www.springframework.org/schema/task"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
	http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd"
	default-autowire="byName">
	
	<!-- 交易库 -->
	<bean id="nsDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.ns.driverClassName}" />
		<property name="url" value="${jdbc.ns.url}" />
		<property name="username" value="${jdbc.ns.username}" />
		<property name="password" value="${jdbc.ns.password}" />
		<property name="testOnBorrow" value="true" />
		<property name="maxActive" value="5" />
		<property name="initialSize" value="2" />
		<property name="maxIdle" value="2" />
		<property name="maxWait" value="30000" />
		<property name="validationQuery" value="select 1 from dual" />
<!-- 		<property name="connectionProperties" value="v$session.machine=${oracle.clientMachine};v$session.program=${project.name}"/>
 -->	</bean>  
	
	<!-- 对账库 -->
	<bean id="collateDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.collate.driverClassName}" />
		<property name="url" value="${jdbc.collate.url}" />
		<property name="username" value="${jdbc.collate.username}" />
		<property name="password" value="${jdbc.collate.password}" />
		<property name="testOnBorrow" value="true" />
		<property name="maxActive"    value="5" />
		<property name="initialSize"  value="2" />
		<property name="maxIdle"      value="2" />
		<property name="maxWait"      value="30000" />
		<property name="validationQuery" value="select 1 from dual" />
<!-- 		<property name="connectionProperties" value="v$session.machine=${oracle.clientMachine};v$session.program=${project.name}"/>
 -->	</bean>
	
	<!-- 账户库 -->
	<bean id="naDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.na.driverClassName}" />
		<property name="url" value="${jdbc.na.url}" />
		<property name="username" value="${jdbc.na.username}" />
		<property name="password" value="${jdbc.na.password}" />
		<property name="testOnBorrow" value="true" />
		<property name="maxActive"    value="5" />
		<property name="initialSize"  value="2" />
		<property name="maxIdle"      value="2" />
		<property name="maxWait"      value="30000" />
		<property name="validationQuery" value="select 1 from dual" />
<!-- 		<property name="connectionProperties" value="v$session.machine=${oracle.clientMachine};v$session.program=${project.name}"/>
 -->	</bean>
	
	<!-- 转账库 -->
	<bean id="ntDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="${jdbc.nt.driverClassName}" />
		<property name="url" value="${jdbc.nt.url}" />
		<property name="username" value="${jdbc.nt.username}" />
		<property name="password" value="${jdbc.nt.password}" />
		<property name="testOnBorrow" value="true" />
		<property name="maxActive"    value="5" />
		<property name="initialSize"  value="2" />
		<property name="maxIdle"      value="2" />
		<property name="maxWait"      value="30000" />
		<property name="validationQuery" value="select 1 from dual" />
		<!-- <property name="connectionProperties" value="v$session.machine=${oracle.clientMachine};v$session.program=${project.name}"/> -->
	</bean>

	<bean id="dynamicDataSource" class="com.test.base.dynamicdb.DynamicDataSource">
		<property name="targetDataSources">
			<map key-type="java.lang.String">
				<entry key="nsDataSource" value-ref="nsDataSource"></entry>
				<entry key="collateDataSource" value-ref="collateDataSource"></entry>
				<entry key="naDataSource" value-ref="naDataSource"></entry>
				<entry key="ntDataSource" value-ref="ntDataSource"></entry>
			</map>
		</property>
		<property name="defaultTargetDataSource" ref="nsDataSource">  
		</property> 
	</bean>

	<!-- 数据库拦截器  -->	
	<bean id="dataSourceInterceptor" class="com.test.base.dynamicdb.DataSourceInterceptor" />
	
	<aop:config>
		<aop:aspect id="dataSourceAspect" ref="dataSourceInterceptor">
			<aop:pointcut id="nsDataSourceAop"     expression="execution(* com.test.dao.nsdao..*.*(..))" />
			<aop:pointcut id="collateDataSourceAop" expression="execution(* com.test.dao.collatedao..*.*(..))" />
			<aop:pointcut id="naDataSourceAop"     expression="execution(* com.test.dao.nadao..*.*(..))" />
			<aop:pointcut id="ntDataSourceAop"     expression="execution(* com.test.dao.ntdao..*.*(..))" />
			
			<aop:around method="nsDataSource"  pointcut-ref="nsDataSourceAop"/>
			<aop:around method="collateDataSource"  pointcut-ref="collateDataSourceAop"/>
			<aop:around method="naDataSource"  pointcut-ref="naDataSourceAop"/>
			<aop:around method="ntDataSource"  pointcut-ref="ntDataSourceAop"/>
			
			<aop:after-returning method="clearDBType" pointcut-ref="nsDataSourceAop"/>
			<aop:after-returning method="clearDBType" pointcut-ref="collateDataSourceAop"/>
			<aop:after-returning method="clearDBType" pointcut-ref="naDataSourceAop"/>
			<aop:after-returning method="clearDBType" pointcut-ref="ntDataSourceAop"/>
		</aop:aspect>
	</aop:config>
	
	<!-- 注解方式配置 -->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">  
		<property name="dataSource">
			<ref bean="dynamicDataSource" />
		</property>
		<property name="namingStrategy">
			<bean class="org.hibernate.cfg.ImprovedNamingStrategy" />
		</property>
		<property name="hibernateProperties">
			<props> 
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.showSql}</prop>
				<prop key="hibernate.format_sql">true</prop>
				<prop key="hibernate.generateDdl">${hibernate.generateDdl}</prop>
				<prop key="hibernate.cache.use_second_level_cache">true</prop>
				<prop key="hibernate.cache.use_query_cache">true</prop>
				<prop key="hibernate.autoReconnect">true</prop>  
				<prop key="hibernate.cache.region.factory_class">net.sf.ehcache.hibernate.EhCacheRegionFactory</prop>
				<prop key="hibernate.query.substitutions">true 1, false 0</prop>
				<prop key="hibernate.query.factory_class">org.hibernate.hql.classic.ClassicQueryTranslatorFactory</prop>
			</props>
		</property>
		<!-- 自动扫描指定位置下的实体文件进行映射 -->  
		<property name="packagesToScan">
			<list>
				<value>com.test</value>
				<!-- <value>com.test.model</value> -->
				<!-- <value>com.test.verification.model</value> -->
			</list>
		</property>    
	</bean>

	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
		<property name="dataSource">
        	<ref bean="dynamicDataSource" />
   		 </property>
	</bean>
	
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" p:dataSource-ref="dynamicDataSource" />
	
	<bean id="namedParameterJdbcTemplate"  class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<constructor-arg ref="dynamicDataSource"/>  
	</bean>
	
	<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />
</beans>


Spring事务与JDK/CGLIB动态代理
liyifan687的博客
05-29 3894
近日面试问及AOP和动态代理，再之后的事务方面有所生疏，感谢面试官特意给我介绍了下，一个之前的知识盲区。 首先Spring事务在开发过程中是通过@Transactional注解来控制。 1. Transactional注解的原理 对于使用了Transactional注解的方法的类，Spring AOP代理会在运行时生成这个类的代理对象。 当这个对象运行这个注解方法时，会读取@Transa...
Java 动态代理原理图解 (附：2种实现方式详细对比)
mikechen的互联网架构
10-31 2342
​动态代理在 Java 中有着广泛的应用，例如：Spring AOP 面向切面编程，Hibernate 数据查询、以及 RPC Dubbo 远程调用等，都有非常多的实际应用。本文深入：Java 动态代理原理、JDK 原生动态代理、CGLib 动态代理实现、JDK 动态代理与 CGLib 的区别​。
使用DefaultAdvisorAutoProxyCreator实现spring的自动代理
08-12
NULL 博文链接：https://bijian1013.iteye.com/blog/2263303
jdbc代理模式和cglib代理模式优缺点比较
qq_30908729的博客
06-22 719
jdbc代理模式和cglib代理模式优缺点比较：http://www.yayihouse.com/yayishuwu/chapter/1303
SpringAOP之cglib与jdbc动态代理
weixin_43904583的博客
10-18 741
动态代理的目的 想要在方法执行之前、方法执行之后、方法抛出异常时，执行一些特殊操作以达到，增强方法的目的。 1.简单粗暴的方法 public void method(){ System.out.println(); //do somethiing System.out.println(); } 存在的问题： 代码耦合度过高 在某功能的代码中混合了大量不属于这个功能所必须的通知方法，代码的美观度不尽人意，耦合性还高 修改麻烦 如果想要修改相应通知方法，必须要一个一个去修改，类似的方法数量如果
如何实现手动指定AOP实现JDK代理模式到CGLIB的更改？
秃头的博客
09-23 336
在使用AOP进行切面编程的时候，我们底层会自动调用JDK动态代理的实现模式，根据接口进行编程，如果想要AOP底层调用CGLIB动态代理的模式，那么需要在核心配置文件xml中写下以下： <aop:scoped-proxy proxy-target-class="false"></aop:scoped-proxy> 这个标签可以把AOP的底层的动态代理改成CGLIB 还有就是，如果我们在之前实现切面编程的时候，指定的不是接口.calss，使用的是实现类，那么底层将会默认调用CGLIB
SpringBoot 的 AOP 中 JDK Proxy 和 CGLib
LIXI.FUN
08-24 497
【SpringBoot 的 AOP 中 JDK Proxy 和 CGLib】 以下内容搭配 SpringAopDebug 食用更佳 基础 Spring AOP 的底层就是通过使用 JDK 或者 CGLib 动态代理来实现为目标 Bean 织入横切逻辑的。 JDK 的动态代理，允许开发者在运行期创建接口的代理实例，限制也是只能为接口创建代理实例。 CGLib 采用字节码技术，可以为一个类创建子类，在子类中采用方法拦截所有父类的调用来织入横切逻辑。 Spring 默认为有接口实现类用 JDK 代理，无接口实现
JAVAWEB开发之Spring详解之——AOP底层剖析(基于JDK和cglib)、Spring中的AOP以及基于AspectJ的AOP实现、Spring的JDBCTemplate详解
04-27 1452
AOP概述  什么是AOP？ AOP—Aspect Oriented Programming 面向切面编程。AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码(性能监视、事务管理、安全检查、缓存)。Spring AOP使用后纯Java实现，不需要专门的编译工程和类加载器，在运行期间通过代理方式向目标类组织增强代码。AspectJ是一个基于Java语言的AOP框架，Spring2.
动态代理和注解Spring.rar
09-01
Spring支持两种类型的代理：JDK动态代理和CGLIB代理。JDK动态代理基于接口实现，适用于目标对象实现了至少一个接口的情况；而CGLIB代理则是在运行时动态生成子类来实现，适用于目标对象没有接口或者接口不完全满足...
Spring Boot集成Mybatis Plus实现动态多数据源切换
5. **动态数据源上下文：**使用ThreadLocal来隔离不同线程的数据源环境，实现线程级别的数据源切换。这样每个线程操作的数据库可以是独立的，保证了线程安全。 6. **AOP技术：**AOP（面向切面编程）是Spring框架的...
Spring-boot+mybatis多数据源整合（动态切换数据源）
08-12
Spring-boot+mybatis多数据源整合（动态切换数据源）,亲测可用
（Java基础篇）八、Java中的两种代理（JDK与CGLib）
weixin_43021647的博客
06-20 767
代理模式可以避免对象直接暴露，静态代理每次需要新的业务均需要预添加额外的代理类。动态代理则是在编译或运行生成的，大大降低了代理类与被代理类的耦合，提高扩展性和复用性。首先用一段代码先看看JDK动态代理的用法。
spring的动态代理模式有几种?默认是那种?如何切换?
热门推荐
秋语博客
11-20 2万+
spring的动态的代理模式有两种 JDK动态代理,基于接口(默认代理模式)，CGLIB动态代理（若要使用需要进行配置） JDK动态代理是由java JDK提供    其缺点是只能为接口创建代理，返回的代理对象也只能转到某个接口类型 CGLIB动态大力是由是由第三方库cglib提供， CGLIB的实现机制与JDK的实现机制不同，它是通过继承实现的，它也是动态的创建一个类，但这个类的父类是...
【Spring Boot实战与进阶】AOP的两种动态代理（JDK和Cglib）
程序员云帆哥的博客
10-07 3641
JDK和Cglib两种动态代理方式区别 1、java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。而Cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
Spring两种实现动态代理（JDK与CGLIB）的讲解与demo
qq_41625866的博客
10-17 1002
Spring两种实现动态代理的讲解与demo
Spring aop 通过获取代理对象实现事务切换
_William_Cheung的博客
08-11 5397
摘要：在项目中，涉及到同一个类中一个方法调用另外一个方法，并且两个方法的事务不相关， 这里面涉及到一个事务切换的问题，一般的方法没问题，根据通过aop注解在方法上通过加注解标识， 答案是：通过spring aop类里面的AopContext类获取当前类的代理对象， 这样就能切换对应的事务管理器了，具体做法如下： (1).在applicationContext.xml文件中配置如下：
Spring AOP中的JDK动态代理与CGLIB代理
大鹏
12-28 2738
1、在Spring中的应用 　　Spring在将Advice织入目标对象的Joinpoint是在运行时动态进行的。它采用的方式可能有两种，即JDK动态代理与CGLIB代理。Spring会根据具体的情况在两者之间切换。 　　实际情况如下： 　　Ø  如果目标对象实现了接口，那么Spring默认会采用JDK的动态代理实现AOP 　　Ø  如果目标对象实现了接口，也可以强制使用CGLIB生成代理
spring 动态代理_Spring中的两种动态代理
mywaya2333的博客
01-09 3871
两种动态代理1、java动态代理利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。2、cglib动态代理利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。 spring中的动态代理 spring会自动在JDK动态代理和CGLIB之间转换1、 默认使用Java动态代理 来创建AOP代理，这样就可以为任何接口实例创建代理了。2、当需要代理的类没有实现代理接口的时候，Spring会切换为使用CGLIB代理。3、可以通过配置 强制使
Spring AOP在动态数据源与缓存操作中的应用
- Spring AOP使用代理模式来实现AOP，主要有JDK动态代理和CGLIB代理两种方式。 2. Spring AOP的使用场景 - 日志记录：在方法执行前后记录日志信息，帮助开发者追踪程序执行情况。 - 事务管理：将事务控制逻辑从...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

燕郊炒家

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值