【Srping】事务的执行原理（一）

在使用事务的时候需要添加@EnableTransactionManagement注解来开启事务，那么就从@EnableTransactionManagement入手查看一下事务的执行原理。

@EnableTransactionManagement

Spring事务底层是通过AOP来完成的，而Spring AOP基于动态代理实现，可以看到mode方法默认返回了PROXY代理模式，我们只需关注代理模式下的执行流程即可
使用@Import导入了TransactionManagementConfigurationSelector

@Target(ElementType.TYPE)

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Import(TransactionManagementConfigurationSelector.class)

public @interface EnableTransactionManagement {

        // 是否代理目标类

	boolean proxyTargetClass() default false;

	// 默认使用代理模式

	AdviceMode mode() default AdviceMode.PROXY;

	int order() default Ordered.LOWEST_PRECEDENCE;

}

TransactionManagementConfigurationSelector

在selectImports方法中可以看到对模式进行了判断：

如果是基于代理模式，返回AutoProxyRegistrar和ProxyTransactionManagementConfiguration类
如果是基于ASPECTJ，调用determineTransactionAspectClass方法

Spring默认使用的是代理模式，所以接下来看下AutoProxyRegistrar和ProxyTransactionManagementConfiguration里面都有什么。

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {

	@Override

	protected String[] selectImports(AdviceMode adviceMode) {

		switch (adviceMode) {

			case PROXY:

                                // 如果基于代理模式

				return new String[] {AutoProxyRegistrar.class.getName(),

						ProxyTransactionManagementConfiguration.class.getName()};

			case ASPECTJ:

                                // 如果基于ASPECTJ

				return new String[] {determineTransactionAspectClass()};

			default:

				return null;

		}

	}

	private String determineTransactionAspectClass() {

		return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ?

				TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME :

				TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);

	}

}

AutoProxyRegistrar

AutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口，ImportBeanDefinitionRegistrar可以向容器中注册Bean，跟着registerBeanDefinitions方法看下它会向容器中注册什么样的bean：

public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

        @Override

	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

		boolean candidateFound = false;

		Set<String> annTypes = importingClassMetadata.getAnnotationTypes();

		for (String annType : annTypes) {

			AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);

			if (candidate == null) {

				continue;

			}

			Object mode = candidate.get("mode");

			Object proxyTargetClass = candidate.get("proxyTargetClass");

			if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&

					Boolean.class == proxyTargetClass.getClass()) {

				candidateFound = true;

				if (mode == AdviceMode.PROXY) {

                                        // 调用AopConfigUtils的registerAutoProxyCreatorIfNecessary向容器中注册bean

					AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);

					if ((Boolean) proxyTargetClass) {

						AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);

						return;

					}

				}

			}

		}

		if (!candidateFound && logger.isInfoEnabled()) {

			String name = getClass().getSimpleName();

			logger.info(String.format("%s was imported but no annotations were found " +

					"having both 'mode' and 'proxyTargetClass' attributes of type " +

					"AdviceMode and boolean respectively. This means that auto proxy " +

					"creator registration and configuration may not have occurred as " +

					"intended, and components may not be proxied as expected. Check to " +

					"ensure that %s has been @Import'ed on the same class where these " +

					"annotations are declared; otherwise remove the import of %s " +

					"altogether.", name, name, name));

		}

	}

}

AopConfigUtils

在AopConfigUtils中一共有三种自动代理创建器：

InfrastructureAdvisorAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator
AnnotationAwareAspectJAutoProxyCreator

在registerAutoProxyCreatorIfNecessary方法中，可以看到事务使用的是InfrastructureAdvisorAutoProxyCreator类型的创建器：

public abstract class AopConfigUtils {

	/**

	 * 自动代理创建器BeanName

	 */

	public static final String AUTO_PROXY_CREATOR_BEAN_NAME =

			"org.springframework.aop.config.internalAutoProxyCreator";

	/**

	 * 所有的自动代理创建器集合

	 */

	private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<>(3);

	static {

		// 初始化

		APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);

		APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class); // AspectJ

		APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class); // 注解

	}

        // AutoProxyRegistrar中调用的registerAutoProxyCreatorIfNecessary方法

	@Nullable

	public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {

	        // 会调用下面那个registerAutoProxyCreatorIfNecessary方法

		return registerAutoProxyCreatorIfNecessary(registry, null);

	}

	@Nullable

	public static BeanDefinition registerAutoProxyCreatorIfNecessary(

			BeanDefinitionRegistry registry, @Nullable Object source) {

		// 调用registerOrEscalateApcAsRequired进行注册，这里传入的是InfrastructureAdvisorAutoProxyCreator类型的

		return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);

	}

@Nullable

	private static BeanDefinition registerOrEscalateApcAsRequired(

			Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

                // 判断容器中是否已经包含代理创建器

		if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {

                        // 从容器中获取

			BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);

			if (!cls.getName().equals(apcDefinition.getBeanClassName())) {

                               // 判断容器中已经存在的创建器的优先级

				int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());

                                // 需要的创建器的优先级

				int requiredPriority = findPriorityForClass(cls);

                                // 如果容器中已经存在的创建器的优先级小于需要创建的

				if (currentPriority < requiredPriority) {

                                         // 使用优先级高的

					apcDefinition.setBeanClassName(cls.getName());

				}

			}

			return null;

		}

                // 创建RootBeanDefinition

		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);

                // 设置source

		beanDefinition.setSource(source);

		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);

		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);

                // 注册代理创建器

		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);

		return beanDefinition;

	}

}

总结

AutoProxyRegistrar实现ImportBeanDefinitionRegistrar是为了向容器中注册代理创建器，事务默认使用的是InfrastructureAdvisorAutoProxyCreator类型的。

ProxyTransactionManagementConfiguration

1. AOP概念

Advice通知：定义在切点上需要执行什么样的操作

PointCut切点：定义在哪些方法上使用通知

Advisor：Advice和Pointcut加起来组成了Advisor

2. 事务中的Advisor

我们已经知道事务是基于AOP实现的，在transactionAdvisor方法中可以看到创建了Advisor，然后设置了事务属性TransactionAttributeSource和事务拦截器TransactionInterceptor：

TransactionAttributeSource，从名字上可以看出是和事务的属性设置相关的
TransactionInterceptor事务拦截器相当于Advice通知
BeanFactoryTransactionAttributeSourceAdvisor是Advisor

Advisor由Advice和PointCut组成，现在Advice已经有了，接下来看下Pointcut在哪里。

