接上节内容 ，Spring事务执行原理通过创建一个BeanFactoryTransactionAttributeSourceAdvisor，并把TransactionInterceptor注入进去，而TransactionInterceptor实现了Advice接口。而Spring Aop在Spring中会把Advisor中的Advice转换成拦截器链，然后调用。
执行流程
获取对应事务属性，也就是获取@Transactional注解上的属性 获取TransactionManager，常用的如DataSourceTransactionManager事务管理 在目标方法执行前获取事务信息并创建事务 回调执行下一个调用链 一旦出现异常，尝试异常处理，回滚事务 提交事务
具体分析
获取对应事务属性，具体代码执行流程如下：
|
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方法执行的逻辑是：
判断是不是只运行公共方法，在AnnotationTransactionAttributeSource构造方法中传入true。若方法不是公共方法，则返回null。 得到具体的方法，method方法可能是接口方法或者泛型方法。 查看方法上是否存在事务 查看方法所在类上是否存在事务 查看接口的方法是否存在事务，查看接口上是否存在事务。所以如果一个方法上用了@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 ); } } |
构建事务信息
获取事务，创建对应的事务实例，这里使用的是DataSourceTransactionManager中的doGetTransaction方法，创建基于JDBC的事务实例，如果当前线程中存在关于dataSoruce的连接，那么直接使用。这里有一个对保存点的设置，是否开启允许保存点取决于是否设置了允许嵌入式事务。DataSourceTransactionManager默认是开启的。 如果当先线程存在事务，则转向嵌套的事务处理。是否存在事务在DataSourceTransactionManager的isExistingTransaction方法中 事务超时设置验证 事务PropagationBehavior属性的设置验证 构建DefaultTransactionStatus。 完善transaction，包括设置connectionHolder、隔离级别、timeout，如果是新事务，绑定到当前线程 将事务信息记录在当前线程中以上就是Spring事务执行流程及如何创建事务的详细内容，更多关于Spring事务执行流程及如何创建的资料请关注其它相关文章！
原文链接：https://segmentfault.com/a/1190000039355506
查看更多关于Spring事务执行流程及如何创建事务的详细内容...