基於JDK動態代理和CGLIB動態代理的實現Spring註解管理事務(@Trasactional)到底有什麼區別。 – JAVA編程語言程序開發技術文章

一、基礎工作
首先修改我們上一次做的 SpringMVC + spring3.1.1 + hibernate4.1.0 https://www.aiwalls.com/kf/201203/122443.html 集成及常見問題總結,如下所示:
    將xml聲明式事務刪除

 

 

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代碼:
<tx:annotation-driven transaction-manager="txManager"/>
 

    在我們的BaseService接口上添加 @Transactional 使該方法開啟事務

 

 

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代碼:
log4j.logger.org.springframework=INFO,CONSOLE
 

在我們的resources.properties裡將hibernate.show_sql=true 改為true,為瞭看到hibernate的sql。

 

 

單元測試類:

 

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代碼:
<tx:annotation-driven transaction-manager="txManager"/>
   該配置方式默認就是JDK動態代理方式

 

運行單元測試,核心日志如下:                                    

 

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代碼:
<tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>
   該配置方式是基於CGLIB類代理

 

啟動測試會報錯,No Session found for current thread,說明事務沒有起作用

 

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代碼:
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代碼:
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代碼:
<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代碼:
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代碼:
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代碼:
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代碼:
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代碼:
package cn.javass.common.service;
public interface IBaseService<M extends java.io.Serializable, PK extends java.io.Serializable> {
    public int countAll();

 

在具體類中添加@Transactional

 

 

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代碼:
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建議放置到具體類上,不要放置到接口。

 

 摘自  hello spring
 
 

發佈留言