@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) {

                // 创建Advisor

		BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();

                // 设置TransactionAttributeSource，类型为AnnotationTransactionAttributeSource

		advisor.setTransactionAttributeSource(transactionAttributeSource);

                // 设置事务拦截器，相当于Advice

		advisor.setAdvice(transactionInterceptor);

		if (this.enableTx != null) {

			advisor.setOrder(this.enableTx.<Integer>getNumber("order"));

		}

		return advisor;

	}

        @Bean

	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)

	public TransactionAttributeSource transactionAttributeSource() {

                // 创建AnnotationTransactionAttributeSource

		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

BeanFactoryTransactionAttributeSourceAdvisor继承关系如下：

除了继承父类的属性和方法，它自己还有两个成员变量：

transactionAttributeSource，实际传入的是AnnotationTransactionAttributeSource类型的对象
TransactionAttributeSourcePointcut类型的切点pointcut
- 切点在实例化时实现了getTransactionAttributeSource方法，返回了transactionAttributeSource，后面的方法中需要调用此方法获取transactionAttributeSource

由上面的分析可知，在创建BeanFactoryTransactionAttributeSourceAdvisor的时候，设置了TransactionInterceptor和TransactionAttributeSource，TransactionInterceptor相当于Advice，而这里我们看到了它还有一个TransactionAttributeSourcePointcut切点:

public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {

	@Nullable

	private TransactionAttributeSource transactionAttributeSource; // 实际传入的是AnnotationTransactionAttributeSource类型的

        // 创建切点

	private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {

                // 实现了getTransactionAttributeSource方法，返回的是AnnotationTransactionAttributeSource

		@Override

		@Nullable

		protected TransactionAttributeSource getTransactionAttributeSource() {

			return transactionAttributeSource;

		}

	};

	public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {

                // 设置TransactionAttributeSource

		this.transactionAttributeSource = transactionAttributeSource;

	}

	@Override

	public Pointcut getPointcut() {

		return this.pointcut;

	}

}

TransactionAttributeSourcePointcut

TransactionAttributeSourcePointcut是一个切点，它的继承关系如下：

Pointcut和MethodMatcher

Pointcut接口中定义了两个方法：

获取ClassFilter，ClassFilter是一个接口，里面定义了matches方法，检查切点是否与类匹配
获取MethodMatcher，它也是一个接口，并且定义了matches方法，检查切点是否与方法匹配

public interface Pointcut {

	/**

	 * 返回类过滤器ClassFilter

	 */

	ClassFilter getClassFilter();

	/**

	 * 返回MethodMatcher

	 */

	MethodMatcher getMethodMatcher();

}

public interface MethodMatcher {

	/**

	 * 检查方法是否匹配pointcut

	 */

	boolean matches(Method method, Class<?> targetClass);

	/**

	 * 检查方法是否匹配pointcut

	 */

	boolean matches(Method method, Class<?> targetClass, Object... args);

}

@FunctionalInterface

public interface ClassFilter {

	/**

	 * 检查类是否与pointcut匹配

	 */

	boolean matches(Class<?> clazz);

}

TransactionAttributeSourcePointcut是Pointcut和MethodMatcher的子类：

在构造函数中设置了ClassFilter，类型为TransactionAttributeSourceClassFilter，它是TransactionAttributeSourcePointcut的一个内部类，实现了ClassFilter接口中定义的matches方法，检查pointcut与类是否匹配：
- 如果是TransactionalProxy、PlatformTransactionManager或者PersistenceExceptionTranslator的子类，则不匹配
- 获取TransactionAttributeSource，调用它的isCandidateClass方法判断是否匹配
实现了MethodMatcher接口中定义的matches方法，检查pointcut是否匹配当前的方法
- 获取TransactionAttributeSource判断是否为空，如果不为空则调用getTransactionAttribute获取事务属性，TransactionAttributeSource为空，或者从TransactionAttributeSource获取到的事务属性不为空都会返回true

所以一个方法执行时开启事务，需要满足两个条件，当前的方法和类都需要与事务的pointcut匹配，对应的方法分别是MethodMatcher的matches和ClassFilter的matches方法。

abstract class TransactionAttributeSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {

	protected TransactionAttributeSourcePointcut() {

                // 设置ClassFilter

		setClassFilter(new TransactionAttributeSourceClassFilter());

	}

        // 方法是否与切点匹配

	@Override

	public boolean matches(Method method, Class<?> targetClass) {

                // 获取TransactionAttributeSource，由上面的步骤可知返回的是AnnotationTransactionAttributeSource

		TransactionAttributeSource tas = getTransactionAttributeSource();

                 // 如果TransactionAttributeSource为空，或者从TransactionAttributeSource获取到的事务属性不为空都会返回true

		return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);

	}

  // ClassFilter过滤器

  private class TransactionAttributeSourceClassFilter implements ClassFilter {

                // 切点是否与类匹配

		@Override

		public boolean matches(Class<?> clazz) {

                        // 如果TransactionalProxy、PlatformTransactionManager或者PersistenceExceptionTranslator的子类，则不匹配

			if (TransactionalProxy.class.isAssignableFrom(clazz) ||

					PlatformTransactionManager.class.isAssignableFrom(clazz) ||

					PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {

				return false;

			}

                        // 获取TransactionAttributeSource，由上文可知是AnnotationTransactionAttributeSource类型的

			TransactionAttributeSource tas = getTransactionAttributeSource();

                       // 调用isCandidateClass方法判断是否是匹配

			return (tas == null || tas.isCandidateClass(clazz));

		}

	}

}

AnnotationTransactionAttributeSource

条件一：检查类是否匹配事务切点

上面分析可知，检查类是否与切点匹配时获取了TransactionAttributeSource，调用它的isCandidateClass方法进行判断，TransactionAttributeSource的具体实现是AnnotationTransactionAttributeSource：

在构造方法中，添加了注解解析器：
- Spring事务注解解析器的实现类为SpringTransactionAnnotationParser，也是默认的注解解析器。
- 如果开启了JTA或者EJB，将会分别添加对应的解析器。
实现了isCandidateClass方法，实际又是调用注解解析器的isCandidateClass判断是否是候选类的。

@SuppressWarnings("serial")

public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource

		implements Serializable {

	private static final boolean jta12Present;

	private static final boolean ejb3Present;

	static {

		ClassLoader classLoader = AnnotationTransactionAttributeSource.class.getClassLoader();

		jta12Present = ClassUtils.isPresent("javax.transaction.Transactional", classLoader);

		ejb3Present = ClassUtils.isPresent("javax.ejb.TransactionAttribute", classLoader);

	}

	private final boolean publicMethodsOnly;

        // 注解解析器集合

	private final Set<TransactionAnnotationParser> annotationParsers;

	public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {

		this.publicMethodsOnly = publicMethodsOnly;

                // 添加注解解析器

		if (jta12Present || ejb3Present) {

			this.annotationParsers = new LinkedHashSet<>(4);

                        // 添加Spring事务注解解析器

			this.annotationParsers.add(new SpringTransactionAnnotationParser());

			if (jta12Present) {

                                // JTA事务注解解析器

				this.annotationParsers.add(new JtaTransactionAnnotationParser());

			}

			if (ejb3Present) {

                                 // EJB3事务注解解析器

				this.annotationParsers.add(new Ejb3TransactionAnnotationParser());

			}

		}

		else {

                         // 添加Spring事务注解解析器

			this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());

		}

	}

        // 判断是否是候选类

	@Override

	public boolean isCandidateClass(Class<?> targetClass) {

		for (TransactionAnnotationParser parser : this.annotationParsers) {

                        // 调用解析器的isCandidateClass方法判断是否是候选类

			if (parser.isCandidateClass(targetClass)) {

				return true;

			}

		}

		return false;

	}

}

