服务器之家

服务器之家 > 正文

Spring事务执行流程及如何创建事务

时间:2021-08-27 11:08     来源/作者:柠檬时间

接上节内容,Spring事务执行原理通过创建一个BeanFactoryTransactionAttributeSourceAdvisor,并把TransactionInterceptor注入进去,而TransactionInterceptor实现了Advice接口。而Spring Aop在Spring中会把Advisor中的Advice转换成拦截器链,然后调用。

执行流程

  1. 获取对应事务属性,也就是获取@Transactional注解上的属性
  2. 获取TransactionManager,常用的如DataSourceTransactionManager事务管理
  3. 在目标方法执行前获取事务信息并创建事务
  4. 回调执行下一个调用链
  5. 一旦出现异常,尝试异常处理,回滚事务
  6. 提交事务

具体分析

获取对应事务属性,具体代码执行流程如下:

?
1
final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
protected TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {
 // Don't allow no-public methods as required.
 //1. allowPublicMethodsOnly()返回true,只能是公共方法
 if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
  return null;
 }
 
 // Ignore CGLIB subclasses - introspect the actual user class.
 Class<?> userClass = ClassUtils.getUserClass(targetClass);
 // 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代表实现类的方法
 Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
 // If we are dealing with method with generic parameters, find the original method.
 //处理泛型
 specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
 
 // 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;
}

getTransactionAttributeSource()获得的对象是在ProxyTransactionManagementConfiguration创建bean时注入的AnnotationTransactionAttributeSource对象。 AnnotationTransactionAttributeSource中getTransactionAttributeSource方法主要逻辑交给了computeTransactionAttribute方法,所以我们直接看computeTransactionAttribute代码实现。

computeTransactionAttribute方法执行的逻辑是:

  1. 判断是不是只运行公共方法,在AnnotationTransactionAttributeSource构造方法中传入true。若方法不是公共方法,则返回null。
  2. 得到具体的方法,method方法可能是接口方法或者泛型方法。
  3. 查看方法上是否存在事务
  4. 查看方法所在类上是否存在事务
  5. 查看接口的方法是否存在事务,查看接口上是否存在事务。

所以如果一个方法上用了@Transactional,类上和接口上也用了,以方法上的为主,其次才是类,最后才到接口。

获取TransactionManager,具体代码执行流程如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
protected PlatformTransactionManager determineTransactionManager(TransactionAttribute txAttr) {
 // Do not attempt to lookup tx manager if no tx attributes are set
 if (txAttr == null || this.beanFactory == null) {
  return getTransactionManager();
 }
 String qualifier = txAttr.getQualifier();
 if (StringUtils.hasText(qualifier)) {
  return determineQualifiedTransactionManager(qualifier);
 }
 else if (StringUtils.hasText(this.transactionManagerBeanName)) {
  return determineQualifiedTransactionManager(this.transactionManagerBeanName);
 }
 else {
  //常用的会走到这里
  PlatformTransactionManager defaultTransactionManager = getTransactionManager();
  if (defaultTransactionManager == null) {
   defaultTransactionManager = this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
   if (defaultTransactionManager == null) {
    //从beanFactory获取PlatformTransactionManager类型的bean
    defaultTransactionManager = this.beanFactory.getBean(PlatformTransactionManager.class);
    this.transactionManagerCache.putIfAbsent(
      DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
   }
  }
  return defaultTransactionManager;
 }
}
?
1
2
3
4
@Bean
public PlatformTransactionManager txManager() {
 return new DataSourceTransactionManager(dataSource());
}

创建事务主要两部分:

  • 获取事务状态
  • 构建事务信息

获取事务状态

代码如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@Override
 public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
 //1.获取事务
 Object transaction = doGetTransaction();
 
 // Cache debug flag to avoid repeated checks.
 boolean debugEnabled = logger.isDebugEnabled();
 
 if (definition == null) {
  // Use defaults if no transaction definition given.
  definition = new DefaultTransactionDefinition();
 }
 
 //判断当前线程是否存在事务,判断依据为当前线程记录连接不为空且连接中的(connectionHolder)中的transactionActive属性不为空
 if (isExistingTransaction(transaction)) {
  // Existing transaction found -> check propagation behavior to find out how to behave.
  return handleExistingTransaction(definition, transaction, debugEnabled);
 }
 
 // Check definition settings for new transaction.
 //事务超时设置验证
 if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
  throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
 }
 
 // No existing transaction found -> check propagation behavior to find out how to proceed.
 //如果当前线程不存在事务,但是@Transactional却声明事务为PROPAGATION_MANDATORY抛出异常
 if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
  throw new IllegalTransactionStateException(
    "No existing transaction found for transaction marked with propagation 'mandatory'");
 }
 //如果当前线程不存在事务,PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED都得创建事务
 else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
   definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
   definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
  //空挂起
  SuspendedResourcesHolder suspendedResources = suspend(null);
  if (debugEnabled) {
   logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
  }
  try {
   //默认返回true
   boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
   //构建事务状态
   DefaultTransactionStatus status = newTransactionStatus(
     definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
   //构造transaction、包括设置connectionHolder、隔离级别、timeout
   //如果是新事务,绑定到当前线程
   doBegin(transaction, definition);
   //新事务同步设置,针对当前线程
   prepareSynchronization(status, definition);
   return status;
  }
  catch (RuntimeException ex) {
   resume(null, suspendedResources);
   throw ex;
  }
  catch (Error err) {
   resume(null, suspendedResources);
   throw err;
  }
 }
 else {
  // Create "empty" transaction: no actual transaction, but potentially synchronization.
  if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
   logger.warn("Custom isolation level specified but no actual transaction initiated; " +
     "isolation level will effectively be ignored: " + definition);
  }
  //声明事务是PROPAGATION_SUPPORTS
  boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
  return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
 }
}

构建事务信息

  1. 获取事务,创建对应的事务实例,这里使用的是DataSourceTransactionManager中的doGetTransaction方法,创建基于JDBC的事务实例,如果当前线程中存在关于dataSoruce的连接,那么直接使用。这里有一个对保存点的设置,是否开启允许保存点取决于是否设置了允许嵌入式事务。DataSourceTransactionManager默认是开启的。
  2. 如果当先线程存在事务,则转向嵌套的事务处理。是否存在事务在DataSourceTransactionManager的isExistingTransaction方法中
  3. 事务超时设置验证
  4. 事务PropagationBehavior属性的设置验证
  5. 构建DefaultTransactionStatus。
  6. 完善transaction,包括设置connectionHolder、隔离级别、timeout,如果是新事务,绑定到当前线程
  7. 将事务信息记录在当前线程中

以上就是Spring事务执行流程及如何创建事务的详细内容,更多关于Spring事务执行流程及如何创建的资料请关注服务器之家其它相关文章!

原文链接:https://segmentfault.com/a/1190000039355506

相关文章

热门资讯

yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全
2020微信伤感网名听哭了 让对方看到心疼的伤感网名大全 2019-12-26
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总
苹果12mini价格表官网报价 iPhone12mini全版本价格汇总 2020-11-13
2021年耽改剧名单 2021要播出的59部耽改剧列表
2021年耽改剧名单 2021要播出的59部耽改剧列表 2021-03-05
返回顶部