当前位置：首页 > news >正文

基于JDK动态代理和CGLIB动态代理的实现Spring注解管理事务（@Trasactional）到底有什么区别。...

news 来源：原创 2024/4/19 14:39:46

基于JDK动态代理和CGLIB动态代理的实现Spring注解管理事务（@Trasactional）到底有什么区别。

我还是喜欢基于Schema风格的Spring事务管理，但也有很多人在用基于@Trasactional注解的事务管理，但在通过基于JDK动态代理和CGLIB动态代理的实现Spring注解管理事务是有区别的，我们接下来看看到底有哪些区别。

一、基础工作

首先修改我们上一次做的 SpringMVC + spring3.1.1 + hibernate4.1.0 集成及常见问题总结，如下所示：

将xml声明式事务删除

java代码：

     Java代码   
     
    
 <aop:config expose-proxy="true">  
         <!-- 只对业务逻辑层实施事务 -->  
         <aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" />  
         <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>  
     </aop:config>  

并添加注解式事务支持：

java代码：

     Java代码   
     
 <tx:annotation-driven transaction-manager="txManager"/>

在我们的BaseService接口上添加 @Transactional 使该方法开启事务

java代码：

     Java代码   
     
    
 package cn.javass.common.service;  
 public interface IBaseService<M extends java.io.Serializable, PK extends java.io.Serializable> {  
 @Transactional   //开启默认事务  
     public int countAll();  
 }    

在我们的log4j.properties中添加如下配置，表示输出spring的所有debug信息

java代码：

     Java代码   
     
 log4j.logger.org.springframework=INFO,CONSOLE

在我们的resources.properties里将hibernate.show_sql=true 改为true，为了看到hibernate的sql。

单元测试类：

java代码：

     Java代码   
     
    
 package cn.javass.ssonline.spider.service.impl;  
   
 import org.junit.Test;  
 import org.junit.runner.RunWith;  
 import org.springframework.beans.factory.annotation.Autowired;  
 import org.springframework.test.context.ContextConfiguration;  
 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;  
 import org.springframework.test.context.transaction.TransactionConfiguration;  
   
 import cn.javass.demo.service.UserService;  
 @RunWith(SpringJUnit4ClassRunner.class)  
 @ContextConfiguration(locations = {"classpath:spring-config.xml"})  
 public class UserServiceTest2 {  
       
     @Autowired  
     private UserService userService;  
     @Test  
     public void testCreate() {  
        userService.countAll();  
     }  
 }  

基础工作做好，接下来我们详细看看 Spring基于 JDK动态代理和 CGLIB类级别代理到底有什么区别。

二、基于JDK动态代理：

java代码：

     Java代码   
     
 <tx:annotation-driven transaction-manager="txManager"/>

该配置方式默认就是JDK动态代理方式

运行单元测试，核心日志如下：

java代码：

     Java代码   
     
    
 2012-03-07 09:58:44 [main] DEBUG org.springframework.orm.hibernate4.HibernateTransactionManager - Creating new transaction with name [cn.javass.common.service.impl.BaseService.countAll]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''      //开启事务  
 2012-03-07 09:58:44 [main] DEBUG org.springframework.orm.hibernate4.HibernateTransactionManager - Opened new Session   
   
 2012-03-07 09:58:44 [main] DEBUG org.springframework.transaction.support.TransactionSynchronizationManager - Bound value [org.springframework.orm.hibernate4.SessionHolder@1184a4f] for key [org.hibernate.internal.SessionFactoryImpl@107b56e] to thread [main] //绑定session到ThreadLocal  
 2012-03-07 09:58:44 [main] DEBUG org.springframework.transaction.support.TransactionSynchronizationManager - Initializing transaction synchronization  
 2012-03-07 09:58:44 [main] DEBUG org.springframework.transaction.interceptor.TransactionInterceptor - Getting transaction for [cn.javass.common.service.impl.BaseService.countAll]  
 2012-03-07 09:58:44 [main] DEBUG org.springframework.transaction.support.TransactionSynchronizationManager - Retrieved value [org.springframework.orm.hibernate4.SessionHolder@1184a4f] for key [org.hibernate.internal.SessionFactoryImpl@107b56e] bound to thread [main]  
 2012-03-07 09:58:44 [main] DEBUG org.springframework.orm.hibernate4.HibernateTransactionManager - Found thread-bound Session   
   
 2012-03-07 09:58:44 [main] DEBUG org.springframework.transaction.support.TransactionSynchronizationManager - Retrieved value [org.springframework.orm.hibernate4.SessionHolder@1184a4f] for key [org.hibernate.internal.SessionFactoryImpl@107b56e] bound to thread [main]  
 Hibernate:   
     select  
         count(*) as col_0_0_   
     from  
         tbl_user usermodel0_  
   
 2012-03-07 09:58:44 [main] DEBUG org.springframework.orm.hibernate4.HibernateTransactionManager - Committing Hibernate transaction on Session    //提交事务  
   
 2012-03-07 09:58:44 [main] DEBUG org.springframework.transaction.support.TransactionSynchronizationManager - Removed value [org.springframework.orm.hibernate4.SessionHolder@1184a4f] for key [org.hibernate.internal.SessionFactoryImpl@107b56e] from thread [main] //解除绑定session到ThreadLocal  

