• 【源码】SpringBoot事务注册原理

    Spring事务

    1、【源码】SpringBoot事务注册原理

    2、【源码】Spring Data JPA原理解析之事务注册原理

    3、【源码】Spring Data JPA原理解析之事务执行原理

    4、【源码】SpringBoot编程式事务使用及执行原理

    5、【源码】Spring事务之传播特性的详解

    6、【源码】Spring事务之事务失效及原理

    前言

    对于数据库的操作，可能存在脏读、不可重复读、幻读等问题，从而引入了事务的概念。

    事务

    1.1 事务的定义

    事务是指在数据库管理系统中，一系列紧密相关的操作序列，这些操作作为一个单一的工作单元执行。事务的特点是要么全部成功，要么全部失败，不会出现部分完成的情况。如果事务中的任何一个操作失败，那么整个事务都会被回滚到开始之前的状态，以确保数据库的一致性和完整性。

    1.2 事务的特性

    事务具有4个特性：原子性、一致性、隔离性和持久性。通常称为ACID。

    1）原子性（Atomicity）

    事务是一个不可分割的工作单位，事务中包含的所有操作要么全部成功，要么全部失败。

    2）隔离性（Isolation）

    一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的。

    3）持久性（Durability）

    一旦事务提交成功，则其所做的修改就会永久保存在数据库中，即使发生系统故障也不会丢失。

    4）一致性（Consistency）

    事务必须确保数据库从一个一致性状态转变到另一个一致性状态。

    更准确的说，事务是通过原子性、隔离性和持久性，实现了事务的一致性。另外，一致性还需要额外的工作来保证，如转账，从A转给B，A的资金减少了，B的资金增加了。转账要么成功、要么失败，但不管成功还是失败，事务的一致性要求两人的资金之和必须一致，要么成功，A减少了、B增加了，要么失败，A和B的资金都不变。为了一致性，需要程序来开启事务，同时修改A和B的资金，从而才能保证一致性。

    SpringBoot自动装载

    在SpringBoot框架中，会自动引入TransactionAutoConfiguration。且在META-INF的spring-autoconfigure-metadata.properties有如下配置：

    1. org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration=
    2. org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration$EnableTransactionManagementConfiguration=
    3. org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration$EnableTransactionManagementConfiguration.ConditionalOnBean=org.springframework.transaction.TransactionManager

    说明在自动引入TransactionAutoConfiguration时，必须存在TransactionManager的bean，且要先引入内部类EnableTransactionManagementConfiguration。

    EnableTransactionManagementConfiguration

    内部类EnableTransactionManagementConfiguration的源码如下：

    1. public class TransactionAutoConfiguration {
    2. 	@Configuration(proxyBeanMethods = false)
    3. 	@ConditionalOnBean(TransactionManager.class)
    4. 	@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
    5. 	public static class EnableTransactionManagementConfiguration {
    6.  
    7. 		@Configuration(proxyBeanMethods = false)
    8. 		@EnableTransactionManagement(proxyTargetClass = false)
    9. 		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false")
    10. 		public static class JdkDynamicAutoProxyConfiguration {
    11.  
    12. 		}
    13.  
    14. 		@Configuration(proxyBeanMethods = false)
    15. 		@EnableTransactionManagement(proxyTargetClass = true)
    16. 		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
    17. 				matchIfMissing = true)
    18. 		public static class CglibAutoProxyConfiguration {
    19.  
    20. 		}
    21.  
    22. 	}
    23. }

    EnableTransactionManagementConfiguration内中会自动引入JdkDynamicAutoProxyConfiguration和CglibAutoProxyConfiguration，且添加了@EnableTransactionManagement注解。该注解会自动引入TransactionManagementConfigurationSelector。TransactionManagementConfigurationSelector的父类实现了ImportSelector接口，该类的selectImports()方法返回AutoProxyRegistrar和ProxyTransactionManagementConfiguration类名数组，即AutoProxyRegistrar和ProxyTransactionManagementConfiguration会自动注入到Spring IOC容器中。

    Spring的配置类解析的时候，会执行ConfigurationClassParser.processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection importCandidates, boolean checkForCircularImports)，在该方法中，判断importCandidates是否继承于ImportSelector接口，如果是，调用ImportSelector的selectImports()方法，获取需要额外自动加入容器的类。

    ProxyTransactionManagementConfiguration

    ProxyTransactionManagementConfiguration的源码如下：

    1. package org.springframework.transaction.annotation;
    2.  
    3. /**
    4.  * Transaction事务管理代理的配置类
    5.  */
    6. @Configuration
    7. @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    8. public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
    9.  
    10. 	/**
    11. 	 * 返回一个BeanFactoryTransactionAttributeSourceAdvisor【继承AbstractBeanFactoryPointcutAdvisor，重
    12. 	 * 写了getPointcut()方法。即当前Advisor包含了事务需要的advice以及pointcut】
    13. 	 * @return
    14. 	 */
    15. 	@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    16. 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    17. 	public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
    18. 		// 声明一个BeanFactoryTransactionAttributeSourceAdvisor对象，
    19. 		// 传入的transactionAttributeSource为AnnotationTransactionAttributeSource
    20. 		BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
    21. 		advisor.setTransactionAttributeSource(transactionAttributeSource());
    22. 		advisor.setAdvice(transactionInterceptor());
    23. 		if (this.enableTx != null) {
    24. 			advisor.setOrder(this.enableTx.getNumber("order"));
    25. 		}
    26. 		return advisor;
    27. 	}
    28.  
    29. 	/**
    30. 	 * 创建一个AnnotationTransactionAttributeSource对象，该继承AbstractFallbackTransactionAttributeSource，
    31. 	 * 对外提供了getTransactionAttribute()方法。该方法返回某个方法的事务注解信息
    32. 	 */
    33. 	@Bean
    34. 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    35. 	public TransactionAttributeSource transactionAttributeSource() {
    36. 		return new AnnotationTransactionAttributeSource();
    37. 	}
    38.  
    39. 	/**
    40. 	 * 创建一个TransactionInterceptor对象
    41. 	 * @return
    42. 	 */
    43. 	@Bean
    44. 	@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    45. 	public TransactionInterceptor transactionInterceptor() {
    46. 		TransactionInterceptor interceptor = new TransactionInterceptor();
    47. 		interceptor.setTransactionAttributeSource(transactionAttributeSource());
    48. 		if (this.txManager != null) {
    49. 			interceptor.setTransactionManager(this.txManager);
    50. 		}
    51. 		return interceptor;
    52. 	}
    53.  
    54. }

    在ProxyTransactionManagementConfiguration中，自动注入了BeanFactoryTransactionAttributeSourceAdvisor、AnnotationTransactionAttributeSource和TransactionInterceptor。添加了事务处理的advisor，该advisor生效时，会执行TransactionInterceptor拦截器。

    BeanFactoryTransactionAttributeSourceAdvisor

    BeanFactoryTransactionAttributeSourceAdvisor的源码如下：

    1. package org.springframework.transaction.interceptor;
    2.  
    3. /**
    4.  * 继承AbstractBeanFactoryPointcutAdvisor，重写了getPointcut()方法。即当前Advisor包含了事务需要的advice以及pointcut
    5.  * 1、维护TransactionAttributeSource对象；
    6.  * 2、创建一个TransactionAttributeSourcePointcut，重写getTransactionAttributeSource()，返回TransactionAttributeSource对
    7.  * 象给TransactionAttributeSourcePointcut，进行方法事务注解判断
    8.  */
    9. @SuppressWarnings("serial")
    10. public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {
    11.  
    12. 	// 在ProxyTransactionManagementConfiguration类中的transactionAdvisor()方法，
    13. 	// 设置transactionAttributeSource为AnnotationTransactionAttributeSource
    14. 	@Nullable
    15. 	private TransactionAttributeSource transactionAttributeSource;
    16.  
    17. 	private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
    18. 		@Override
    19. 		@Nullable
    20. 		protected TransactionAttributeSource getTransactionAttributeSource() {
    21. 			return transactionAttributeSource;
    22. 		}
    23. 	};
    24.  
    25. 	public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {
    26. 		this.transactionAttributeSource = transactionAttributeSource;
    27. 	}
    28.  
    29. 	public void setClassFilter(ClassFilter classFilter) {
    30. 		this.pointcut.setClassFilter(classFilter);
    31. 	}
    32.  
    33. 	@Override
    34. 	public Pointcut getPointcut() {
    35. 		return this.pointcut;
    36. 	}
    37.  
    38. }

    在BeanFactoryTransactionAttributeSourceAdvisor切面中，切点为自定义的实现抽象类TransactionAttributeSourcePointcut的对象，抽象方法getTransactionAttributeSource()返回的TransactionAttributeSource对象为ProxyTransactionManagementConfiguration的transactionAdvisor()方法传入的AnnotationTransactionAttributeSource对象。

    TransactionAttributeSourcePointcut

    TransactionAttributeSourcePointcut的源码如下：

    1. package org.springframework.transaction.interceptor;
    2.  
    3. /**
    4.  * 抽象类，继承StaticMethodMatcherPointcut，属于静态的方法匹配。在方法匹配中，通过抽象方法getTransactionAttributeSource()获
    5.  * 取TransactionAttributeSource对象，然后执行TransactionAttributeSource.getTransactionAttribute()，判断方法是否有事务注解，
    6.  * 如果有，表示匹配；没有则不匹配
    7.  */
    8. @SuppressWarnings("serial")
    9. abstract class TransactionAttributeSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {
    10.  
    11. 	@Override
    12. 	public boolean matches(Method method, @Nullable Class targetClass) {
    13. 		if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
    14. 			return false;
    15. 		}
    16. 		// 返回AnnotationTransactionAttributeSource
    17. 		TransactionAttributeSource tas = getTransactionAttributeSource();
    18. 		// 在AnnotationTransactionAttributeSource的getTransactionAttribute()方法中，
    19. 		// 获取方法添加的@Transactional注解的信息，如果没有添加@Transactional注解，返回null
    20. 		return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
    21. 	}
    22.  
    23. 	@Override
    24. 	public boolean equals(Object other) {
    25. 		if (this == other) {
    26. 			return true;
    27. 		}
    28. 		if (!(other instanceof TransactionAttributeSourcePointcut)) {
    29. 			return false;
    30. 		}
    31. 		TransactionAttributeSourcePointcut otherPc = (TransactionAttributeSourcePointcut) other;
    32. 		return ObjectUtils.nullSafeEquals(getTransactionAttributeSource(), otherPc.getTransactionAttributeSource());
    33. 	}
    34.  
    35. 	@Override
    36. 	public int hashCode() {
    37. 		return TransactionAttributeSourcePointcut.class.hashCode();
    38. 	}
    39.  
    40. 	@Override
    41. 	public String toString() {
    42. 		return getClass().getName() + ": " + getTransactionAttributeSource();
    43. 	}
    44.  
    45. 	/**
    46. 	 * 抽象方法，获得一个TransactionAttributeSource对象
    47. 	 * @return
    48. 	 */
    49. 	@Nullable
    50. 	protected abstract TransactionAttributeSource getTransactionAttributeSource();
    51.  
    52. }

    TransactionAttributeSourcePointcut继承StaticMethodMatcherPointcut，StaticMethodMatcherPointcut的类匹配默认为ClassFilter.TRUE，即匹配所有的类。

    当Spring中的bean对象声明之后，都会调用BeanFactoryTransactionAttributeSourceAdvisor切面，遍历bean的方法，执行切点的matches(Method method, @Nullable Class targetClass)方法，该方法执行如下：

    6.1）调用getTransactionAttributeSource()，获取一个TransactionAttributeSource。此处为AnnotationTransactionAttributeSource对象；

    6.2）因为TransactionAttributeSource对象不为空，所以执行TransactionAttributeSource的getTransactionAttribute()方法，该方法会执行AnnotationTransactionAttributeSource的父类AbstractFallbackTransactionAttributeSource的getTransactionAttribute()方法，如果方法有返回值，则matches()方法返回true。对应的bean创建代理类，并添加Advisor中的拦截器，即添加TransactionInterceptor；

    在该方法中，最终会调用子类AnnotationTransactionAttributeSource的determineTransactionAttribute()方法，遍历事务的解析器，从解析器中获取事务属性信息；结合1）中的描述，会解析org.springframework.transaction.annotation包和javax.transaction包下的@Transactional注解。如果没有@Transactional注解，getTransactionAttribute()最终返回null。matches()会返回false，即不支持，如果有注解，则返回true。对应的bean创建代理类，并添加Advisor中的拦截器，即添加TransactionInterceptor；

    AnnotationTransactionAttributeSource

    AnnotationTransactionAttributeSource的相关源码如下：

    1. package org.springframework.transaction.annotation;
    2.  
    3. /**
    4.  * 继承AbstractFallbackTransactionAttributeSource，对外提供了getTransactionAttribute()方法。该方法返回某个方法的事务注解信息
    5.  * 1、添加不同类型的事务注解解析器，用于解析注解信息。支撑jta、ejb和spring的事务
    6.  */
    7. @SuppressWarnings("serial")
    8. public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource
    9. 		implements Serializable {
    10.  
    11. 	/** 判断包中是否有javax.transaction.Transactional这个类，即项目中是否有对应的包。如果有，则需要添加对应的事务解析器 */
    12. 	private static final boolean jta12Present = ClassUtils.isPresent(
    13. 			"javax.transaction.Transactional", AnnotationTransactionAttributeSource.class.getClassLoader());
    14.  
    15. 	/** 判断包中是否有javax.ejb.TransactionAttribute这个类，即项目中是否有对应的包。如果有，则需要添加对应的事务解析器 */
    16. 	private static final boolean ejb3Present = ClassUtils.isPresent(
    17. 			"javax.ejb.TransactionAttribute", AnnotationTransactionAttributeSource.class.getClassLoader());
    18.  
    19. 	/** 标记是否只有public方法才可以添加事务，默认为true */
    20. 	private final boolean publicMethodsOnly;
    21.  
    22. 	private final Set annotationParsers;
    23.  
    24. 	public AnnotationTransactionAttributeSource() {
    25. 		this(true);
    26. 	}
    27.  
    28. 	/**
    29. 	 * 设置publicMethodsOnly的值，并添加事务的注解解析器集合
    30. 	 */
    31. 	public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
    32. 		this.publicMethodsOnly = publicMethodsOnly;
    33. 		if (jta12Present || ejb3Present) {
    34. 			this.annotationParsers = new LinkedHashSet<>(4);
    35. 			// 添加spring的Transactional注解解析器
    36. 			this.annotationParsers.add(new SpringTransactionAnnotationParser());
    37. 			// 根据条件，添加jta和ejb3两种事务的注解解析器
    38. 			if (jta12Present) {
    39. 				this.annotationParsers.add(new JtaTransactionAnnotationParser());
    40. 			}
    41. 			if (ejb3Present) {
    42. 				this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
    43. 			}
    44. 		}
    45. 		else {
    46. 			// 如果不支持jta和ejb3两种注解的事务，则只添加spring的Transactional注解解析器
    47. 			this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
    48. 		}
    49. 	}
    50.  
    51. 	/**
    52. 	 * 调用determineTransactionAttribute()方法，从类中查找事务注解信息
    53. 	 */
    54. 	@Override
    55. 	@Nullable
    56. 	protected TransactionAttribute findTransactionAttribute(Class clazz) {
    57. 		return determineTransactionAttribute(clazz);
    58. 	}
    59.  
    60. 	/**
    61. 	 * 调用determineTransactionAttribute()方法，从方法中查找事务注解信息
    62. 	 */
    63. 	@Override
    64. 	@Nullable
    65. 	protected TransactionAttribute findTransactionAttribute(Method method) {
    66. 		return determineTransactionAttribute(method);
    67. 	}
    68.  
    69. 	/**
    70. 	 * 确定事务属性。遍历事务解析器集合，对当前element进行解析，如果能够正常解析，则返回对应
    71. 	 * 的TransactionAttribute【RuleBasedTransactionAttribute对象】；否则返回null
    72. 	 */
    73. 	@Nullable
    74. 	protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
    75. 		for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
    76. 			TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
    77. 			if (attr != null) {
    78. 				return attr;
    79. 			}
    80. 		}
    81. 		return null;
    82. 	}
    83.  
    84. }

    在AnnotationTransactionAttributeSource构造方法中，会添加SpringTransactionAnnotationParser和JtaTransactionAnnotationParser事务注解解析器。

    7.1 SpringTransactionAnnotationParser

    SpringTransactionAnnotationParser的源码如下：

    1. package org.springframework.transaction.annotation;
    2. /**
    3.  * 实现TransactionAnnotationParser，解析org.springframework.transaction.annotation.Transactional的注解信息，
    4.  * 返回一个RuleBasedTransactionAttribute对象
    5.  */
    6. @SuppressWarnings("serial")
    7. public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
    8.  
    9. 	/**
    10. 	 * 解析@Transaction注解，获取一个TransactionAttribute对象
    11. 	 */
    12. 	@Override
    13. 	@Nullable
    14. 	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
    15. 		// 在所提供的element上方的注释层次结构中查找Transactional的第一个注释，
    16. 		// 并将该注释的属性与注释层次结构较低级别注释中的匹配的attribute合并
    17. 		AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
    18. 				element, Transactional.class, false, false);
    19. 		// 解析Transactional注解，返回一个RuleBasedTransactionAttribute对象
    20. 		if (attributes != null) {
    21. 			return parseTransactionAnnotation(attributes);
    22. 		}
    23. 		else {
    24. 			return null;
    25. 		}
    26. 	}
    27.  
    28. 	public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
    29. 		return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
    30. 	}
    31.  
    32. 	/**
    33. 	 * 从注解属性对象中，获取事务注解相关属性信息，封装成RuleBasedTransactionAttribute对象
    34. 	 */
    35. 	protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
    36. 		// 根据注解的信息，创建一个RuleBasedTransactionAttribute对象
    37. 		RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
    38.  
    39. 		Propagation propagation = attributes.getEnum("propagation");
    40. 		rbta.setPropagationBehavior(propagation.value());
    41. 		Isolation isolation = attributes.getEnum("isolation");
    42. 		rbta.setIsolationLevel(isolation.value());
    43. 		rbta.setTimeout(attributes.getNumber("timeout").intValue());
    44. 		rbta.setReadOnly(attributes.getBoolean("readOnly"));
    45. 		rbta.setQualifier(attributes.getString("value"));
    46.  
    47. 		// 添加回滚规则
    48. 		List rollbackRules = new ArrayList<>();
    49. 		for (Class rbRule : attributes.getClassArray("rollbackFor")) {
    50. 			rollbackRules.add(new RollbackRuleAttribute(rbRule));
    51. 		}
    52. 		for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
    53. 			rollbackRules.add(new RollbackRuleAttribute(rbRule));
    54. 		}
    55. 		for (Class rbRule : attributes.getClassArray("noRollbackFor")) {
    56. 			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
    57. 		}
    58. 		for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
    59. 			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
    60. 		}
    61. 		rbta.setRollbackRules(rollbackRules);
    62.  
    63. 		return rbta;
    64. 	}
    65.  
    66.  
    67. 	@Override
    68. 	public boolean equals(Object other) {
    69. 		return (this == other || other instanceof SpringTransactionAnnotationParser);
    70. 	}
    71.  
    72. 	@Override
    73. 	public int hashCode() {
    74. 		return SpringTransactionAnnotationParser.class.hashCode();
    75. 	}
    76.  
    77. }

    SpringTransactionAnnotationParser用于解析org.springframework.transaction.annotation包下的@Transactional的注解信息。

    7.2 JtaTransactionAnnotationParser

    JtaTransactionAnnotationParser的源码如下：

    1. package org.springframework.transaction.annotation;
    2.  
    3. /**
    4.  * 实现TransactionAnnotationParser，用于解析javax.transaction.Transactional注解的事务属性。返回一个RuleBasedTransactionAttribute对象
    5.  */
    6. @SuppressWarnings("serial")
    7. public class JtaTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
    8.  
    9. 	/**
    10. 	 * 判断是否有javax.transaction.Transactional，如果有，则进行注解解析【解析传播行为，回滚的异常类、不回滚的异常类设置回滚规则】，
    11. 	 * 返回一个RuleBasedTransactionAttribute对象
    12. 	 * @param element
    13. 	 * @return
    14. 	 */
    15. 	@Override
    16. 	@Nullable
    17. 	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
    18. 		AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(
    19. 				element, javax.transaction.Transactional.class);
    20. 		if (attributes != null) {
    21. 			return parseTransactionAnnotation(attributes);
    22. 		}
    23. 		else {
    24. 			return null;
    25. 		}
    26. 	}
    27.  
    28. 	public TransactionAttribute parseTransactionAnnotation(javax.transaction.Transactional ann) {
    29. 		return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
    30. 	}
    31.  
    32. 	protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
    33. 		RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
    34.  
    35. 		// 通过注解的value设定传播行为。默认为REQUIRED
    36. 		rbta.setPropagationBehaviorName(
    37. 				RuleBasedTransactionAttribute.PREFIX_PROPAGATION + attributes.getEnum("value").toString());
    38.  
    39. 		// 根据设置的回滚的异常类，添加回滚规则
    40. 		List rollbackRules = new ArrayList<>();
    41. 		for (Class rbRule : attributes.getClassArray("rollbackOn")) {
    42. 			rollbackRules.add(new RollbackRuleAttribute(rbRule));
    43. 		}
    44. 		// 根据设置的不回滚的异常类，添加回滚规则，定义为不回滚
    45. 		for (Class rbRule : attributes.getClassArray("dontRollbackOn")) {
    46. 			rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
    47. 		}
    48. 		rbta.setRollbackRules(rollbackRules);
    49.  
    50. 		return rbta;
    51. 	}
    52.  
    53.  
    54. 	@Override
    55. 	public boolean equals(Object other) {
    56. 		return (this == other || other instanceof JtaTransactionAnnotationParser);
    57. 	}
    58.  
    59. 	@Override
    60. 	public int hashCode() {
    61. 		return JtaTransactionAnnotationParser.class.hashCode();
    62. 	}
    63.  
    64. }

    JtaTransactionAnnotationParser用于解析javax.transaction包下的@Transactional注解。

    在6.2）中调用AnnotationTransactionAttributeSource的getTransactionAttribute()，最终会调用AnnotationTransactionAttributeSource的determineTransactionAttribute()方法，遍历事务注解的解析器，从解析器中获取事务属性信息。只要方法中添加了org.springframework.transaction.annotation包或javax.transaction包的@Transactional注解，则能够正常获取事务属性信息。

    小结

    限于篇幅，本篇先分享到这里。以下做一个小结：

    1）在SpringBoot框架的项目，项目启动时，会自动开启@EnableTransactionManagement注解，从而自动添加BeanFactoryTransactionAttributeSourceAdvisor切面，添加TransactionAttributeSourcePointcut切点。该切点的ClassFilter为ClassFilter.TRUE，即过滤所有的类。

    2）Spring的bean自动注入时，会执行BeanFactoryTransactionAttributeSourceAdvisor切面，遍历bena的方法，执行TransactionAttributeSourcePointcut的matches()。在该方法中，会执行AnnotationTransactionAttributeSource的getTransactionAttribute()方法，判断方法是否添加了org.springframework.transaction.annotation包或javax.transaction包下的@Transactional注解，如果有，则bean的代理类中添加TransactionInterceptor拦截器；

    关于本篇内容你有什么自己的想法或独到见解，欢迎在评论区一起交流探讨下吧。

  • 相关阅读:
    第二章第三节：字符串常规操作
    简述Mysql中索引类型及对数据库的性能的影响
    5- 进入docker 打包的文件，查看内部文件
    Java 复习笔记 - 集合进阶篇：List集合
    pv操作题目笔记
    初识树结构和二叉树
    发布Android库至MavenCentral详解
    【Linux】实时线程的优先级设置、调度和抢占
    IF：14+ “冒烟型”骨髓瘤的分子组成突显了导致多发性骨髓瘤的进化途径
    C++ Reference: Standard C++ Library reference: C Library: cmath: rint
  • 原文地址：https://blog.csdn.net/JingAi_jia917/article/details/139475205