SpringTransactionAnnotationParser

SpringTransactionAnnotationParser实现了isCandidateClass方法，它又调用了AnnotationUtils的isCandidateClass判断目标类是否是Transactional注解的候选类，AnnotationUtils中isCandidateClass的具体判断逻辑如下：
- 如果注解类路径以java.开头，返回true，这里Transactional注解不是java.开头，它是Spring的注解类，所以这个条件不会成立
- 如果目标类的类路径以java.开头，或者是Ordered类型，isCandidateClass返回false，说明目标类不是某个注解的候选类
- 除去以上两种情况之外，isCandidateClass都返回true
  
  总结：如果目标类的类路径不以java.开头（也就是说它不是java的相关类），也不是Ordered类型，说明目标类是Transactional注解的候选类。
SpringTransactionAnnotationParser实现了parseTransactionAnnotation方法，里面包含对事物属性的解析

public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {

	@Override

	public boolean isCandidateClass(Class<?> targetClass) {

                // 是否是Transactional注解的候选类

		return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);

	}

        // 解析注解属性

	@Override

	@Nullable

	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {

		AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(

				element, Transactional.class, false, false);

		if (attributes != null) {

                        // 解析注解属性

			return parseTransactionAnnotation(attributes);

		}

		else {

			return null;

		}

	}

       /**

        * 解析事务注解

        */

	public TransactionAttribute parseTransactionAnnotation(Transactional ann) {

		return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));

	}

       /**

        * 解析事务注解

        */

	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());

		rbta.setReadOnly(attributes.getBoolean("readOnly"));

		rbta.setQualifier(attributes.getString("value"));

		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;

	}

}

// AnnotationUtils

public abstract class AnnotationUtils {

        /**

	 * 检查目标类clazz是否是注解的候选类

	 */

	public static boolean isCandidateClass(Class<?> clazz, Collection<Class<? extends Annotation>> annotationTypes) {

		for (Class<? extends Annotation> annotationType : annotationTypes) {

                        // 传入目标类和注解，SpringTransactionAnnotationParser传入的注解是Transactional

			if (isCandidateClass(clazz, annotationType)) {

				return true;

			}

		}

		return false;

	}

    /**

     * 检查目标类clazz是否是注解的候选类

     */

