Spring 源码阅读 74：BeanFactoryTransactionAttributeSourceAdvisor 分析

// org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor@Bean(name=TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
publicBeanFactoryTransactionAttributeSourceAdvisortransactionAdvisor(
TransactionAttributeSourcetransactionAttributeSource, TransactionInterceptortransactionInterceptor) {
BeanFactoryTransactionAttributeSourceAdvisoradvisor=newBeanFactoryTransactionAttributeSourceAdvisor();
advisor.setTransactionAttributeSource(transactionAttributeSource);
advisor.setAdvice(transactionInterceptor);
if (this.enableTx!=null) {
advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
   }
returnadvisor;
}

// org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration#transactionAttributeSource@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
publicTransactionAttributeSourcetransactionAttributeSource() {
returnnewAnnotationTransactionAttributeSource();
}

publicAnnotationTransactionAttributeSource() {
this(true);
}

publicAnnotationTransactionAttributeSource(booleanpublicMethodsOnly) {
this.publicMethodsOnly=publicMethodsOnly;
if (jta12Present||ejb3Present) {
this.annotationParsers=newLinkedHashSet<>(4);
this.annotationParsers.add(newSpringTransactionAnnotationParser());
if (jta12Present) {
this.annotationParsers.add(newJtaTransactionAnnotationParser());
      }
if (ejb3Present) {
this.annotationParsers.add(newEjb3TransactionAnnotationParser());
      }
   }
else {
this.annotationParsers=Collections.singleton(newSpringTransactionAnnotationParser());
   }
}

// org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration#transactionInterceptor@Bean@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
publicTransactionInterceptortransactionInterceptor(TransactionAttributeSourcetransactionAttributeSource) {
TransactionInterceptorinterceptor=newTransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource);
if (this.txManager!=null) {
interceptor.setTransactionManager(this.txManager);
   }
returninterceptor;
}

@Autowired(required=false)
voidsetConfigurers(Collection<TransactionManagementConfigurer>configurers) {
if (CollectionUtils.isEmpty(configurers)) {
return;
   }
if (configurers.size() >1) {
thrownewIllegalStateException("Only one TransactionManagementConfigurer may exist");
   }
TransactionManagementConfigurerconfigurer=configurers.iterator().next();
this.txManager=configurer.annotationDrivenTransactionManager();
}

publicinterfaceTransactionManagementConfigurer {
TransactionManagerannotationDrivenTransactionManager();
}

// org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor#pointcutprivatefinalTransactionAttributeSourcePointcutpointcut=newTransactionAttributeSourcePointcut() {
@Override@NullableprotectedTransactionAttributeSourcegetTransactionAttributeSource() {
returntransactionAttributeSource;
   }
};

// org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut#TransactionAttributeSourcePointcutprotectedTransactionAttributeSourcePointcut() {
setClassFilter(newTransactionAttributeSourceClassFilter());
}

privateclassTransactionAttributeSourceClassFilterimplementsClassFilter {
@Overridepublicbooleanmatches(Class<?>clazz) {
if (TransactionalProxy.class.isAssignableFrom(clazz) ||PlatformTransactionManager.class.isAssignableFrom(clazz) ||PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
returnfalse;
      }
TransactionAttributeSourcetas=getTransactionAttributeSource();
return (tas==null||tas.isCandidateClass(clazz));
   }
}

@OverridepublicClassFiltergetClassFilter() {
returnthis.classFilter;
}
@OverridepublicfinalMethodMatchergetMethodMatcher() {
returnthis;
}

// org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut.TransactionAttributeSourceClassFilter#matches@Overridepublicbooleanmatches(Class<?>clazz) {
if (TransactionalProxy.class.isAssignableFrom(clazz) ||PlatformTransactionManager.class.isAssignableFrom(clazz) ||PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
returnfalse;
   }
TransactionAttributeSourcetas=getTransactionAttributeSource();
return (tas==null||tas.isCandidateClass(clazz));
}

// org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#isCandidateClass@OverridepublicbooleanisCandidateClass(Class<?>targetClass) {
for (TransactionAnnotationParserparser : this.annotationParsers) {
if (parser.isCandidateClass(targetClass)) {
returntrue;
      }
   }
returnfalse;
}

// org.springframework.transaction.annotation.SpringTransactionAnnotationParser#isCandidateClass@OverridepublicbooleanisCandidateClass(Class<?>targetClass) {
returnAnnotationUtils.isCandidateClass(targetClass, Transactional.class);
}

