一、Spring @Transactional 声明式事务执行原理
@Transactional 是 Spring 框架中用于声明事务的注解，可以标注在方法或类上。当标注在类上时，表示该类的所有public方法都将支持事务。当标注在方法上时，表示该方法将在一个事务内执行。
@Transactional 的执行原理依赖于 AOP ，因此在看本篇文章时，最好对 AOP 的原理有所了解，如果不了解，可以看下下面两篇文章：
SpringAop 源码解析 (一) - Aspect 切面方法的查找匹配过程
SpringAop 源码解析 (二) - 代理对象的创建以及执行过程
下面一起开始源码的分析。
二、@EnableTransactionManagement
在普通的 Spring 项目中，开启声明式事务的支持需要使用 @EnableTransactionManagement 注解，该注解在 SpringBoot 中会自动调用，可以从该注解入手，看到底做了啥事情：
注意注解中代理模式默认为 PROXY ，同时还使用 @Import 引入了 TransactionManagementConfigurationSelector 类，看下该类的继承关系：
有实现 ImportSelector 选择注入器，因此先找到 selectImports(AnnotationMetadata importingClassMetadata) 方法，在 AdviceModeImportSelector 类下：
这里又使用了子类的selectImports方法的结果注入了 Spring 容器，就是TransactionManagementConfigurationSelector 类下的 selectImports 方法：
从上面注解中可以得到默认为 PROXY 模式，因此会注入AutoProxyRegistrar 和 ProxyTransactionManagementConfiguration 这里主要分析下 ProxyTransactionManagementConfiguration 配置类：
@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
// 事务代理配置
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
// 事务切面
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
// 创建事务切面增强器
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
// 设置事务属性解析器
advisor.setTransactionAttributeSource(transactionAttributeSource);
// 设置
advisor.setAdvice(transactionInterceptor);
if (this.enableTx != null) {
advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
}
return advisor;
}
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
// 事务属性解析器
public TransactionAttributeSource transactionAttributeSource() {
// 创建一个注解事务属性解析器
return new AnnotationTransactionAttributeSource();
}
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
// 事务拦截器
public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
// 创建事务拦截器
TransactionInterceptor interceptor = new TransactionInterceptor();
// 设置事务属性拦截器
interceptor.setTransactionAttributeSource(transactionAttributeSource);
if (this.txManager != null) {
// 设置事务管理器
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}
}
该配置类中声明了三个非常重要的对象：
BeanFactoryTransactionAttributeSourceAdvisor ：是Advisor 的子类，该类也是源码分析的关键点，由于其属于 Advisor 的子类，因此在 AOP 扫描 Advisor 增强器时会被扫描到，执行后续 AOP 的逻辑。
注意该类在Spring 中注册的名称为：org.springframework.transaction.config.internalTransactionAdvisor
TransactionAttributeSource ：事务属性解析器，这里实例为 AnnotationTransactionAttributeSource ，主要在 AOP 中匹配Advisor 增强器时用到，一方面判断是否带有 @Transactional 注解，另一方面对注解中的参数进行解析包装。
TransactionInterceptor： 事务拦截器，是 MethodInterceptor 的子类，因此在AOP中也是最终触发执行逻辑的类，其中包含了事务的开启、提交、回滚等。
三、事务切面增强器的扫描过程
下面我们从 AOP 的执行逻辑中 AbstractAdvisorAutoProxyCreator 类下的 getAdvicesAndAdvisorsForBean 方法进行分析，主要实现了Advices 切面增强方法的扫描和匹配过程。
这里的处理过程在上篇 AOP 的文章中有分析过，因此这里主要对BeanFactoryTransactionAttributeSourceAdvisor 的扫描和匹配过程进行分析，如果对这块不了解的话，建议看下前面的 AOP 分析的文章：
下面看到该方法中：
protected Object[] getAdvicesAndAdvisorsForBean(
Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
//获取增强方法
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
//判断是否为空
if (advisors.isEmpty()) {
//如果为空，返回一个空数组
return DO_NOT_PROXY;
}
//如果不为空，转化为数组然后返回
return advisors.toArray();
}
使用 findEligibleAdvisors 方法获取到匹配的增强方法，也就是切面方法，看到该方法中：
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
//获取所有的增强方法
List<Advisor> candidateAdvisors = findCandidateAdvisors();
//从所有的增强方法中匹配适合该 bean 的增强方法
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
//对匹配后的增强方法进行扩展
extendAdvisors(eligibleAdvisors);
//判断是否为空
if (!eligibleAdvisors.isEmpty()) {
//如果不为空，进行排序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
//返回处理后的增强方法
return eligibleAdvisors;
}
这里通过 findCandidateAdvisors 方法获取到所有的切面方法，然后使用 findAdvisorsThatCanApply 方法匹配出符合该 beanName 的切面方法，首先看到 findCandidateAdvisors 方法，在 AbstractAdvisorAutoProxyCreator 类下：
这里又调用了 BeanFactoryAdvisorRetrievalHelper 类下的 findAdvisorBeans 方法：
public List<Advisor> findAdvisorBeans() {
// Determine list of advisor bean names, if not cached already.
String[] advisorNames = this.cachedAdvisorBeanNames;
if (advisorNames == null) {
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the auto-proxy creator apply to them!
// 获取工厂中所有的 Advisor
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
if (advisorNames.length == 0) {
return new ArrayList<>();
}
List<Advisor> advisors = new ArrayList<>();
for (String name : advisorNames) {
if (isEligibleBean(name)) {
if (this.beanFactory.isCurrentlyInCreation(name)) {
if (logger.isTraceEnabled()) {
logger.trace("Skipping currently created advisor '" + name + "'");
}
}
else {
try {
// 从工厂中获取对象实例
advisors.add(this.beanFactory.getBean(name, Advisor.class));
}
catch (BeanCreationException ex) {
Throwable rootCause = ex.getMostSpecificCause();
if (rootCause instanceof BeanCurrentlyInCreationException) {
BeanCreationException bce = (BeanCreationException) rootCause;
String bceBeanName = bce.getBeanName();
if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
if (logger.isTraceEnabled()) {
logger.trace("Skipping advisor '" + name +
"' with dependency on currently created bean: " + ex.getMessage());
}
// Ignore: indicates a reference back to the bean we're trying to advise.
// We want to find advisors other than the currently created bean itself.
continue;
}
}
throw ex;
}
}
}
}
return advisors;
}
这里从工厂中获取到了所有的 Advisor 类型的 beanName ，后面直接从工厂中获取到了对应的实例对象。
前面说 BeanFactoryTransactionAttributeSourceAdvisor 实现了 Advisor ，因此这里 advisors 列表中也带有 BeanFactoryTransactionAttributeSourceAdvisor 类型的实例对象。
四、事务切面增强器的匹配过程
下面再回到 findEligibleAdvisors 方法中，已经通过 findCandidateAdvisors 方法获取到 Advisor 切面增强方法了，下面通过 findAdvisorsThatCanApply 匹配出符合当前 beanName 的 Advisor，看到该方法中：
这里又调用了 AopUtils.findAdvisorsThatCanApply 方法，继续看到该方法下：
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
}
// 创建一个合适的 Advisor 的集合 eligibleAdvisors
List<Advisor> eligibleAdvisors = new ArrayList<>();
//循环所有的Advisor
for (Advisor candidate : candidateAdvisors) {
// 判断切面是否匹配
//如果Advisor是 IntroductionAdvisor 引介增强 可以为目标类 通过AOP的方式添加一些接口实现
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
//是否有引介增强
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
for (Advisor candidate : candidateAdvisors) {
//如果是IntroductionAdvisor类型的话 则直接跳过
if (candidate instanceof IntroductionAdvisor) {
// already processed
continue;
}
// 判断切面是否匹配
if (canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
这里对 Advisor 判断是否为 IntroductionAdvisor 引介增强类型，前面看到 BeanFactoryTransactionAttributeSourceAdvisor 的继承树关系，并没有实现 IntroductionAdvisor接口 ，因此最后会使用 canApply 方法进行匹配，再看到 canApply 方法中：
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {
// IntroductionAdvisor，根据类过滤器，进行匹配
//如果是 IntroductionAdvisor 的话，则调用IntroductionAdvisor类型的实例进行类的过滤
//这里是直接调用的ClassFilter的matches方法
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
// 通常情况下 Advisor 都是 PointcutAdvisor 类型
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
// 从Advisor中获取Pointcut的实现类 就是是AspectJExpressionPointcut
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
return true;
}
}
这里根据不同的类型走不同的匹配方式，再看下 BeanFactoryTransactionAttributeSourceAdvisor 的继承树关系，其中有实现 PointcutAdvisor 接口，因此会进入到 canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) 方法中，注意这里第一个 Pointcut 参数是通过 pca.getPointcut() 获取到的，在 BeanFactoryTransactionAttributeSourceAdvisor 中就是 TransactionAttributeSourcePointcut 对象：
下面看到 canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) 方法中：
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
//进行切点表达式的匹配最重要的就是 ClassFilter 和 MethodMatcher这两个方法的实现。
//首先进行ClassFilter的matches方法校验
//首先这个类要在所匹配的规则下
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
MethodMatcher methodMatcher = pc.getMethodMatcher();
// 通过切点的方法匹配策略 进行匹配
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
// 如果当前 MethodMatcher 也是IntroductionAwareMethodMatcher类型，则转为该类型
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
Set<Class<?>> classes = new LinkedHashSet<>();
if (!Proxy.isProxyClass(targetClass)) {
// 目标对象没有采用jdk动态代理，则要么是cglib代理，要么没有代理，获取到没有代理的原始类
classes.add(ClassUtils.getUserClass(targetClass));
}
// 获取到目标类的所有的超类接口
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
for (Class<?> clazz : classes) {
// 获取目标类即接口的方法，只要有一个方法满足切点条件，即视为切点可以匹配
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
// 只要有一个方法能匹配到就返回true
//MethodMatcher 中有两个 matches 方法。
// boolean matches(Method method, Class<?> targetClass) 用于静态的方法匹配
// boolean matches(Method method, Class<?> targetClass, Object... args) 用于运行期动态的进行方法匹配
for (Method method : methods) {
// 如果 MethodMatcher 是IntroductionAwareMethodMatcher类型，则使用该类型的方法进行匹配
// 否则使用 MethodMatcher.matches() 方法进行匹配
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}
该方法首先使用 ClassFilter 对类进行匹配是否符合，如果不符合直接跳过，这里先看下 TransactionAttributeSourcePointcut 中 getClassFilter 获取的是哪个对象：
从 TransactionAttributeSourcePointcut 的构造函数中可以看出具体对象为 TransactionAttributeSourceClassFilter 类型，下面看到 TransactionAttributeSourceClassFilter 类下的 matches(Class<?> clazz) 方法：
public boolean matches(Class<?> clazz) {
// 判断是否属于 TransactionalProxy 或 TransactionManager 或 PersistenceExceptionTranslator
if (TransactionalProxy.class.isAssignableFrom(clazz) ||
TransactionManager.class.isAssignableFrom(clazz) ||
PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
// 如果是返回 false 不尽兴匹配
return false;
}
// 匹配判断
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.isCandidateClass(clazz));
}
这里如果是 TransactionalProxy 或 TransactionManager 或 PersistenceExceptionTranslator 类直接返回 false 不进行后面的匹配，再接着获取到一个 TransactionAttributeSource 对象，从前面 ProxyTransactionManagementConfiguration 类中可以看出，主要为AnnotationTransactionAttributeSource类型实例，因此进到该类下的 isCandidateClass 方法中：
public boolean isCandidateClass(Class<?> targetClass) {
// 遍历事务注解析器
for (TransactionAnnotationParser parser : this.annotationParsers) {
// 是否可解析
if (parser.isCandidateClass(targetClass)) {
return true;
}
}
return false;
}
这里遍历了所有的事务解析器，这些解析器怎么来的呢，看到 AnnotationTransactionAttributeSource 的构造方法中：
public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
this.publicMethodsOnly = publicMethodsOnly;
if (jta12Present || ejb3Present) {
this.annotationParsers = new LinkedHashSet<>(4);
this.annotationParsers.add(new SpringTransactionAnnotationParser());
if (jta12Present) {
this.annotationParsers.add(new JtaTransactionAnnotationParser());
}
if (ejb3Present) {
this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
}
}
else {
this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
}
}
这里主要对 SpringTransactionAnnotationParser 类进行分析，下面可以看到 SpringTransactionAnnotationParser 类下的 isCandidateClass 方法中：
public boolean isCandidateClass(Class<?> targetClass) {
// 检查类是否带有 @Transactional 注解
return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
}
主要就是检查类是否带有 @Transactional 注解。
下面再回到 canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) 方法中，继续向下看会通过 pc.getMethodMatcher() 获取到一个 MethodMatcher 对象，这里看下 TransactionAttributeSourcePointcut 的继承关系图：
可以看到 TransactionAttributeSourcePointcut 就是 MethodMatcher 类型， 但 TransactionAttributeSourcePointcut 没有重写 getMethodMatcher() 方法，实现触发的StaticMethodMatcherPointcut 类下的 getMethodMatcher() 方法：
这里直接返回的自身，因此这里MethodMatcher 对象就是自身 TransactionAttributeSourcePointcut 。
下面再回到 canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) 方法中，最后通过反射获取到类下的方法，由于这里不属于introductionAwareMethodMatcher类型，会通过 methodMatcher.matches 判断是否符合，下面看到 TransactionAttributeSourcePointcut 类下的 matches(Method method, Class<?> targetClass) 方法中：
public boolean matches(Method method, Class<?> targetClass) {
TransactionAttributeSource tas = getTransactionAttributeSource();
// 如果存在事务信息则返回true
return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}
上面已经分析过了 TransactionAttributeSource 主要为 AnnotationTransactionAttributeSource类型实例，因此看到该类下的 getTransactionAttribute 方法中：
主要实现在父类的 AbstractFallbackTransactionAttributeSource 类中：
public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// 如果是 Object 类型，直接返回 null
if (method.getDeclaringClass() == Object.class) {
return null;
}
// First, see if we have a cached value.
// 生成缓存 key
Object cacheKey = getCacheKey(method, targetClass);
// 从缓存中获取
TransactionAttribute cached = 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) {
return null;
}
else {
return cached;
}
}
else {
//缓存中不存在
// We need to work it out.
// 判断是否为事务方法，是的话获取事务属性
TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
// Put it in the cache.
// 不存在事务
if (txAttr == null) {
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
}
else {
// 存在事务的话
// 获取方法名称
String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
if (txAttr instanceof DefaultTransactionAttribute) {
DefaultTransactionAttribute dta = (DefaultTransactionAttribute) txAttr;
dta.setDescriptor(methodIdentification);
dta.resolveAttributeStrings(this.embeddedValueResolver);
}
if (logger.isTraceEnabled()) {
logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
}
this.attributeCache.put(cacheKey, txAttr);
}
return txAttr;
}
}
这里对事物属性进行了缓存，看下缓存中不存在的情况，通过 computeTransactionAttribute 方法，尝试解析事物属性，也就是解析 @Transactional 中的属性，下面看到该方法中：
protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// Don't allow no-public methods as required.
if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
}
// 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 = AopUtils.getMostSpecificMethod(method, targetClass);
// First try is the method in the target class.
// 首先尝试检测方法是否符合
TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
// 如果存在则返回
if (txAttr != null) {
return txAttr;
}
// Second try is the transaction attribute on the target class.
// 检测方法所在类上是否符合
txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
if (specificMethod != method) {
// Fallback is to look at the original method.
txAttr = findTransactionAttribute(method);
if (txAttr != null) {
return txAttr;
}
// Last fallback is the class of the original method.
txAttr = findTransactionAttribute(method.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
}
return null;
}
这里会先尝试从方法上取获取 @Transactional 注解，不存在的话再去检测方法所在类上是否符合，这里主要看下方法层面的 findTransactionAttribute(Method method) 方法：
这里又触发了 determineTransactionAttribute 方法，继续看到该方法中：
protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
// 遍历事务解析器
for (TransactionAnnotationParser parser : this.annotationParsers) {
// 使用解析器解析事务信息
TransactionAttribute attr = parser.parseTransactionAnnotation(element);
if (attr != null) {
return attr;
}
}
return null;
}
这里又使用了前面提到的 TransactionAnnotationParser 解析器，还是主要看 SpringTransactionAnnotationParser，进到 SpringTransactionAnnotationParser 类下的 parseTransactionAnnotation 方法中：
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
// 寻找目标上的 @Transactional 注解信息
AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
element, Transactional.class, false, false);
if (attributes != null) {
// 解析注解中的参数属性，包装到 TransactionAttribute 对象中
return parseTransactionAnnotation(attributes);
}
else {
return null;
}
}
这里首先尝试获取方法上的 @Transactional 注解，如果存在的话则使用 parseTransactionAnnotation 方法解析参数，进到 parseTransactionAnnotation 方法中：
protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
// 事务的传播方式
Propagation propagation = attributes.getEnum("propagation");
rbta.setPropagationBehavior(propagation.value());
// 事务隔离级别
Isolation isolation = attributes.getEnum("isolation");
rbta.setIsolationLevel(isolation.value());
// 超时时间
rbta.setTimeout(attributes.getNumber("timeout").intValue());
String timeoutString = attributes.getString("timeoutString");
Assert.isTrue(!StringUtils.hasText(timeoutString) || rbta.getTimeout() < 0,
"Specify 'timeout' or 'timeoutString', not both");
rbta.setTimeoutString(timeoutString);
// 事务读写性
rbta.setReadOnly(attributes.getBoolean("readOnly"));
// 可选的限定描述符，指定使用的事务管理器
rbta.setQualifier(attributes.getString("value"));
rbta.setLabels(Arrays.asList(attributes.getStringArray("label")));
// 回滚的类型
List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
// 回滚的类名称
for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
// 不回滚的类型
for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
// 不回滚的类名称
for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
rbta.setRollbackRules(rollbackRules);
return rbta;
}
分别解析出注解中的属性信息，并包装为 TransactionAttribute 类型对象。
下面再回到 getTransactionAttribute 方法中，通过 computeTransactionAttribute 方法获取到事务的属性信息后，如果结果不为空的话进行属性的补充后直接将属性信息返回给了 TransactionAttributeSourcePointcut 中的 matches 方法，这里如果结果不为空返回就是为 true ，也就是匹配符合条件了。
五、事务拦截器的触发过程
在 AOP 中查找完匹配的增强方法后，如果存在会创建一个代理对象放入 Spring 容器中，在代理对象执行时，先根据 Advisor 生成一个 Advice 类型的增强器链，这里以 JDK 动态代理为例，在 JdkDynamicAopProxy 类中 invoke 方法下触发的 this.advised.getInterceptorsAndDynamicInterceptionAdvice ：
其中从 Advisor 中获取 Advice 对象的逻辑在DefaultAdvisorAdapterRegistry类下的 getInterceptors 方法中：
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
List<MethodInterceptor> interceptors = new ArrayList<>(3);
Advice advice = advisor.getAdvice();
if (advice instanceof MethodInterceptor) {
interceptors.add((MethodInterceptor) advice);
}
for (AdvisorAdapter adapter : this.adapters) {
if (adapter.supportsAdvice(advice)) {
interceptors.add(adapter.getInterceptor(advisor));
}
}
if (interceptors.isEmpty()) {
throw new UnknownAdviceTypeException(advisor.getAdvice());
}
return interceptors.toArray(new MethodInterceptor[0]);
}
增强切面方法的执行主要在 ReflectiveMethodInvocation 类下的 proceed() 中：
public Object proceed() throws Throwable {
// 该方法为 jdk的AOP实现的核心
// We start with an index of -1 and increment early.
// 从拦截器链条的尾部向头部进行递归执行
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
// 获取下一个要执行的拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
// 如果通知器为 动态方法匹配拦截器，则还需要方法是否匹配的验证
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
//获取被代理的对象类型
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
//进行动态匹配
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
//如果动态匹配失败，递归进行proceed
//不匹配就不执行当前的拦截器
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
//如果不是增强器，只是一般的拦截器
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
// 获取通知，并进行执行
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
这里会顺序执行 MethodInterceptor 类型的 invoke 方法 ，从前面的分析可以知道 BeanFactoryTransactionAttributeSourceAdvisor 中的 Advice 为 TransactionInterceptor，而 TransactionInterceptor 又实现了MethodInterceptor ，因此这里看到 TransactionInterceptor 类的 invoke 方法下：
public Object invoke(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, invocation::proceed);
}
这里又调用了父类 TransactionAspectSupport 下的 invokeWithinTransaction 方法，下面主要看到该方法中：
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// If the transaction attribute is null, the method is non-transactional.
// 获取事务属性源，如果为空则表示不存在事物
TransactionAttributeSource tas = getTransactionAttributeSource();
// 获取前面解析出来 @Transactional 注解的属性
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 根据事物属性获取对应的事物管理器，一般为 DataSourceTransactionManager
final TransactionManager tm = determineTransactionManager(txAttr);
// 是否存在 反应式事务
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
....省略...
}
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
// 获取目标方法唯一标识，如 com.xx.XX.xx
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
// 根据条件执行目标增强
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// Standard transaction demarcation with getTransaction and commit/rollback calls.
// 判断是否有必要创建一个事物，根据事物传播行为决定，如果需要则新建事务信息，还会保存至 ThreadLocal 中
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
// 返回值
Object retVal;
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);
}
if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
// Set rollback-only in case of Vavr failure matching our rollback rules...
TransactionStatus status = txInfo.getTransactionStatus();
if (status != null && txAttr != null) {
retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
}
}
// 提交事务
commitTransactionAfterReturning(txInfo);
// 如果方法正常执行，则必提交事务成功
return retVal;
}
else {
....省略...
}
}
这里会获取到前面拿到前面解析出来 @Transactional 注解的属性，并获取到事物管理器，一般为 DataSourceTransactionManager ，后面我们也主要看该类型的事务操作过程。
其中里面几个重要的方法： createTransactionIfNecessary 方法主要开启事务，completeTransactionAfterThrowing 方法回滚事务，commitTransactionAfterReturning 方法提交事务。
五、开启事务的过程
看到 TransactionAspectSupport 类下的 createTransactionIfNecessary 方法：
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
// If no name specified, apply method identification as transaction name.
if (txAttr != null && txAttr.getName() == null) {
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
public String getName() {
return joinpointIdentification;
}
};
}
TransactionStatus status = 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");
}
}
}
// 创建事务信息对象，记录新老事务信息
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}
再看到 tm.getTransaction 方法中，如果事务不存在就开启一个事务：
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException {
// Use defaults if no transaction definition given.
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
// 获取事务对象，本质上，是将当前线程的数据库连接对象，与事务相关联
Object transaction = doGetTransaction();
boolean debugEnabled = logger.isDebugEnabled();
// 首次进入，connectionHolder为空，不存在事务
// 如果事务已经存在
if (isExistingTransaction(transaction)) {
// Existing transaction found -> check propagation behavior to find out how to behave.
// 处理已经存在的事务
return handleExistingTransaction(def, transaction, debugEnabled);
}
// Check definition settings for new transaction.
// 默认事务无超时设置
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
// No existing transaction found -> check propagation behavior to find out how to proceed.
// 不存在事务，且事务传播属性为 强制时，抛错
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
throw new IllegalTransactionStateException(
"No existing transaction found for transaction marked with propagation 'mandatory'");
}
// 如果事务隔离级别为 requered,requires_new,nested, 则加入事务
else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// 挂起
SuspendedResourcesHolder suspendedResources = suspend(null);
if (debugEnabled) {
logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
}
try {
// 创建新事务
return startTransaction(def, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error ex) {
resume(null, suspendedResources);
throw ex;
}
}
else {
// Create "empty" transaction: no actual transaction, but potentially synchronization.
if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
logger.warn("Custom isolation level specified but no actual transaction initiated; " +
"isolation level will effectively be ignored: " + def);
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
}
}
这里首先通过 doGetTransaction 方法获取事务对象，前提有事务的话，本质就是去 ThreadLocal 中获取连接句柄，看到 DataSourceTransactionManager 类下 doGetTransaction 方法：
protected Object doGetTransaction() {
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
txObject.setSavepointAllowed(isNestedTransactionAllowed());
//当前数据源，在当前线程 的 连接对象
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
// 将该连接对象，设置进事务中
txObject.setConnectionHolder(conHolder, false);
return txObject;
}
其中 TransactionSynchronizationManager.getResource 就是去 ThreadLocal 中获取：
下面回到 getTransaction 方法中，如果不存在事务的话，下面通过 startTransaction 方法开启事务，看到该方法中：
private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 创建事务状态信息，封装一些事务对象的信息，记录事务状态
// 该事务标志为 新事务
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 开启事务，
// jdbc: transaction -> DataSourceTransactionObject jta: JtaTransactionObject
// jms: transaction-> JmsTransactionObject jca: CciLocalTransactionObject
doBegin(transaction, definition);
// 开启事务后，改变事务状态
prepareSynchronization(status, definition);
return status;
}
再看到 doBegin 方法中，来到 DataSourceTransactionManager 类下的方法：
protected void doBegin(Object transaction, TransactionDefinition definition) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
try {
// 如果之前没有连接，则新建连接
if (!txObject.hasConnectionHolder() ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
// 此处是 从连接池获取连接，算是应用层底层与上层的交界处
Connection newCon = obtainDataSource().getConnection();
if (logger.isDebugEnabled()) {
logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
// 将首次创建的连接，保存至 connectionHolder,connectionHolder 由 ThreadLocal实现
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
// 从当前事务，获取连接，一个事务下，用的同一个连接
con = txObject.getConnectionHolder().getConnection();
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// 设置事务的可读状态
txObject.setReadOnly(definition.isReadOnly());
// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
// 有事务的环境，如果设置了自动提交，则会自动切换到 手动提交
if (con.getAutoCommit()) {
txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
// 关闭连接得自动提交，这一步实际上就开启了事务
con.setAutoCommit(false);
}
// 设置事务只读状态
prepareTransactionalConnection(con, definition);
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// Bind the connection holder to the thread.
// 如果是新创建的事务
if (txObject.isNewConnectionHolder()) {
// 就 建立 当前线程，和 数据库连接的绑定关系
TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
}
}
catch (Throwable ex) {
if (txObject.isNewConnectionHolder()) {
DataSourceUtils.releaseConnection(con, obtainDataSource());
txObject.setConnectionHolder(null, false);
}
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
获取到数据库连接后，通过 con.setAutoCommit(false) 将自动提交关闭，实际上就已经开启了事务。
在最后 TransactionSynchronizationManager.bindResource 就是将当前连接句柄存放发到前面提到的 resources ThreadLocal 中：
六、回滚事务过程
看到 TransactionAspectSupport 类下的 completeTransactionAfterThrowing 方法：
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
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 (TransactionSystemException ex2) {
logger.error("Application exception overridden by rollback exception", ex);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException | Error ex2) {
logger.error("Application exception overridden by rollback exception", ex);
throw ex2;
}
}
// 否则提交该事务
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 (TransactionSystemException ex2) {
logger.error("Application exception overridden by commit exception", ex);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException | Error ex2) {
logger.error("Application exception overridden by commit exception", ex);
throw ex2;
}
}
}
}
如果设置了 rollbackOn 参数，会异常类型判断是否符合，不符合直接提交事务。
如果符合则获取到事务管理器进行 回滚操作，看到 rollback 方法中：
public final void rollback(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
// 回滚
processRollback(defStatus, false);
}
再看到 processRollback 方法中：
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
try {
boolean unexpectedRollback = unexpected;
try {
triggerBeforeCompletion(status);
// 内嵌事务，则去除回滚点
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Rolling back transaction to savepoint");
}
status.rollbackToHeldSavepoint();
}
// 当前事务为新事务
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction rollback");
}
// 则执行回滚
doRollback(status);
}
else {
...省略...
}
}
catch (RuntimeException | Error ex) {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
throw ex;
}
// 触发后置通知
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
// Raise UnexpectedRollbackException if we had a global rollback-only marker
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction rolled back because it has been marked as rollback-only");
}
}
finally {
cleanupAfterCompletion(status);
}
}
主要回滚逻辑在 doRollback 方法中，看到DataSourceTransactionManager 类下的该方法：
protected void doRollback(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
}
try {
// 通过数据库实现回滚
con.rollback();
}
catch (SQLException ex) {
throw translateException("JDBC rollback", ex);
}
}
获取到数据库连接后，通过 con.rollback() 进行事务的回滚。
七、提交事务的过程
看到TransactionAspectSupport 类下的 commitTransactionAfterReturning 方法中：
protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
if (txInfo != null && txInfo.getTransactionStatus() != null) {
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
}
// 调用事务管理器提交该事务
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
}
}
这里使用了事务管理器的 commit 方法，看到该方法下：
public final void commit(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
if (defStatus.isLocalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Transactional code has requested rollback");
}
processRollback(defStatus, false);
return;
}
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
}
processRollback(defStatus, true);
return;
}
// 处理事务提交操作
processCommit(defStatus);
}
再看到 processCommit 方法下：
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
try {
boolean beforeCompletionInvoked = false;
try {
boolean unexpectedRollback = false;
prepareForCommit(status);
triggerBeforeCommit(status);
triggerBeforeCompletion(status);
beforeCompletionInvoked = true;
// 内嵌事务
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Releasing transaction savepoint");
}
// 不提交，只是将 savepoint 清除
unexpectedRollback = status.isGlobalRollbackOnly();
status.releaseHeldSavepoint();
}
// 当前事务为新事务
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction commit");
}
unexpectedRollback = status.isGlobalRollbackOnly();
// 提交事务
doCommit(status);
}
else if (isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = status.isGlobalRollbackOnly();
}
// Throw UnexpectedRollbackException if we have a global rollback-only
// marker but still didn't get a corresponding exception from commit.
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction silently rolled back because it has been marked as rollback-only");
}
}
catch (UnexpectedRollbackException ex) {
// can only be caused by doCommit
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
throw ex;
}
catch (TransactionException ex) {
// can only be caused by doCommit
if (isRollbackOnCommitFailure()) {
doRollbackOnCommitException(status, ex);
}
else {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
}
throw ex;
}
catch (RuntimeException | Error ex) {
if (!beforeCompletionInvoked) {
triggerBeforeCompletion(status);
}
doRollbackOnCommitException(status, ex);
throw ex;
}
// Trigger afterCommit callbacks, with an exception thrown there
// propagated to callers but the transaction still considered as committed.
try {
triggerAfterCommit(status);
}
finally {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
}
}
finally {
cleanupAfterCompletion(status);
}
}
这里的判断逻辑和回滚的逻辑差不多，主要提交逻辑在 doCommit 方法中，看到 DataSourceTransactionManager 类下该方法：
protected void doCommit(DefaultTransactionStatus status) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
if (status.isDebug()) {
logger.debug("Committing JDBC transaction on Connection [" + con + "]");
}
try {
// 通过数据库连接，实现事务提交
con.commit();
}
catch (SQLException ex) {
throw translateException("JDBC commit", ex);
}
}
获取到数据库连接后，通过 con.commit() 进行事务的提交。