    public static boolean isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType) {

                // 传入目标类和注解类路径

		return isCandidateClass(clazz, annotationType.getName());

	}

	/**

	 * 检查目标类clazz是否是注解的候选类

	 */

	public static boolean isCandidateClass(Class<?> clazz, String annotationName) {

                // 注解类路径是否是java.开头

		if (annotationName.startsWith("java.")) {

			return true;

		}

                // 调用AnnotationsScanner的hasPlainJavaAnnotationsOnly方法判断

                // hasPlainJavaAnnotationsOnly方法的判断逻辑是：如果目标类的类路径以java.开头或者是Ordered类会返回true

               // 所以如果目标类的类路径以java.开头或者是Ordered类，isCandidateClass会返回false，说明目标类不是注解的候选类

		if (AnnotationsScanner.hasPlainJavaAnnotationsOnly(clazz)) {

			return false;

		}

                // 如果注解类路径不是java.开头，并且目标类的类路径不以java.开头，也不是Ordered类型，返回true，说明目标类是某个注解的候选类

		return true;

	}

}

// AnnotationsScanner

abstract class AnnotationsScanner {

    static boolean hasPlainJavaAnnotationsOnly(Class<?> type) {

                // 如果目标类的类路径以java.开头或者是Ordered类

		return (type.getName().startsWith("java.") || type == Ordered.class);

	}

}

条件二：检查方法是否匹配事务切点

AbstractFallbackTransactionAttributeSource

如果从TransactionAttributeSource获取到的事务属性不为空将会满足切点的匹配条件，获取事务属性的方法实现在AbstractFallbackTransactionAttributeSource类中：

如果当前方法是Object中的方法，返回空
根据当前的方法和类的信息构建缓存key，从缓存中获取
- 如果获取不为空，判断是否为空的事务属性NULL_TRANSACTION_ATTRIBUTE，如果是则返回null，否则返回从缓存中获取到的事务属性
- 如果获取为空，调用解析事务属性的方法进行解析，然后放入缓存中并返回

public abstract class AbstractFallbackTransactionAttributeSource implements TransactionAttributeSource {

        // 空的TransactionAttribute

	@SuppressWarnings("serial")

	private static final TransactionAttribute NULL_TRANSACTION_ATTRIBUTE = new DefaultTransactionAttribute() {

		@Override

		public String toString() {

			return "null";

		}

	};

        // 缓存

	private final Map<Object, TransactionAttribute> attributeCache = new ConcurrentHashMap<>(1024);

        // 获取事务属性

        @Override

	@Nullable

	public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {

                // 如果当前方法所在的类是Object

		if (method.getDeclaringClass() == Object.class) {

			return null;

		}

		// 构建cacheKey

		Object cacheKey = getCacheKey(method, targetClass);

                // 首先根据cacheKey从缓存中获取

		TransactionAttribute cached = this.attributeCache.get(cacheKey);

		if (cached != null) {

			// 判断是否为空的TRANSACTION_ATTRIBUTE

			if (cached == NULL_TRANSACTION_ATTRIBUTE) {

                                // 返回空

				return null;

			}

			else {

                                // 返回事务属性TransactionAttribute

				return cached;

			}

		}

		else {

			// 解析TransactionAttribute

			TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);

			// 如果为空，也加入缓存，但是value是NULL_TRANSACTION_ATTRIBUTE

			if (txAttr == null) {

				this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);

			}

			else {

				String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);

                                // 如果是DefaultTransactionAttribute类型的

				if (txAttr instanceof DefaultTransactionAttribute) {

					((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);

				}

				if (logger.isTraceEnabled()) {

					logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);

				}

                                // 加入缓存

				this.attributeCache.put(cacheKey, txAttr);

			}

			return txAttr;

		}

	}

        // 获取缓存KEY

	protected Object getCacheKey(Method method, @Nullable Class<?> targetClass) {

		return new MethodClassKey(method, targetClass);

	}

	/**

	 * 解析TransactionAttribute

	 */

	@Nullable

	protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {

		// 判断方法是否是public的

		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {

			return null;

		}

		// 获取目标方法

		Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);

		// 在方法上查找事务属性的设置，findTransactionAttribute方法在AnnotationTransactionAttributeSource中实现

		TransactionAttribute txAttr = findTransactionAttribute方法(specificMethod);

		if (txAttr != null) {

			return txAttr;

		}

		// 在目标类上面查找事务属性的设置

		txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());

		if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {

			return txAttr;

		}

		if (specificMethod != method) {

			// 使用方法上配置的事务属性

			txAttr = findTransactionAttribute(method);

			if (txAttr != null) {

				return txAttr;

			}

			// 使用类上面配置的事务属性

			txAttr = findTransactionAttribute(method.getDeclaringClass());

			if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {

				return txAttr;

			}

		}

		return null;

	}

}