// org.springframework.core.annotation.AnnotationUtils#isCandidateClass(java.lang.Class<?>, java.lang.Class<? extends java.lang.annotation.Annotation>)publicstaticbooleanisCandidateClass(Class<?>clazz, Class<?extendsAnnotation>annotationType) {
returnisCandidateClass(clazz, annotationType.getName());
}
// org.springframework.core.annotation.AnnotationUtils#isCandidateClass(java.lang.Class<?>, java.lang.String)publicstaticbooleanisCandidateClass(Class<?>clazz, StringannotationName) {
if (annotationName.startsWith("java.")) {
returntrue;
   }
if (AnnotationsScanner.hasPlainJavaAnnotationsOnly(clazz)) {
returnfalse;
   }
returntrue;
}

// org.springframework.core.annotation.AnnotationsScanner#hasPlainJavaAnnotationsOnly(java.lang.Class<?>)staticbooleanhasPlainJavaAnnotationsOnly(Class<?>type) {
return (type.getName().startsWith("java.") ||type==Ordered.class);
}

@Overridepublicbooleanmatches(Methodmethod, Class<?>targetClass) {
TransactionAttributeSourcetas=getTransactionAttributeSource();
return (tas==null||tas.getTransactionAttribute(method, targetClass) !=null);
}

// org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#getTransactionAttribute@Override@NullablepublicTransactionAttributegetTransactionAttribute(Methodmethod, @NullableClass<?>targetClass) {
if (method.getDeclaringClass() ==Object.class) {
returnnull;
   }
// First, see if we have a cached value.ObjectcacheKey=getCacheKey(method, targetClass);
TransactionAttributecached=this.attributeCache.get(cacheKey);
if (cached!=null) {
// Value will either be canonical value indicating there is no transaction attribute,// or an actual transaction attribute.if (cached==NULL_TRANSACTION_ATTRIBUTE) {
returnnull;
      }
else {
returncached;
      }
   }
else {
// We need to work it out.TransactionAttributetxAttr=computeTransactionAttribute(method, targetClass);
// Put it in the cache.if (txAttr==null) {
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
      }
else {
StringmethodIdentification=ClassUtils.getQualifiedMethodName(method, targetClass);
if (txAttrinstanceofDefaultTransactionAttribute) {
            ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
         }
if (logger.isTraceEnabled()) {
logger.trace("Adding transactional method '"+methodIdentification+"' with attribute: "+txAttr);
         }
this.attributeCache.put(cacheKey, txAttr);
      }
returntxAttr;
   }
}

// org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource#computeTransactionAttribute@NullableprotectedTransactionAttributecomputeTransactionAttribute(Methodmethod, @NullableClass<?>targetClass) {
// Don't allow no-public methods as required.if (allowPublicMethodsOnly() &&!Modifier.isPublic(method.getModifiers())) {
returnnull;
   }
// 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.MethodspecificMethod=AopUtils.getMostSpecificMethod(method, targetClass);
// First try is the method in the target class.TransactionAttributetxAttr=findTransactionAttribute(specificMethod);
if (txAttr!=null) {
returntxAttr;
   }
// Second try is the transaction attribute on the target class.txAttr=findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAttr!=null&&ClassUtils.isUserLevelMethod(method)) {
returntxAttr;
   }
if (specificMethod!=method) {
// Fallback is to look at the original method.txAttr=findTransactionAttribute(method);
if (txAttr!=null) {
returntxAttr;
      }
// Last fallback is the class of the original method.txAttr=findTransactionAttribute(method.getDeclaringClass());
if (txAttr!=null&&ClassUtils.isUserLevelMethod(method)) {
returntxAttr;
      }
   }
returnnull;
}

// org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#findTransactionAttribute(java.lang.Class<?>)@Override@NullableprotectedTransactionAttributefindTransactionAttribute(Class<?>clazz) {
returndetermineTransactionAttribute(clazz);
}
// org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#findTransactionAttribute(java.lang.reflect.Method)@Override@NullableprotectedTransactionAttributefindTransactionAttribute(Methodmethod) {
returndetermineTransactionAttribute(method);
}

// org.springframework.transaction.annotation.AnnotationTransactionAttributeSource#determineTransactionAttribute@NullableprotectedTransactionAttributedetermineTransactionAttribute(AnnotatedElementelement) {
for (TransactionAnnotationParserparser : this.annotationParsers) {
TransactionAttributeattr=parser.parseTransactionAnnotation(element);
if (attr!=null) {
returnattr;
      }
   }
returnnull;
}

// org.springframework.transaction.annotation.SpringTransactionAnnotationParser#parseTransactionAnnotation(java.lang.reflect.AnnotatedElement)@Override@NullablepublicTransactionAttributeparseTransactionAnnotation(AnnotatedElementelement) {
AnnotationAttributesattributes=AnnotatedElementUtils.findMergedAnnotationAttributes(
element, Transactional.class, false, false);
if (attributes!=null) {
returnparseTransactionAnnotation(attributes);
   }
