@Transactional注解簡介
@Transactional是spring中宣告式事務管理的注解配置方式，相信這個注解的作用大家都很清楚，@Transactional注解可以幫助我們把事務開啟、提交或者回滾的操作，通過aop的方式進行管理，
通過@Transactional注解就能讓spring為我們管理事務，免去了重復的事務管理邏輯，減少對業務代碼的侵入，使我們開發人員能夠專注于業務層面開發，
我們知道實作@Transactional原理是基于spring aop，aop又是動態代理模式的實作，通過對原始碼的閱讀，總結出下面的步驟來了解實際中，在spring 是如何利用aop來實作@Transactional的功能的，
spring中宣告式事務實作原理猜想
首先，對于spring中aop實作原理有了解的話，應該知道想要對一個方法進行代理的話，肯定需要定義切點，在@Transactional的實作中，同樣如此，spring為我們定義了以 @Transactional 注解為植入點的切點，這樣才能知道@Transactional注解標注的方法需要被代理，
有了切面定義之后，在spring的bean的初始化程序中，就需要對實體化的bean進行代理，并且生成代理物件，
生成代理物件的代理邏輯中，進行方法呼叫時，需要先獲取切面邏輯，@Transactional注解的切面邏輯類似于@Around，在spring中是實作一種類似代理邏輯，
@Transactional作用
根據上面的原理猜想，下面簡單介紹每個步驟的原始碼以進行驗證，
首先是@Transactional，作用是定義代理植入點，我們知道代理物件創建的通過BeanPostProcessor的實作類AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInstantiation方法來實作個，如果需要進行代理，那么在這個方法就會回傳一個代理物件給容器，同時判斷植入點也是在這個方法中，
那么下面開始分析，在配置好注解驅動方式的事務管理之后，spring會在ioc容器創建一個BeanFactoryTransactionAttributeSourceAdvisor實體，這個實體可以看作是一個切點，在判斷一個bean在初始化程序中是否需要創建代理物件，都需要驗證一次BeanFactoryTransactionAttributeSourceAdvisor是否是適用這個bean的切點，如果是，就需要創建代理物件，并且把BeanFactoryTransactionAttributeSourceAdvisor實體注入到代理物件中，
前文我們知道在AopUtils#findAdvisorsThatCanApply中判斷切面是否適用當前bean，可以在這個地方斷點分析呼叫堆疊，AopUtils#findAdvisorsThatCanApply一致呼叫，最終通過以下代碼判斷是否適用切點，
AbstractFallbackTransactionAttributeSource#computeTransactionAttribute(Method method, Class<?> targetClass)這里可以根據引數打上條件斷點進行除錯分析呼叫堆疊，targetClass就是目標class …一系列呼叫- 最終
SpringTransactionAnnotationParser#parseTransactionAnnotation(java.lang.reflect.AnnotatedElement)
@Override
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
//這里就是分析Method是否被@Transactional注解標注，有的話，不用說BeanFactoryTransactionAttributeSourceAdvisor適配當前bean，進行代理，并且注入切點
//BeanFactoryTransactionAttributeSourceAdvisor
AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
if (attributes != null) {
return parseTransactionAnnotation(attributes);
}
else {
return null;
}
}
上面就是判斷是否需要根據@Transactional進行代理物件創建的判斷程序，@Transactional的作用一個就是標識方法需要被代理，一個就是攜帶事務管理需要的一些屬性資訊，
推薦一個 Spring Boot 基礎教程及實戰示例：
https://github.com/javastacks/spring-boot-best-practice
動態代理邏輯實作
【aop實作原理分析】中知道，aop最終的代理物件的代理方法是
DynamicAdvisedInterceptor#intercept
所以我們可以在這個方法斷點分析代理邏輯，
@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
Object oldProxy = null;
boolean setProxyContext = false;
Class<?> targetClass = null;
Object target = null;
try {
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we
// "own" the target, in case it comes from a pool...
target = getTarget();
if (target != null) {
targetClass = target.getClass();
}
//follow
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
Object retVal;
// Check whether we only have one InvokerInterceptor: that is,
// no real advice, but just reflective invocation of the target.
if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
// We can skip creating a MethodInvocation: just invoke the target directly.
// Note that the final invoker must be an InvokerInterceptor, so we know
// it does nothing but a reflective operation on the target, and no hot
// swapping or fancy proxying.
Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
retVal = methodProxy.invoke(target, argsToUse);
}
else {
// We need to create a method invocation...
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
}
retVal = processReturnType(proxy, target, method, retVal);
return retVal;
}
finally {
if (target != null) {
releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
通過分析 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)回傳的是TransactionInterceptor,利用TransactionInterceptor是如何實作代理邏輯呼叫的？
跟蹤new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
發現最終是呼叫TransactionInterceptor#invoke方法，并且把CglibMethodInvocation注入到invoke方法中，從上面可以看到CglibMethodInvocation是包裝了目標物件的方法呼叫的所有必須資訊，因此，在TransactionInterceptor#invoke里面也是可以呼叫目標方法的，并且還可以實作類似@Around的邏輯，在目標方法呼叫前后繼續注入一些其他邏輯，比如事務管理邏輯，
TransactionInterceptor–最終事務管理者
下面看代碼，
TransactionInterceptor#invoke
@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
// Work out the target class: may be {@code null}.
// The TransactionAttributeSource should be passed the target class
// as well as the method, which may be from an interface.
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// Adapt to TransactionAspectSupport's invokeWithinTransaction...
return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
@Override
public Object proceedWithInvocation() throws Throwable {
return invocation.proceed();
}
});
}
繼續跟蹤invokeWithinTransaction，下面的代碼中其實就可以看出一些邏輯端倪，就是我們猜想的實作方式，事務管理，
protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
throws Throwable {
// If the transaction attribute is null, the method is non-transactional.
final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
final PlatformTransactionManager tm = determineTransactionManager(txAttr);
final String joinpointIdentification = methodIdentification(method, targetClass);
if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
// Standard transaction demarcation with getTransaction and commit/rollback calls.
//開啟事務
TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
Object retVal = null;
try {
// This is an around advice: Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
//方法呼叫
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// target invocation exception
//回滾事務
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
//提交事務
commitTransactionAfterReturning(txInfo);
return retVal;
}
else {
// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
try {
Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
new TransactionCallback<Object>() {
@Override
public Object doInTransaction(TransactionStatus status) {
TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
try {
return invocation.proceedWithInvocation();
}
catch (Throwable ex) {
if (txAttr.rollbackOn(ex)) {
// A RuntimeException: will lead to a rollback.
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
}
else {
throw new ThrowableHolderException(ex);
}
}
else {
// A normal return value: will lead to a commit.
return new ThrowableHolder(ex);
}
}
finally {
cleanupTransactionInfo(txInfo);
}
}
});
// Check result: It might indicate a Throwable to rethrow.
if (result instanceof ThrowableHolder) {
throw ((ThrowableHolder) result).getThrowable();
}
else {
return result;
}
}
catch (ThrowableHolderException ex) {
throw ex.getCause();
}
}
}
總結
最終可以總結一下整個流程，跟開始的猜想對照，
分析原始碼后對照
原文鏈接：https://blog.csdn.net/qq_20597727/article/details/84868035
著作權宣告：本文為CSDN博主「一擼向北」的原創文章，遵循CC 4.0 BY-SA著作權協議，轉載請附上原文出處鏈接及本宣告，
近期熱文推薦：
1.1,000+ 道 Java面試題及答案整理(2021最新版)
2.別在再滿屏的 if/ else 了，試試策略模式，真香！！
3.臥槽！Java 中的 xx ≠ null 是什么新語法？
4.Spring Boot 2.5 重磅發布，黑暗模式太炸了！
5.《Java開發手冊（嵩山版）》最新發布，速速下載！
覺得不錯，別忘了隨手點贊+轉發哦！
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/325226.html
標籤：Java