到此我们可以看到事务起作用了，也就是说即使把@Transactional放到接口上基于JDK动态代理也是可以工作的。

三、基于CGLIB类代理：

java代码：

     Java代码   
     
 <tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>

该配置方式是基于CGLIB类代理

启动测试会报错，No Session found for current thread，说明事务没有起作用

java代码：

     Java代码   
     
    
 org.hibernate.HibernateException: No Session found for current thread  
     at org.springframework.orm.hibernate4.SpringSessionContext.currentSession(SpringSessionContext.java:97)  
     at org.hibernate.internal.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:1024)  
     at cn.javass.common.dao.hibernate4.BaseHibernateDao.getSession(BaseHibernateDao.java:63)  
     at cn.javass.common.dao.hibernate4.BaseHibernateDao.aggregate(BaseHibernateDao.java:238)  
     at cn.javass.common.dao.hibernate4.BaseHibernateDao.countAll(BaseHibernateDao.java:114)  
     at cn.javass.common.service.impl.BaseService.countAll(BaseService.java:60)  
     at cn.javass.common.service.impl.BaseService$$FastClassByCGLIB$$5b04dd69.invoke(<generated>)  
     at net.sf.cglib.proxy.MethodProxy.invoke(MethodProxy.java:149)  
     at org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.intercept(Cglib2AopProxy.java:618)  
     at cn.javass.demo.service.impl.UserServiceImpl$$EnhancerByCGLIB$$7d46c567.countAll(<generated>)  
     at cn.javass.ssonline.spider.service.impl.UserServiceTest2.testCreate(UserServiceTest2.java:20)  

如果将注解放在具体类上或具体类的实现方法上才会起作用。

java代码：

     Java代码   
     
    
 package cn.javass.common.service.impl;  
 public abstract class BaseService<M extends java.io.Serializable, PK extends java.io.Serializable> implements IBaseService<M, PK> {  
    
    @Transactional()   //放在抽象类上  
     @Override  
     public int countAll() {  
         return baseDao.countAll();  
     }  
 }  

运行测试类，将发现成功了，因为我们的UserService继承该方法，但如果UserService覆盖该方法，如下所示，也将无法织入事务(报错)：

java代码：

     Java代码   
     
    
 package cn.javass.demo.service.impl;  
 public class UserServiceImpl extends BaseService<UserModel, Integer> implements UserService {  
     //没有@Transactional  
     @Override   
     public int countAll() {  
         return baseDao.countAll();  
     }  
 }  

四、基于aspectj的

java代码：

     Java代码   
     
 <tx:annotation-driven transaction-manager="txManager" mode="aspectj" proxy-target-class="true"/>

在此就不演示了，我们主要分析基于JDK动态代理和CGLIB类代理两种的区别。

五、结论：

基于JDK动态代理，可以将@Transactional放置在接口和具体类上。

基于CGLIB类代理，只能将@Transactional放置在具体类上。

因此在实际开发时全部将@Transactional放到具体类上，而不是接口上。

六、分析

1、 JDK动态代理

1.1、Spring使用JdkDynamicAopProxy实现代理：

java代码：

     Java代码   
     
    
 package org.springframework.aop.framework;  
 final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {  
     //注意此处的method 一定是接口上的method（因此放置在接口上的@Transactional是可以发现的）  
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
     }  
 }  

注意此处的method 一定是接口上的method（因此放置在接口上的@Transactional是可以发现的）

1.2、如果<tx:annotation-driven 中 proxy-target-class="true" ，Spring将使用CGLIB动态代理，而内部通过Cglib2AopProxy实现代理，而内部通过DynamicAdvisedInterceptor进行拦截：

java代码：

     Java代码   
     
    
 package org.springframework.aop.framework;  
 final class Cglib2AopProxy implements AopProxy, Serializable {  
     private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {  
             //注意此处的method 一定是具体类上的method（因此只用放置在具体类上的@Transactional是可以发现的）  
         public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
             }  
        }  
 }  

1.3、Spring使用AnnotationTransactionAttributeSource通过查找一个类或方法是否有@Transactional注解事务来返回TransactionAttribute（表示开启事务）：

java代码：

     Java代码   
     
    
 package org.springframework.transaction.annotation;  
 public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource implements Serializable {  
          protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {  
         for (TransactionAnnotationParser annotationParser : this.annotationParsers) {  
             TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);  
             if (attr != null) {  
                 return attr;  
             }  
         }  
         return null;  
     }  
 }  