else {
returnnull;
   }
}

// org.springframework.transaction.interceptor.TransactionInterceptor#invoke@Override@NullablepublicObjectinvoke(MethodInvocationinvocation) throwsThrowable {
// 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...returninvokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

// org.springframework.transaction.interceptor.TransactionAspectSupport.InvocationCallback@FunctionalInterfaceprotectedinterfaceInvocationCallback {
ObjectproceedWithInvocation() throwsThrowable;
}

// org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction// If the transaction attribute is null, the method is non-transactional.TransactionAttributeSourcetas=getTransactionAttributeSource();
finalTransactionAttributetxAttr= (tas!=null?tas.getTransactionAttribute(method, targetClass) : null);
finalTransactionManagertm=determineTransactionManager(txAttr);
// 省略部分代码PlatformTransactionManagerptm=asPlatformTransactionManager(tm);
finalStringjoinpointIdentification=methodIdentification(method, targetClass, txAttr);
if (txAttr==null||!(ptminstanceofCallbackPreferringPlatformTransactionManager)) {
// Standard transaction demarcation with getTransaction and commit/rollback calls.TransactionInfotxInfo=createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
ObjectretVal;
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 (Throwableex) {
// target invocation exceptioncompleteTransactionAfterThrowing(txInfo, ex);
throwex;
   }
finally {
cleanupTransactionInfo(txInfo);
   }
if (vavrPresent&&VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...TransactionStatusstatus=txInfo.getTransactionStatus();
if (status!=null&&txAttr!=null) {
retVal=VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
      }
   }
commitTransactionAfterReturning(txInfo);
returnretVal;
}
// 省略部分代码

// org.springframework.transaction.interceptor.TransactionAspectSupport#createTransactionIfNecessary@SuppressWarnings("serial")
protectedTransactionInfocreateTransactionIfNecessary(@NullablePlatformTransactionManagertm,
@NullableTransactionAttributetxAttr, finalStringjoinpointIdentification) {
// If no name specified, apply method identification as transaction name.if (txAttr!=null&&txAttr.getName() ==null) {
txAttr=newDelegatingTransactionAttribute(txAttr) {
@OverridepublicStringgetName() {
returnjoinpointIdentification;
         }
      };
   }
TransactionStatusstatus=null;
if (txAttr!=null) {
if (tm!=null) {
status=tm.getTransaction(txAttr);
      }
else {
if (logger.isDebugEnabled()) {
logger.debug("Skipping transactional joinpoint ["+joinpointIdentification+"] because no transaction manager has been configured");
         }
      }
   }
returnprepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}

status=tm.getTransaction(txAttr);

// org.springframework.transaction.interceptor.TransactionAspectSupport#completeTransactionAfterThrowingprotectedvoidcompleteTransactionAfterThrowing(@NullableTransactionInfotxInfo, Throwableex) {
if (txInfo!=null&&txInfo.getTransactionStatus() !=null) {
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for ["+txInfo.getJoinpointIdentification() +"] after exception: "+ex);
      }
if (txInfo.transactionAttribute!=null&&txInfo.transactionAttribute.rollbackOn(ex)) {
try {
txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
         }
catch (TransactionSystemExceptionex2) {
logger.error("Application exception overridden by rollback exception", ex);
ex2.initApplicationException(ex);
throwex2;
         }
catch (RuntimeException|Errorex2) {
logger.error("Application exception overridden by rollback exception", ex);
throwex2;
         }
      }
else {
// We don't roll back on this exception.// Will still roll back if TransactionStatus.isRollbackOnly() is true.try {
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
         }
catch (TransactionSystemExceptionex2) {
logger.error("Application exception overridden by commit exception", ex);
ex2.initApplicationException(ex);
throwex2;
         }
catch (RuntimeException|Errorex2) {
logger.error("Application exception overridden by commit exception", ex);
throwex2;
         }
      }
   }
}

// org.springframework.transaction.interceptor.TransactionAspectSupport#cleanupTransactionInfoprotectedvoidcleanupTransactionInfo(@NullableTransactionInfotxInfo) {
if (txInfo!=null) {
txInfo.restoreThreadLocalStatus();
   }
}

// org.springframework.transaction.interceptor.TransactionAspectSupport#commitTransactionAfterReturningprotectedvoidcommitTransactionAfterReturning(@NullableTransactionInfotxInfo) {
if (txInfo!=null&&txInfo.getTransactionStatus() !=null) {
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for ["+txInfo.getJoinpointIdentification() +"]");
      }
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
   }
}