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

，spring事务执行原理通过创建一个beanfactorytransactionattributesourceadvisor，并把transactioninterceptor注入进去，而transactioninterceptor实现了advice接口。而spring aop在spring中会把advisor中的advice转换成拦截器链，然后调用。

执行流程

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

具体分析

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

final transactionattribute txattr = gettransactionattributesource().gettransactionattribute(method, targetclass);

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，具体代码执行流程如下：

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;
 }
}

@bean
public platformtransactionmanager txmanager() {
 return new datasourcetransactionmanager(datasource());
}

创建事务主要两部分：

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

获取事务状态

代码如下：

@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事务执行流程及如何创建的资料请关注其它相关文章！