而AnnotationTransactionAttributeSource又使用SpringTransactionAnnotationParser来解析是否有@Transactional注解：

java代码：

     Java代码   
     
    
 package org.springframework.transaction.annotation;  
   
 public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {  
   
     public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {  
         Transactional ann = AnnotationUtils.getAnnotation(ae, Transactional.class);  
         if (ann != null) {  
             return parseTransactionAnnotation(ann);  
         }  
         else {  
             return null;  
         }  
     }  
   
     public TransactionAttribute parseTransactionAnnotation(Transactional ann) {  
           
     }  
   
 }  

此处使用AnnotationUtils.getAnnotation(ae, Transactional.class)；这个方法只能发现当前方法/类上的注解，不能发现父类的注解。 Spring还提供了一个 AnnotationUtils.findAnnotation()方法可以发现父类/父接口中的注解（但spring没有使用该接口）。

如果Spring此处换成AnnotationUtils.findAnnotation()，将可以发现父类/父接口中的注解。

这里还一个问题，描述如下：

在接口中删除@Transactional //开启默认事务

java代码：

     Java代码   
     
    
 package cn.javass.common.service;  
 public interface IBaseService<M extends java.io.Serializable, PK extends java.io.Serializable> {  
     public int countAll();  
 }    

在具体类中添加@Transactional

java代码：

     Java代码   
     
    
 package cn.javass.common.service.impl;  
 public abstract class BaseService<M extends java.io.Serializable, PK extends java.io.Serializable> implements IBaseService<M, PK> {  
   
     @Transactional()   //开启默认事务  
     @Override  
     public int countAll() {  
         return baseDao.countAll();  
     }  
 }  

问题：

我们之前说过，基于JDK动态代理时， method 一定是接口上的method（因此放置在接口上的@Transactional是可以发现的），但现在我们放在具体类上，那么Spring是如何发现的呢？？

还记得发现TransactionAttribute是通过AnnotationTransactionAttributeSource吗？具体看步骤1.3：

而AnnotationTransactionAttributeSource 继承AbstractFallbackTransactionAttributeSource

java代码：

     Java代码   
     
    
 package org.springframework.transaction.interceptor;  
 public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {  
   
     public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {  
         //第一次 会委托给computeTransactionAttribute  
 }  
   
     //计算TransactionAttribute的  
     private TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {  
           
         //省略  
   
         // Ignore CGLIB subclasses - introspect the actual user class.  
         Class<?> userClass = ClassUtils.getUserClass(targetClass);  
         // The method may be on an interface, but we need attributes from the target class.  
         // If the target class is null, the method will be unchanged.  
         //①此处将查找当前类覆盖的方法  
         Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);  
         // If we are dealing with method with generic parameters, find the original method.  
         specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);  
   
         // First try is the method in the target class.  
         TransactionAttribute txAtt = findTransactionAttribute(specificMethod);  
         if (txAtt != null) {  
             return txAtt;  
         }  
   
         //找类上边的注解  
         // Second try is the transaction attribute on the target class.  
         txAtt = findTransactionAttribute(specificMethod.getDeclaringClass());  
         if (txAtt != null) {  
             return txAtt;  
         }  
         //②如果子类覆盖的方法没有 再直接找当前传过来的  
         if (specificMethod != method) {  
             // Fallback is to look at the original method.  
             txAtt = findTransactionAttribute(method);  
             if (txAtt != null) {  
                 return txAtt;  
             }  
             // Last fallback is the class of the original method.  
             return findTransactionAttribute(method.getDeclaringClass());  
         }  
         return null;  
     }  
 }  

//①此处将查找子类覆盖的方法

Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);

// ClassUtils.getMostSpecificMethod

public static Method getMostSpecificMethod(Method method, Class<?> targetClass) {

Method specificMethod = null;

if (method != null && isOverridable(method, targetClass) &&

targetClass != null && !targetClass.equals(method.getDeclaringClass())) {

try {

specificMethod = ReflectionUtils.findMethod(targetClass, method.getName(), method.getParameterTypes());

} catch (AccessControlException ex) {

// security settings are disallowing reflective access; leave

// 'specificMethod' null and fall back to 'method' below

}

return (specificMethod != null ? specificMethod : method);

}

可以看出将找到当前类的那个方法。因此我们放置在BaseService countAll方法上的@Transactional起作用了。

//②如果子类覆盖的方法没有再直接找当前传过来的

if (specificMethod != method) {

// Fallback is to look at the original method.

txAtt = findTransactionAttribute(method);

if (txAtt != null) {

return txAtt;

}

// Last fallback is the class of the original method.

return findTransactionAttribute(method.getDeclaringClass());

}

查找子类失败时直接使用传过来的方法。

因此，建议大家使用基于Schema风格的事务（不用考虑这么多问题，也不用考虑是类还是方法）。而@Transactional建议放置到具体类上，不要放置到接口。