总结

事务是基于AOP实现的，事务的Advisor是BeanFactoryTransactionAttributeSourceAdvisor，Advisor判断方法是否匹配时，是通过Pointcut的matches方法判断的，事务的Pointcut是TransactionAttributeSourcePointcut，里面实现了方法是否与事务切点匹配的判断：

对类的匹配是通过判断目标类是否是Transactional注解的候选类实现的，我们创建的类一般不会以java.开头，所以说可以与Transactional注解匹配成功。
对方法的匹配是通过解析方法上面配置的事务属性判断的，如果解析到了事务属性，则满足匹配条件。

TransactionInterceptor

TransactionInterceptor是事务Advisor的Advice，执行目标方法时，方法会被拦截，进入到TransactionInterceptor中，在TransactionInterceptor的invoke方法中实际是调用invokeWithinTransaction执行的：

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {

  @Override

	@Nullable

	public Object invoke(MethodInvocation invocation) throws Throwable {

		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		// 通过事务执行目标方法，实现在TransactionAspectSupport方法中

		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);

	}

}

TransactionAspectSupport

TransactionAspectSupport中实现了invokeWithinTransaction方法：

获取事务属性TransactionAttribute和TransactionManager事务管理器
对响应式事务、声明式事务和编程式事务分别进行判断，以声明式事务为例步骤如下：
- 创建事务
- 执行方法
- 捕捉异常，如果抛出异常进行回滚
- 清除事务信息
- 提交事务

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {

@Nullable

	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,

			final InvocationCallback invocation) throws Throwable {

		// 获取TransactionAttributeSource

		TransactionAttributeSource tas = getTransactionAttributeSource();

		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);

                // 获取事务管理器TransactionManager

		final TransactionManager tm = determineTransactionManager(txAttr);

                // 响应式事务处理

		if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {

			ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {

				if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {

					throw new TransactionUsageException(

							"Unsupported annotated transaction on suspending function detected: " + method +

							". Use TransactionalOperator.transactional extensions instead.");

				}

				ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());

				if (adapter == null) {

					throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " +

							method.getReturnType());

				}

				return new ReactiveTransactionSupport(adapter);

			});

			return txSupport.invokeWithinTransaction(

					method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);

		}

		PlatformTransactionManager ptm = asPlatformTransactionManager(tm);

		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

                // 声明式事务的处理

		if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {

			// 创建事务

			TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

			Object retVal;

			try {

				// This is an around advice: Invoke the next interceptor in the chain.

                                // 这是一个环绕通知，将会在拦截链中执行下一个拦截

				retVal = invocation.proceedWithInvocation();

			}

			catch (Throwable ex) {

				// 捕捉异常，进行回滚

				completeTransactionAfterThrowing(txInfo, ex);

				throw ex;

			}

			finally {

                                // 清除事务

				cleanupTransactionInfo(txInfo);

			}

			if (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 {

			final ThrowableHolder throwableHolder = new ThrowableHolder();

			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.

			try {

				Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {

                                        // 获取事务信息

					TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);

					try {

                                                // 执行方法

						Object retVal = invocation.proceedWithInvocation();

						if (vavrPresent && VavrDelegate.isVavrTry(retVal)) {

							// Set rollback-only in case of Vavr failure matching our rollback rules...

							retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);

						}

						return retVal;

					}

					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.

							throwableHolder.throwable = ex;

							return null;

						}

					}

					finally {

                                                // 清除事务信息

						cleanupTransactionInfo(txInfo);

					}

				});

				// Check result state: It might indicate a Throwable to rethrow.

				if (throwableHolder.throwable != null) {

					throw throwableHolder.throwable;

				}

				return result;

			}

			catch (ThrowableHolderException ex) {

				throw ex.getCause();

			}

			catch (TransactionSystemException ex2) {

				if (throwableHolder.throwable != null) {

					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);

					ex2.initApplicationException(throwableHolder.throwable);

				}

				throw ex2;

			}

			catch (Throwable ex2) {

				if (throwableHolder.throwable != null) {

					logger.error("Application exception overridden by commit exception", throwableHolder.throwable);

				}

				throw ex2;

			}

		}

	}

}

总结

参考

【猫吻鱼】Spring源码分析：全集整理

Spring版本：5.2.5.RELEASE

巴特西