1.注册核心的组件：Advisor
<tx:annotation-driven>
http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler
TxNamespaceHandler#init
public void init() {
registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
}
AnnotationDrivenBeanDefinitionParser#parse()解析标签tx:annotation-driven
/**
* Parses the {@code <tx:annotation-driven/>} tag. Will
* {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
* with the container as necessary.
*/
@Override
@Nullable
public BeanDefinition parse(Element element, ParserContext parserContext) {
// element = <tx:annotation-driven transaction-manager="transactionManager" />
// 向Spring容器注册了一个 BD -> TransactionalEventListenerFactory.class
registerTransactionalEventListenerFactory(parserContext);
String mode = element.getAttribute("mode");
if ("aspectj".equals(mode)) {
// mode="aspectj"
registerTransactionAspect(element, parserContext);
if (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader())) {
registerJtaTransactionAspect(element, parserContext);
}
}
else {
// 我们要分析的源码入口：
// mode="proxy"
AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
}
return null;
}
核心在AopAutoProxyConfigurer# configureAutoProxyCreator
private static class AopAutoProxyConfigurer {
public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
// 向Spring容器注册 BD -> InfrastructureAdvisorAutoProxyCreator.class ，BD的名称：
// org.springframework.aop.config.internalAutoProxyCreator
AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
// 事务切面的名称：
// org.springframework.transaction.config.internalTransactionAdvisor
String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
// 条件成立：说明Spring容器内 不存在 事务切面 的 BD 信息..走if内的逻辑，注册 事务切面 相关的逻辑。
if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
Object eleSource = parserContext.extractSource(element);
// 创建一个BD->AnnotationTransactionAttributeSource.class ，并给BD起了名称：annotationTransactionAttributeSource#1
// Create the TransactionAttributeSource definition.
RootBeanDefinition sourceDef = new RootBeanDefinition(
"org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
sourceDef.setSource(eleSource);
sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
// 创建一个BD->TransactionInterceptor.class (事务增强器)
// Create the TransactionInterceptor definition.
RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
interceptorDef.setSource(eleSource);
interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// 向BD添加 Properties： transactionManagerBeanName -> transactionManager
// 添加这个properties 有什么作用？ Spring容器创建 TransactionInterceptor 实例时，会向该实例 注入 transactionManagerBeanName 属性值。
registerTransactionManager(element, interceptorDef);
// 向BD添加 Properties： transactionAttributeSource -> new RuntimeBeanReference(sourceName)
// 添加这个properties 有什么作用？
// Spring容器创建 TransactionInterceptor 实例时，会向该实例 注入 annotationTransactionAttributeSource 对象。
interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
// 创建一个BD->BeanFactoryTransactionAttributeSourceAdvisor.class (事务增强器)
// Create the TransactionAttributeSourceAdvisor definition.
RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
advisorDef.setSource(eleSource);
advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// 向BD添加 Properties： transactionAttributeSource -> new RuntimeBeanReference(sourceName)
// 添加这个properties 有什么作用？
// Spring容器创建 BeanFactoryTransactionAttributeSourceAdvisor 实例时，会向该实例 注入 annotationTransactionAttributeSource 对象。
advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
// 向BD添加 Properties： adviceBeanName -> interceptorName
// 添加这个properties 有什么作用？ Spring容器创建 BeanFactoryTransactionAttributeSourceAdvisor 实例时，会向该实例 注入 interceptorName .
advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
if (element.hasAttribute("order")) {
advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
}
parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);
CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
parserContext.registerComponent(compositeDef);
}
}
}
该方法向Spring容器注册了四个BD：
核心是两个，一个是InfrastructureAdvisorAutoProxyCreator，用来对@Transactional注解的类创建动态代理；一个是BeanFactoryTransactionAttributeSourceAdvisor，包含切点和增强。
2.创建代理对象（参考Spring AOP）
InfrastructureAdvisorAutoProxyCreator和AnnotationAwareAspectJAutoProxyCreator类层次结构图基本一模一样：
核心方法在AbstractAutoProxyCreator#postProcessAfterInitialization
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
//cacheKey 大部分情况下 都是 beanName
Object cacheKey = getCacheKey(bean.getClass(), beanName);
//防止重复代理某个bean实例。
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// AOP操作入口
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 条件一般不成立，因为咱们很少使用TargetSourceCreator 去创建对象。 BeforeInstantiation阶段。
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// 条件成立：说明当前beanName对应的对象 不需要被增强处理，判断是在 BeforeInstantiation阶段 做的。
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
//条件一：isInfrastructureClass 判断当前bean类型是否是 基础框架 的类型，这个类型的实例 不能被增强
//条件二：shouldSkip 判断当前beanName是否是 .ORIGINAL 结尾，如果是这个结尾 则跳过增强逻辑。
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// Create proxy if we have advice.
// 查找适合当前bean实例Class的通知
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
// 条件成立：说明 上面方法 有查询到 适合当前class的通知
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
//创建代理对象，根据查询到的 通知 ！
// 参数一：目标对象
// 参数二：beanName
// 参数三：匹配当前 目标对象 clazz 的Advisor数据。
// 参数四：目标对象。
Object proxy = createProxy(
bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
// 保存代理对象类型。
this.proxyTypes.put(cacheKey, proxy.getClass());
//返回代理对象
return proxy;
}
//执行到这里，说明当前bean不需要被增强。
this.advisedBeans.put(cacheKey, Boolean.FALSE);
//直接返回原实例。
return bean;
}
查找匹配的Advisor，会调用至如下方法AopUtils#canApply(Advisor, Class<?>, boolean)：
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
// 绝大部分情况 是这个分支，因为咱们创建的 advisor 是 InstantiationModelAwarePointcutAdvisorImpl 类型。
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
// 判断当前pointcut 是否 匹配 当前clazz
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
// It doesn't have a pointcut so we assume it applies.
return true;
}
}
来看看BeanFactoryTransactionAttributeSourceAdvisor
可以看出其pointcut是TransactionAttributeSourcePointcut，包含了transactionAttributeSource，也即AnnotationTransactionAttributeSource。
public class BeanFactoryTransactionAttributeSourceAdvisor extends AbstractBeanFactoryPointcutAdvisor {
@Nullable
private TransactionAttributeSource transactionAttributeSource;
private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
@Override
@Nullable
protected TransactionAttributeSource getTransactionAttributeSource() {
return transactionAttributeSource;
}
};
重载的canApply：
- 1）每一个实例化之后的bean都会先通过ClassFilter.matches方法进行匹配，在TransactionAttributeSourcePointcut的构造器中调用了setClassFilter方法，将ClassFilter配置为一个TransactionAttributeSourceClassFilter。
- 2）如果ClassFilter匹配通过，那么会获取bean的全部方法并且通过MethodMatcher.matches对方法一一进行匹配。最终，如果至少有一个方法能够被增强，那么表示当前bean实例就能被当然通知器，也就可以创建代理对象。
public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
Assert.notNull(pc, "Pointcut must not be null");
// 条件成立：clazz不满足 切点定义。因为后面是 判断 method 是否匹配的 逻辑... clazz都不匹配 ，后面逻辑不用看了..
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
// Spring 事务相关注释：
// transactionAttributeSourcePointcut .getMethodMatcher() => this transactionAttributeSourcePointcut
// 获取 方法匹配器
MethodMatcher methodMatcher = pc.getMethodMatcher();
// 因为 TrueMethodMatcher 方法匹配器 匹配所有方法，所以 直接返回true
if (methodMatcher == MethodMatcher.TRUE) {
// No need to iterate the methods if we're matching any method anyway...
return true;
}
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
// 保存 当前目标 对象clazz + 包括自身实现的接口 + 目标对象 父类 父父类.... 的接口
Set<Class<?>> classes = new LinkedHashSet<>();
// 这个if 就是确保 classes 内存储的数据 包括 目标对象的 clazz ，而不是 代理类clazz。
if (!Proxy.isProxyClass(targetClass)) {
classes.add(ClassUtils.getUserClass(targetClass));
}
//包括自身实现的接口 + 目标对象 父类 父父类.... 的接口
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
// 整个for循环 会检查 当前目标clazz 上级+自身方法 接口 的所有方法 看看是否会被 方法匹配器 匹配，如果有一个方法匹配成功，就说明
// 目标clazz 需要被 AOP 代理增强！
for (Class<?> clazz : classes) {
// 获取当前clazz内定义的method
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
// 执行到这，说明当前clazz 内 没有方法被匹配成功..就不需要创建代理clazz了。
return false;
}
2.1 TransactionAttributeSourcePointcut
来看看TransactionAttributeSourcePointcut
BeanFactoryTransactionAttributeSourceAdvisor就是靠此对象来判断某个bean是否可以被此事务通知器增强，简单的说就是判断当前bean是否可以应用这一个事务。
类匹配（基本上普通class都会返回true）：
- 1）如果当前bean的类型属于TransactionalProxy、TransactionManager或者PersistenceExceptionTranslator，这些类型要么表示当前bean属于已经进行了手动事务代理，要么表示当前bean属于事务管理的基础bean，这些类的实例的方法不应该进行Spring事务的代理。
- 2）如果不是上面那些类型的bean实例，就通过设置的TransactionAttributeSource来判断。如果TransactionAttributeSource为null，或者isCandidateClass方法返回true，那么表示当前bean的class允许继续匹配方法，否则表示不会继续匹配，即当前bean实例不会进行事务代理。
private class TransactionAttributeSourceClassFilter implements ClassFilter {
@Override
public boolean matches(Class<?> clazz) {
if (TransactionalProxy.class.isAssignableFrom(clazz) ||
TransactionManager.class.isAssignableFrom(clazz) ||
PersistenceExceptionTranslator.class.isAssignableFrom(clazz)) {
return false;
}
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.isCandidateClass(clazz));
}
}
AnnotationTransactionAttributeSource#isCandidateClass
public boolean isCandidateClass(Class<?> targetClass) {
for (TransactionAnnotationParser parser : this.annotationParsers) {
if (parser.isCandidateClass(targetClass)) {
return true;
}
}
return false;
}
SpringTransactionAnnotationParser#isCandidateClass
public boolean isCandidateClass(Class<?> targetClass) {
return AnnotationUtils.isCandidateClass(targetClass, Transactional.class);
}
该方法的通用逻辑就是：如果任何一个注解的全路径名都不是以"java."开始，并且该Class全路径名以java."开始或者Class的类型为Ordered.class，那么返回false，否则其他情况都返回true。因此，基本上普通class都会返回true，表示可以进行后续的方法校验。
public static boolean isCandidateClass(Class<?> clazz, String annotationName) {
if (annotationName.startsWith("java.")) {
return true;
}
if (AnnotationsScanner.hasPlainJavaAnnotationsOnly(clazz)) {
return false;
}
return true;
}
static boolean hasPlainJavaAnnotationsOnly(Class<?> type) {
return (type.getName().startsWith("java.") || type == Ordered.class);
}
方法匹配：
TransactionAttributeSourcePointcut#matches
public boolean matches(Method method, Class<?> targetClass) {
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}
AnnotationTransactionAttributeSource父类AbstractFallbackTransactionAttributeSource#getTransactionAttribute
- 1）判断如果方法是属于Object，直接返回null，这些方法不会应用事务，比如Object的hashcode、equals……。
- 2）然后根据方法和目标类型获取缓存key，尝试从缓存中获取。如果缓存有值，判断如果是NULL_TRANSACTION_ATTRIBUTE，这是一个表示没有事务属性的常量，那么直接返回null，否则就表示存在事务属性且此前已经解析过了，直接返回缓存的值。实际上，解析过该方法和目标类型，如论有没有事务属性都会放入缓存。
- 3）到这里表示此前没有解析过该方法和目标类型，那么需要解析。调用computeTransactionAttribute那么根据当前方法和目标类型计算出TransactionAttribute。
- 4）如果计算结果为null，那么仍然存入一个表示没有事务属性的固定值NULL_TRANSACTION_ATTRIBUTE到缓存中，再次遇到时不再解析。如果不为null，说明获取到了事务属性，同样存入缓存。最后返回computeTransactionAttribute的结果。
public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
if (method.getDeclaringClass() == Object.class) {
return null;
}
// First, see if we have a cached value.
Object cacheKey = getCacheKey(method, targetClass);
TransactionAttribute cached = this.attributeCache.get(cacheKey);
if (cached != null) {
// Value will either be canonical value indicating there is no transaction attribute,
// or an actual transaction attribute.
if (cached == NULL_TRANSACTION_ATTRIBUTE) {
return null;
}
else {
return cached;
}
}
else {
// 提取 @Transactional 注解信息..
// We need to work it out.
TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
// Put it in the cache.
if (txAttr == null) {
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
}
else {
String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
if (txAttr instanceof DefaultTransactionAttribute) {
DefaultTransactionAttribute dta = (DefaultTransactionAttribute) txAttr;
dta.setDescriptor(methodIdentification);
dta.resolveAttributeStrings(this.embeddedValueResolver);
}
if (logger.isTraceEnabled()) {
logger.trace("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
}
this.attributeCache.put(cacheKey, txAttr);
}
return txAttr;
}
}
protected TransactionAttribute computeTransactionAttribute(Method method, @Nullable Class<?> targetClass) {
// Don't allow no-public methods as required.
if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
}
// 获取目标类上的 method ，因为 参数 method 可能是 接口 上定义的 method
// 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 = AopUtils.getMostSpecificMethod(method, targetClass);
// 获取目标类上method接口实现方法的 @Transactional 注解信息
// First try is the method in the target class.
TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
if (txAttr != null) {
return txAttr;
}
// 获取目标类上 @Transactional 注解信息
// 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) {
// 到接口上的 method 方法上提取 @Transactional 注解信息
// Fallback is to look at the original method.
txAttr = findTransactionAttribute(method);
if (txAttr != null) {
return txAttr;
}
// 到接口的class 上去提取 @Transactional 注解信息
// Last fallback is the class of the original method.
txAttr = findTransactionAttribute(method.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
}
// 返回null，说明 method 并没有定义 @Transactional 注解...
return null;
}
该方法用于计算给定方法和目标类型的事务属性，一般查找顺序为：执行的目标方法、对应的接口方法（如果有）、目标类、接口类（如果有），其中一个找到了就直接返回，不会继续查找。 具体逻辑如下：
- 1）首先就是对于方法的public属性进行判断，默认不允许非公共方法进行事务代理，将直接返回null。但是可以通过重写allowPublicMethodsOnly方法修改规则，子类AnnotationTransactionAttributeSource就重写了该方法，将返回publicMethodsOnly的属性值，这个值可以手动配置，但同样默认也是只有公共方法可以被设为事务性的。
- 2）获取最终要执行的目标方法，有可能参数方法表示的是一个接口的方法，我们需要找到实现类的方法，也就是最终真正调用的目标方法。但是基本上都是最终方法。
- 3）首先通过findTransactionAttribute去找直接标记在目标方法上的事务注解并解析为事务属性，如果方法上有就直接返回，不会再看类上的了事务注解了，这就是方法上的事务注解的优先级更高的原理。findTransactionAttribute方法由子类实现，findTransactionAttribute方法在查找的时候，会先查找目标方法本身的注解，然后才递归的向上会查找父级类对应方法上的注解，返回找到的第一个注解。
- 4）如果方法上没有就通过findTransactionAttribute去查找目标类上的事务注解，有就直接返回。findTransactionAttribute方法由子类实现，findTransactionAttribute方法在查找的时候，会先查找目标类本身的注解，然后才递归的向上会查找父级类上的注解，返回找到的第一个注解。
- 5）到这里表示没有在真正目标方法或者类上找到事务注解。继续判断如果最终的目标方法和当前参数方法不一致，那么在参数方法和类上查找（一般都走不到这一步）。
通过findTransactionAttribute去查找参数方法上的事务注解，如果找到了就返回。
如果还是没找到，那么最后一次尝试。通过findTransactionAttribute去查找参数方法的类上是否有事务注解，找到了就返回。 - 6）以上方法都是找不到事务注解，那么将返回null，表示当前方法不会进行事务代理。
@Override
@Nullable
protected TransactionAttribute findTransactionAttribute(Class<?> clazz) {
return determineTransactionAttribute(clazz);
}
@Override
@Nullable
protected TransactionAttribute findTransactionAttribute(Method method) {
return determineTransactionAttribute(method);
}
protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
// 需要咱们关注的parser: SpringTransactionAnnotationParser
for (TransactionAnnotationParser parser : this.annotationParsers) {
TransactionAttribute attr = parser.parseTransactionAnnotation(element);
if (attr != null) {
return attr;
}
}
return null;
}
SpringTransactionAnnotationParser
// 参数：element 可能是 method 也可能是 class
@Override
@Nullable
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
// 从 method 或者 class 上提取出来 注解信息
AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
element, Transactional.class, false, false);
if (attributes != null) {
// 解析注解 为 TransactionAttribute ，TransactionAttribute 事务注解的承载对象
return parseTransactionAnnotation(attributes);
}
else {
return null;
}
}
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());
// 从注解信息中获取 timeout
rbta.setTimeout(attributes.getNumber("timeout").intValue());
String timeoutString = attributes.getString("timeoutString");
Assert.isTrue(!StringUtils.hasText(timeoutString) || rbta.getTimeout() < 0,
"Specify 'timeout' or 'timeoutString', not both");
rbta.setTimeoutString(timeoutString);
// 从注解信息中获取 readOnly 参数
rbta.setReadOnly(attributes.getBoolean("readOnly"));
// 从注解信息中获取 value 参数，赋值到 承载对象的 qualifier 字段，表示 当前事务指定使用的 “transactionManager”
rbta.setQualifier(attributes.getString("value"));
rbta.setLabels(Arrays.asList(attributes.getStringArray("label")));
// 存放的是 rollback 条件
List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
// rollbackFor 表示事务碰到哪些指定的 exp 才进行回滚..不指定的话默认是：RuntimeException / Error 才进行回滚
for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
// rollbackForClassName：和上面类似..
for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
// noRollbackFor 表示事务碰到指定的exception 实现对象 不进行回滚，否则碰到其他的class就进行回滚..
for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
// noRollbackForClassName ：和上面一样..
for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
rbta.setRollbackRules(rollbackRules);
return rbta;
}
3.一些相关的接口和类
DataSource接口：
- DataSource是获取物理数据源连接的工厂类。
- 作为DriverManager工具的替代方案，DataSource对象是获取连接的首选方法.
- DataSource的实现类一般都通过JNDI的方式注册到框架中进行使用。
- DataSource向Spring框架屏蔽了具体数据源的差异，即当物理数据源切换时，只需要更新相关的DataSource配置值即可，不需要应用层修改代码。
- 数据库Driver都是通过DataSource对象被注册到DriverManager中，而不是由Driver直接向DriverManager注册。
- 对于获取Connection，先获得DataSource，再根据DataSource对象进行getConnection，而不是直接从DriverManager获取Connection。
ConnectionHolder如下：
TransactionAttribute如下：
Spring事务管理高层抽象主要有3个：
- PlatformTransactionManager :事务管理器(用来管理事务，包含事务的提交，回滚)。Spring本身并不支持事务实现，只是负责包装底层事务，应用底层支持什么样的事务策略，Spring就支持什么样的事务策略。
- TransactionDefinition :事务定义信息(隔离级别，传播行为，超时，只读)
- TransactionStatus :事务具体运行状态
public interface TransactionStatus{
boolean isNewTransaction(); // 是否是新的事物
boolean hasSavepoint(); // 是否有恢复点
void setRollbackOnly(); // 设置为只回滚
boolean isRollbackOnly(); // 是否为只回滚
boolean isCompleted; // 是否已完成
}
TransactionManager如下：
DataSourceTransactionObject如下：
TransactionStatus如下：
TransactionInfo如下：
4.代理对象的调用
参考https://www.jianshu.com/p/e09ff92dfa8d
动态代理调用过程JdkDynamicAopProxy#invoke：
- 1）this.advised.exposeProxy 如果是true，就要把当前这个代理对象，暴漏 到Aop上下文内
- 2）查找匹配该方法的所有增强chain：DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice
2-1）从ProxyFactory 获取出所有的Advisor
2-2）遍历Advisor，先进行类匹配，然后进行方法匹配，如果匹配，则获取Advisor中的Advice（TransactionInterceptor）加入interceptorList链
2-3）返回interceptorList - 3）联合chain包装成ReflectiveMethodInvocation，进行调用
3-1）ReflectiveMethodInvocation#proceed
根据currentInterceptorIndex逐个进行调用；
最终调用至被代理的方法；
3-2）MethodInterceptor#invoke(this)，这里的this就是ReflectiveMethodInvocation
3-3）最后反射调用至被代理的方法
上面的MethodInterceptor#invoke(this)就会调用至TransactionInterceptor#invoke()：
// 事务增强器的入口：
// invocation 非常关键，后续事务增强器 向后 驱动 拦截器链时 还要使用它
@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// Work out the target class: may be {@code null}.
// The TransactionAttributeSource should be passed the target class
// as well as the method, which may be from an interface.
// targetClass: 需要被事务增强器 增强的 目标类, invocation.getThis() => 目标对象 =》 目标类
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// Adapt to TransactionAspectSupport's invokeWithinTransaction...
// @FunctionalInterface
// protected interface InvocationCallback {
//
// @Nullable
// Object proceedWithInvocation() throws Throwable;
// }
// 相当于 new InvocationCallback {
// Object proceedWithInvocation {
// invocation.proceed();
// }
// }
// 参数1：目标方法
// 参数2：目标类
// 参数3：invocation::proceed ...看上面
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}
核心是TransactionAspectSupport#invokeWithinTransaction
protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
final InvocationCallback invocation) throws Throwable {
// If the transaction attribute is null, the method is non-transactional.
// 职责是什么？ 提取注解信息的工具..
TransactionAttributeSource tas = getTransactionAttributeSource();
// 提取@Transactional注解信息，txAttr 是注解信息的承载对象..
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 获取Spring项目配置的 事务管理器，一般情况下：DatasourceTransactionManager 实例
final TransactionManager tm = determineTransactionManager(txAttr);
// 这个if 一般不成立..就不看啦
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);
}
// 咱们使用的 DatasourceTransactionManager 属于 PlatformTransactionManager 接口实现
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
// 值：权限定类名.方法名，该值用来当做 事务名称使用
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
// 条件1：一般不成立..
// 条件2：!(ptm instanceof CallbackPreferringPlatformTransactionManager) 条件一般成立，说明当前是 声明式事务..
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// 声明式事务逻辑块
// 创建一个最上层的 事务上下文对象，集大成者，包装了事务的全部资源。
// Standard transaction demarcation with getTransaction and commit/rollback calls.
// 参数1：事务管理器
// 参数2：事务属性承载对象（解析的@transactional注解）
// 参数3：类的权限定名.方法名
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
Object retVal;
try {
// This is an around advice: Invoke the next interceptor in the chain.
// This will normally result in a target object being invoked.
// 继续驱动 方法拦截器..
retVal = invocation.proceedWithInvocation();
}
catch (Throwable ex) {
// 执行业务代码时 抛出异常，走这里。
// 处理回滚的逻辑入口
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
finally {
cleanupTransactionInfo(txInfo);
}
if (retVal != null && 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 {
// 这个if块 是编程式事务的逻辑...
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 (retVal != null && 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;
}
}
}
TransactionAttribute如下：
DataSourceTransactionManager：
这里看一下
retVal = invocation.proceedWithInvocation();
invocation是InvocationCallback
@FunctionalInterface
protected interface InvocationCallback {
@Nullable
Object proceedWithInvocation() throws Throwable;
}
// 相当于
new InvocationCallback {
Object proceedWithInvocation {
invocation.proceed();
}
}
也即 invocation.proceedWithInvocation() 会调用至MethodInvocation.proceed()也即ReflectiveMethodInvocation#proceed。
最终有ReflectiveMethodInvocation#proceed调用最终的执行sql的方法。跟Spring AOP执行过程是一模一样的。
再来看一下
protected void cleanupTransactionInfo(@Nullable TransactionInfo txInfo) {
if (txInfo != null) {
// 事务出栈
txInfo.restoreThreadLocalStatus();
}
}
TransactionInfo如下：
5.前置逻辑-创建事务
// 创建一个最上层的 事务上下文对象，集大成者，包装了事务的全部资源。
// Standard transaction demarcation with getTransaction and commit/rollback calls.
// 参数1：事务管理器
// 参数2：事务属性承载对象（解析的@transactional注解）
// 参数3：类的权限定名.方法名
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
// 参数1：事务管理器
// 参数2：事务属性承载对象（解析的@transactional注解）
// 参数3：类的权限定名.方法名
@SuppressWarnings("serial")
protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {
// If no name specified, apply method identification as transaction name.
if (txAttr != null && txAttr.getName() == null) {
// 包装txAttr，提供了 事务名称，事务名称是：类的权限定名.方法名
txAttr = new DelegatingTransactionAttribute(txAttr) {
// 类的权限定名.方法名
@Override
public String getName() {
return joinpointIdentification;
}
};
}
// 事务状态
TransactionStatus status = null;
if (txAttr != null) {
if (tm != null) {
// 通过事务管理器，根据事务属性创建 事务状态对象，事务状态 一般情况下 包装着 事务对象，当然
// status.transaction 有可能是null
// 方法上的注解为 @Transactional(propagation = NOT_SUPPORTED || propagation = NEVER)
// 该status.transaction == null.
status = tm.getTransaction(txAttr);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Skipping transactional joinpoint [" + joinpointIdentification +
"] because no transaction manager has been configured");
}
}
}
// 包装成一个上层的 事务上下文对象..
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
}
TransactionStatus如下：
TransactionAspectSupport#prepareTransactionInfo如下：
protected TransactionInfo prepareTransactionInfo(@Nullable PlatformTransactionManager tm,
@Nullable TransactionAttribute txAttr, String joinpointIdentification,
@Nullable TransactionStatus status) {
// 创建 事务上下文对象
TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
if (txAttr != null) {
// We need a transaction for this method...
if (logger.isTraceEnabled()) {
logger.trace("Getting transaction for [" + txInfo.getJoinpointIdentification() + "]");
}
// The transaction manager will flag an error if an incompatible tx already exists.
// 将事务状态对象设置到 事务上下文对象
txInfo.newTransactionStatus(status);
}
else {
// The TransactionInfo.hasTransaction() method will return false. We created it only
// to preserve the integrity of the ThreadLocal stack maintained in this class.
if (logger.isTraceEnabled()) {
logger.trace("No need to create transaction for [" + joinpointIdentification +
"]: This method is not transactional.");
}
}
// We always bind the TransactionInfo to the thread, even if we didn't create
// a new transaction here. This guarantees that the TransactionInfo stack
// will be managed correctly even if no transaction was created by this aspect.
// 事务上下文 对象 入栈/压栈
txInfo.bindToThread();
return txInfo;
}
TransactionInfo如下：
核心是AbstractPlatformTransactionManager#getTransaction
public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
throws TransactionException {
// Use defaults if no transaction definition given.
// 事务属性信息..
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
// 获取事务对象，非常关键。
Object transaction = doGetTransaction();
boolean debugEnabled = logger.isDebugEnabled();
// 条件成立：说明当前的情况是 事务重入的情况 ，
// 例如：a方法开启的事务，a方法内调用 b方法，b方法仍然加了 @Transactional 注解..的情况
if (isExistingTransaction(transaction)) {
// 线程在这之前开启了 一个事务
// 事务重入分支逻辑..
// 参数1：事务属性
// 参数2：事务对象（注意：conHolder 是上层事务 创建时 申请的资源...）
// 参数3：debugEnabled
// Existing transaction found -> check propagation behavior to find out how to behave.
return handleExistingTransaction(def, transaction, debugEnabled);
}
// 执行到这里，说明 当前线程 未绑定conHolder资源，未开启事务！！！
// Check definition settings for new transaction.
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
// No existing transaction found -> check propagation behavior to find out how to proceed.
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
// 使用当前事务，如果没有当前事务，就抛出异常
throw new IllegalTransactionStateException(
"No existing transaction found for transaction marked with propagation 'mandatory'");
}
else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已存在一个事务，加入到这个事务中，这是最常见的选择。
// PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。
// PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
// 注意 ：什么也没挂起.因为线程并没有 绑定 事务...
SuspendedResourcesHolder suspendedResources = suspend(null);
if (debugEnabled) {
logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
}
try {
// 线程未开启事务时，PROPAGATION_REQUIRED PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED 都会去开启一个新的事务
// 开启事务
return startTransaction(def, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error ex) {
resume(null, suspendedResources);
throw ex;
}
}
else {
// PROPAGATION_SUPPORTS 支持当前事务，如果没有当前事务，就以非事务方法执行。
// PROPAGATION_NOT_SUPPORTED 以非事务方式执行执行，如果当前存在事务，就把当前事务挂起。
// PROPAGATION_NEVER 以非事务方式执行操作，如果当前事务存在则抛出异常。
// Create "empty" transaction: no actual transaction, but potentially synchronization.
if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
logger.warn("Custom isolation level specified but no actual transaction initiated; " +
"isolation level will effectively be ignored: " + def);
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 参数2：transaction is null ，说明当前 事务状态 未手动开启事务 =》 线程上 未绑定任何的资源...业务程序执行时 到 datasource 再获取conn
// 获取的conn 是自动提交事务的.. 不需要 Spring 再提交事务了..
// 参数6：suspendedResources is null 说明当前 事务状态 未挂起 任何事务..当前 这个 事务 执行到 后置处理时，不需要 恢复现场..
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
}
}
DataSourceTransactionManager#doGetTransaction
protected Object doGetTransaction() {
// 创建事务对象
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
// 设置事务对象是否支持保存点..由事务管理器控制（默认不支持）
txObject.setSavepointAllowed(isNestedTransactionAllowed());
// 从threadLocal中获取 conHolder 资源，有可能拿到的是null，也有可能不是null
// 什么时候不是null？
// @Transaction
// a() {...b.b()....}
// @Transaction
// b() {....}
// 执行b方法事务增强的前置逻辑时，可以拿到 a 放进去的 conHolder 资源
// 什么时候是null？
// a方法时，拿到的就是null。
ConnectionHolder conHolder =
(ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
// 将conHolder 保存到 事务对象内..注意 参数2，传递是 false
// newConnectionHolder： 表示当前事务 是否 新分配了 conn 资源，还是和上层事务共享呢？
// 默认 这里false，表示 共享过来的...
txObject.setConnectionHolder(conHolder, false);
return txObject;
}
DataSourceTransactionObject如下：
5.1 已存在事务时的处理
// 条件成立：说明当前的情况是 事务重入的情况 ，
// 例如：a方法开启的事务，a方法内调用 b方法，b方法仍然加了 @Transactional 注解..的情况
if (isExistingTransaction(transaction)) {
// 线程在这之前开启了 一个事务
// 事务重入分支逻辑..
// 参数1：事务属性
// 参数2：事务对象（注意：conHolder 是上层事务 创建时 申请的资源...）
// 参数3：debugEnabled
// Existing transaction found -> check propagation behavior to find out how to behave.
return handleExistingTransaction(def, transaction, debugEnabled);
}
AbstractPlatformTransactionManager#handleExistingTransaction
- PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已存在一个事务，加入到这个事务中，这是最常见的选择。
- PROPAGATION_SUPPORTS 支持当前事务，如果没有当前事务，就以非事务方法执行。
- PROPAGATION_MANDATORY 使用当前事务，如果没有当前事务，就抛出异常。
- PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。
- PROPAGATION_NOT_SUPPORTED 以非事务方式执行执行，如果当前存在事务，就把当前事务挂起。
- PROPAGATION_NEVER 以非事务方式执行操作，如果当前事务存在则抛出异常。
- PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
// 参数1：事务属性
// 参数2：事务对象（注意：conHolder 是上层事务 创建时 申请的资源...）
// 参数3：debugEnabled
/**
* Create a TransactionStatus for an existing transaction.
*/
private TransactionStatus handleExistingTransaction(
TransactionDefinition definition, Object transaction, boolean debugEnabled)
throws TransactionException {
// 条件：当前方法加的 @Transactional(propagation = PROPAGATION_NEVER) 以非事务方式执行操作，如果当前事务存在则抛出异常。
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
throw new IllegalTransactionStateException(
"Existing transaction found for transaction marked with propagation 'never'");
}
// 条件：当前方法加的 @Transactional(propagation = NOT_SUPPORTED) 以非事务方式执行执行，如果当前存在事务，就把当前事务挂起。
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
if (debugEnabled) {
logger.debug("Suspending current transaction");
}
// 注意：transaction 是有值的..
// 挂起线程目前绑定的事务，拿到一个SuspendedResourcesHolder对象，该对象最主要的东西是 上一个 事务的 conHolder 资源
// 还包括上一个事务 绑定在 线程上下文 的一些变量..
Object suspendedResources = suspend(transaction);
// 一般是 true
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 创建 transactionStatus 对象
// 参数2：transaction is null ，线程执行到 当前方法(@Transaction(p = NOT_SUPPORTED) b())的事务增强的后置处理逻辑的时候，
// 执行提交事务的时候，会检查transactionStatus#transaction 是否有值，如果没有值，Spring 就不管了..不去做提交的事情..
// 参数6：suspendedResources 很关键..线程执行到 当前方法(@Transaction(p = NOT_SUPPORTED) b())的事务增强的后置处理逻辑的时候，
// 执行恢复现场的时候，会检查 transactionStatus#suspendedResources 是否有值，如果有，会进行恢复现场的操作。
// 恢复现场：根据挂起资源 去 恢复 线程上下文信息..TransactionSync..Manager 的那些threadLocal变量.
return prepareTransactionStatus(
definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}
// 条件：当前方法加的 @Transactional(propagation = REQUIRES_NEW) 新建事务，如果当前存在事务，把当前事务挂起。
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
if (debugEnabled) {
logger.debug("Suspending current transaction, creating new transaction with name [" +
definition.getName() + "]");
}
// 注意：transaction 是有值的..
// 挂起线程目前绑定的事务，拿到一个SuspendedResourcesHolder对象，该对象最主要的东西是 上一个 事务的 conHolder 资源
// 还包括上一个事务 绑定在 线程上下文 的一些变量..
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {
// 开启一个专属 当前方法 事务
// 参数4：因为当前方法 被挂起的 事务
return startTransaction(definition, transaction, debugEnabled, suspendedResources);
}
catch (RuntimeException | Error beginEx) {
resumeAfterBeginException(transaction, suspendedResources, beginEx);
throw beginEx;
}
}
// 条件：当前方法加的 @Transactional(propagation = NESTED） 如果当前存在事务，则在嵌套事务内执行。
// 如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// 默认spring不支持 内嵌 事务..
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException(
"Transaction manager does not allow nested transactions by default - " +
"specify 'nestedTransactionAllowed' property with value 'true'");
}
if (debugEnabled) {
logger.debug("Creating nested transaction with name [" + definition.getName() + "]");
}
if (useSavepointForNestedTransaction()) {
// 为当前方法创建一个 transactionStatus 对象
// Create savepoint within existing Spring-managed transaction,
// through the SavepointManager API implemented by TransactionStatus.
// Usually uses JDBC 3.0 savepoints. Never activates Spring synchronization.
DefaultTransactionStatus status =
prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
// 创建一个 保存点
status.createAndHoldSavepoint();
return status;
}
else {
// Nested transaction through nested begin and commit/rollback calls.
// Usually only for JTA: Spring synchronization might get activated here
// in case of a pre-existing JTA transaction.
return startTransaction(definition, transaction, debugEnabled, null);
}
}
// PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
// Assumably PROPAGATION_SUPPORTS or PROPAGATION_REQUIRED.
if (debugEnabled) {
logger.debug("Participating in existing transaction");
}
if (isValidateExistingTransaction()) {
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
Constants isoConstants = DefaultTransactionDefinition.constants;
throw new IllegalTransactionStateException("Participating transaction with definition [" +
definition + "] specifies isolation level which is incompatible with existing transaction: " +
(currentIsolationLevel != null ?
isoConstants.toCode(currentIsolationLevel, DefaultTransactionDefinition.PREFIX_ISOLATION) :
"(unknown)"));
}
}
if (!definition.isReadOnly()) {
if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
throw new IllegalTransactionStateException("Participating transaction with definition [" +
definition + "] is not marked as read-only but existing transaction is");
}
}
}
// PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已存在一个事务，加入到这个事务中，这是最常见的选择。
// PROPAGATION_SUPPORTS 支持当前事务，如果没有当前事务，就以非事务方法执行。
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 注意：参数3，newTransaction = false，表示当前事务状态 并不是 开启了 新的 事务..而是继续沿用上层事务
// 参数2：transaction 事务对象 -> conHodler 是 doGetTransaction() 方法的时候 从 线程上下文 内 获取 的上层 事务的 con 资源。
// 参数6：suspendedResources 它是null，因为 没有挂起 任何 事务..
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}
挂起事务AbstractPlatformTransactionManager#suspend：
protected final SuspendedResourcesHolder suspend(@Nullable Object transaction) throws TransactionException {
if (TransactionSynchronizationManager.isSynchronizationActive()) {
List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
try {
Object suspendedResources = null;
if (transaction != null) {
// 挂起 上层事务，将当前方法的 事务对象的#conHolder 设置为null
suspendedResources = doSuspend(transaction);
}
// 将上层事务绑定在 线程上下文的 变量 全部取出来...
String name = TransactionSynchronizationManager.getCurrentTransactionName();
TransactionSynchronizationManager.setCurrentTransactionName(null);
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
TransactionSynchronizationManager.setActualTransactionActive(false);
// 通过 “被挂起的资源” 和 上层事务的上下文变量 创建一个 SuspendedResourcesHolder，返回出去..
return new SuspendedResourcesHolder(
suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
}
catch (RuntimeException | Error ex) {
// doSuspend failed - original transaction is still active...
doResumeSynchronization(suspendedSynchronizations);
throw ex;
}
}
else if (transaction != null) {
// Transaction active but no synchronization active.
Object suspendedResources = doSuspend(transaction);
return new SuspendedResourcesHolder(suspendedResources);
}
else {
// Neither transaction nor synchronization active.
return null;
}
}
DataSourceTransactionManager#doSuspend
// transaction 对象是当前 方法的 事务对象
@Override
protected Object doSuspend(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 这一步关键，将 事务对象的 connectionHolder 设置为null 的目的是？ 不和上层共享 con 资源...
// 当前方法 有可能是 不开启 事务 或者 要开启一个 独立的事务
txObject.setConnectionHolder(null);
// 解绑在线程上的 事务（conHolder从 threadLocal 移除走..这样的话 业务就不会再拿上层 事务 的 con 资源了..）
return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
5.2 不存在事务时的处理
分为三类情况进行处理：
- 1）TransactionDefinition.PROPAGATION_MANDATORY，直接抛异常
- 2）PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW 和PROPAGATION_NESTED 开启事务
- 3）PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED和PROPAGATION_NEVER 以非事务方式执行
5.2.1 开启事务
try {
// 线程未开启事务时，PROPAGATION_REQUIRED PROPAGATION_REQUIRES_NEW PROPAGATION_NESTED 都会去开启一个新的事务
// 开启事务
return startTransaction(def, transaction, debugEnabled, suspendedResources);
}
AbstractPlatformTransactionManager#startTransaction
/**
* Start a new transaction.
*/
private TransactionStatus startTransaction(TransactionDefinition definition, Object transaction,
boolean debugEnabled, @Nullable SuspendedResourcesHolder suspendedResources) {
// 一般是true，该值 控制 是否执行 事务的扩展...
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 注意：newTransaction 值为 true ，表示会为当前 事务 分配 conn 资源的，就是 事务是为 当前 目标方法 开启的。
// suspendedResources ：挂起的事务
DefaultTransactionStatus status = newTransactionStatus(
definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 非常 非常重要的方法！开启事务的逻辑在内部..
// 参数1：事务对象
// 参数2：事务属性
doBegin(transaction, definition);
// 设置线程上下文变量，方便程序运行期间 获取 当前事务 的一些核心的属性..
prepareSynchronization(status, definition);
return status;
}
TransactionStatus如下：
DataSourceTransactionManager#doBegin
// 参数1：事务对象
// 参数2：事务属性
protected void doBegin(Object transaction, TransactionDefinition definition) {
// txObject 事务对象
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 数据库连接..
Connection con = null;
try {
// 条件：!txObject.hasConnectionHolder() 成立，说明 需要为当前 目标方法 分配数据库连接..
if (!txObject.hasConnectionHolder() ||
txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
// 通过数据源获取真实的数据库连接
Connection newCon = obtainDataSource().getConnection();
if (logger.isDebugEnabled()) {
logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
}
// 将上一步创建的数据库连接 包装为 connHolder，并且赋值给 事务对象
// 参数2：非常关键，给事务新申请的 conn 资源，那么就将 事务对象的 newConnectionHolder 设置为 true
// 表示 当前 “目标方法” 开启了一个自己的事务
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
// 获取事务对象上的数据库连接
con = txObject.getConnectionHolder().getConnection();
// 修改数据库连接上的一些属性（只读、隔离级别）
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
// 将con原来的隔离级别 保存到 事务对象，方便释放con时 重置回 原状态..
txObject.setPreviousIsolationLevel(previousIsolationLevel);
txObject.setReadOnly(definition.isReadOnly());
// Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
// so we don't want to do it unnecessarily (for example if we've explicitly
// configured the connection pool to set it already).
// 默认情况下，拿到的con#autoCommit == true，这个条件会成立..
if (con.getAutoCommit()) {
// 因为接下来 就是 设置autoCommit 为false 了，这里设置 must..表示回头需要给 con 设置回 autoCommit = true
txObject.setMustRestoreAutoCommit(true);
if (logger.isDebugEnabled()) {
logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
}
// 表示手动开启事务 ----- DB beginTransaction 语句
con.setAutoCommit(false);
}
prepareTransactionalConnection(con, definition);
// 设置holder.transactionActive 是true，表示holder持有的conn 已经手动开启事务了..
txObject.getConnectionHolder().setTransactionActive(true);
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// 条件成立：当前事务对象 申请了 conn 资源，并且 手动开启了 事务，才会成立。
// Bind the connection holder to the thread.
if (txObject.isNewConnectionHolder()) {
// 将 conHolder 绑定到 threadLocal 内，key：数据源
// 方便 业务代码 拿到一个 手动开启事务的 con 去执行 业务sql
TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
}
}
catch (Throwable ex) {
if (txObject.isNewConnectionHolder()) {
DataSourceUtils.releaseConnection(con, obtainDataSource());
txObject.setConnectionHolder(null, false);
}
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
这里又重新设置了DataSourceTransactionObject：
AbstractPlatformTransactionManager#prepareSynchronization
/**
* Initialize transaction synchronization as appropriate.
*/
protected void prepareSynchronization(DefaultTransactionStatus status, TransactionDefinition definition) {
if (status.isNewSynchronization()) {
// 当前事务 是否是真实的事务，transactionStatus#transaction 对象不为null
TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
// 当前事务 隔离级别
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(
definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ?
definition.getIsolationLevel() : null);
// 当前事务 是否只读
TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
// 当前事务 名称
TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
// 初始化事务的 扩展 集合...
TransactionSynchronizationManager.initSynchronization();
}
}
5.2.2 以非事务方式执行
// 参数2：transaction is null ，说明当前 事务状态 未手动开启事务 =》 线程上 未绑定任何的资源...业务程序执行时 到 datasource 再获取conn
// 获取的conn 是自动提交事务的.. 不需要 Spring 再提交事务了..
// 参数6：suspendedResources is null 说明当前 事务状态 未挂起 任何事务..当前 这个 事务 执行到 后置处理时，不需要 恢复现场..
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
6.后置逻辑-事务回滚
catch (Throwable ex) {
// 执行业务代码时 抛出异常，走这里。
// 处理回滚的逻辑入口
// target invocation exception
completeTransactionAfterThrowing(txInfo, ex);
throw ex;
}
TransactionAspectSupport#completeTransactionAfterThrowing
protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) {
if (txInfo != null && txInfo.getTransactionStatus() != null) {
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() +
"] after exception: " + ex);
}
// 条件1：一般都是true
// 条件2：txInfo.transactionAttribute.rollbackOn(ex) 条件如果成立 说明目标方法抛出的异常 需要回滚事务..
if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
try {
// 事务管理器 回滚方法 -> 当前事务状态对象
txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
}
catch (TransactionSystemException ex2) {
logger.error("Application exception overridden by rollback exception", ex);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException | Error ex2) {
logger.error("Application exception overridden by rollback exception", ex);
throw ex2;
}
}
else {
// 执行到这里，说明当前事务虽然抛出了异常，但是该异常并不会导致整个事务回滚..
// We don't roll back on this exception.
// Will still roll back if TransactionStatus.isRollbackOnly() is true.
try {
// 事务提交的逻辑...
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
}
catch (TransactionSystemException ex2) {
logger.error("Application exception overridden by commit exception", ex);
ex2.initApplicationException(ex);
throw ex2;
}
catch (RuntimeException | Error ex2) {
logger.error("Application exception overridden by commit exception", ex);
throw ex2;
}
}
}
}
public final void rollback(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
processRollback(defStatus, false);
}
AbstractPlatformTransactionManager#processRollback
private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
try {
boolean unexpectedRollback = unexpected;
try {
// 事务扩展逻辑，调用点..
triggerBeforeCompletion(status);
// 条件成立：说明当前 事务是一个内嵌事务，并且上层是存在一个事务的，当前方法是沿用了上层事务的一个内嵌事务
// （方法上的注解是 @Transactional(propagation = NESTED)）
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Rolling back transaction to savepoint");
}
// 恢复至保存点..
status.rollbackToHeldSavepoint();
}
// 条件成立：说明当前方法是一个真正开启 事务 的方法，该事务归属 当前方法...
// (@Transactional a() 执行a方法的时候 线程并未 绑定资源..执行的时候就去申请资源..并开启了事务，这个事务 最终 提交 或者 回滚 都由该方法的 后置增强处理..)
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction rollback");
}
doRollback(status);
}
else {
// 执行到这里说明什么？
// 1. 当前方法是共享的上层的事务，所谓的共享上层事务 指的是 和上层 使用同一个 con 资源
// 2. 当前方法添加的注解 ：@Transactional(propagation = SUPPORTS/ NOT_SUPPORTED / NEVER ) 这三种情况下 创建的 事务状态对象的 transaction 字段是null
// 条件成立： 1. 当前方法是共享的上层的事务，所谓的共享上层事务 指的是 和上层 使用同一个 con 资源
// Participating in larger transaction
if (status.hasTransaction()) {
// 条件1：什么成立？共享上层事务的方法，业务代码强制设置当前整个事务 需要回滚的话，可以通过 status.setLocalRollbackOnly = true
// 条件2：默认成立，true
if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
// 一个共享上层事务的 事务，可以直接回滚么？ 不可以..需要将回滚这件事 交给 上层事务 去完成
// 怎么交给？设置 con.rollbackOnly = true，这样的话，线程回到上层事务commit逻辑的时候，会检查该字段，发现true ，就会执行回滚操作了..
if (status.isDebug()) {
logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
}
// transactionStatus->txObject->connetionHolder#rollbackOnly = true
doSetRollbackOnly(status);
}
else {
if (status.isDebug()) {
logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
}
}
}
else {
// 2. 当前方法添加的注解 ：@Transactional(propagation = SUPPORTS/ NOT_SUPPORTED / NEVER ) 这三种情况下 创建的 事务状态对象的 transaction 字段是null
logger.debug("Should roll back transaction but cannot - no transaction available");
}
// Unexpected rollback only matters here if we're asked to fail early
if (!isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = false;
}
}
}
catch (RuntimeException | Error ex) {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
throw ex;
}
// 事务扩展调用点..
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
// Raise UnexpectedRollbackException if we had a global rollback-only marker
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction rolled back because it has been marked as rollback-only");
}
}
finally {
// 清理工作 + 恢复现场的工作
cleanupAfterCompletion(status);
}
}
清理、恢复现场：
private void cleanupAfterCompletion(DefaultTransactionStatus status) {
// 设置当前方法的事务状态为 完成状态.
status.setCompleted();
if (status.isNewSynchronization()) {
// 清理线程上下文 变量 以及 扩展点注册的 sync..
TransactionSynchronizationManager.clear();
}
// 条件成立：说明 真实的事务 开启是由 当前方法 开启的，当前方法在 事务增强器的后置逻辑内 需要做 清理工作..解绑资源（conHolder）
if (status.isNewTransaction()) {
// 当前方法的 “事务对象”
doCleanupAfterCompletion(status.getTransaction());
}
// 条件成立：说明当前事务执行的时候，挂起了一个上层的事务..
// 例子：@Transaction a() {b.b()} @Transaction(propagation = R_N) b(){...}
if (status.getSuspendedResources() != null) {
if (status.isDebug()) {
logger.debug("Resuming suspended transaction after completion of inner transaction");
}
Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
// 恢复现场..
// 参数1：transaction b方法的事务对象
// 参数2：status.getSuspendedResources() a方法的事务资源
resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
}
}
DataSourceTransactionManager#doCleanupAfterCompletion
protected void doCleanupAfterCompletion(Object transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 条件成立：说明 事务对象 是一个真实开启事务的对象..
// Remove the connection holder from the thread, if exposed.
if (txObject.isNewConnectionHolder()) {
// 解绑资源..
TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
// 获取当前事务的数据库链接..
Connection con = txObject.getConnectionHolder().getConnection();
try {
// 恢复链接..为什么呢？因为con需要归还到 datasource，归还之前需要恢复到 申请时的状态..
if (txObject.isMustRestoreAutoCommit()) {
// 恢复链接为 自动提交
con.setAutoCommit(true);
}
// 恢复隔离级别 和 readOnly
DataSourceUtils.resetConnectionAfterTransaction(
con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
}
catch (Throwable ex) {
logger.debug("Could not reset JDBC Connection after transaction", ex);
}
// 条件成立：说明 事务对象 是一个真实开启事务的对象..
if (txObject.isNewConnectionHolder()) {
if (logger.isDebugEnabled()) {
logger.debug("Releasing JDBC Connection [" + con + "] after transaction");
}
// 归还数据库链接到datasource
DataSourceUtils.releaseConnection(con, this.dataSource);
}
txObject.getConnectionHolder().clear();
}
恢复现场AbstractPlatformTransactionManager#resume
protected final void resume(@Nullable Object transaction, @Nullable SuspendedResourcesHolder resourcesHolder)
throws TransactionException {
if (resourcesHolder != null) {
// conHolder资源
Object suspendedResources = resourcesHolder.suspendedResources;
if (suspendedResources != null) {
// 绑定上一个事务的 conHolder 到 线程上下文..
doResume(transaction, suspendedResources);
}
// 将线程上下文变量 恢复 为 上一个事务的 现场..
List<TransactionSynchronization> suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;
if (suspendedSynchronizations != null) {
TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);
doResumeSynchronization(suspendedSynchronizations);
}
}
}
7.后置逻辑-事务提交
// 提交事务的入口：
commitTransactionAfterReturning(txInfo);
TransactionAspectSupport#commitTransactionAfterReturning
protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) {
if (txInfo != null && txInfo.getTransactionStatus() != null) {
if (logger.isTraceEnabled()) {
logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]");
}
// 事务管理器 提交事务方法 参数：事务状态
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
}
}
AbstractPlatformTransactionManager#commit
public final void commit(TransactionStatus status) throws TransactionException {
if (status.isCompleted()) {
throw new IllegalTransactionStateException(
"Transaction is already completed - do not call commit or rollback more than once per transaction");
}
DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
// 条件成立：说明是 业务 强制回滚
if (defStatus.isLocalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Transactional code has requested rollback");
}
// 回滚..
processRollback(defStatus, false);
return;
}
// 条件2：defStatus.isGlobalRollbackOnly() 其实就是 defStatus->txObject->conHolder#rollbackOnly 字段
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
if (defStatus.isDebug()) {
logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
}
// 执行回滚操作..（最上层事务 （事务归属的方法） 会进行真实的事务回滚操作）
processRollback(defStatus, true);
return;
}
processCommit(defStatus);
}
AbstractPlatformTransactionManager#processCommit
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
try {
boolean beforeCompletionInvoked = false;
try {
boolean unexpectedRollback = false;
// 扩展点..
prepareForCommit(status);
// sync..调用点..
triggerBeforeCommit(status);
triggerBeforeCompletion(status);
beforeCompletionInvoked = true;
// 条件成立：说明当前方法是一个 内嵌事务，并且事务并不归属当前方法，当前方法只是共享了 上层的 事务..
if (status.hasSavepoint()) {
if (status.isDebug()) {
logger.debug("Releasing transaction savepoint");
}
unexpectedRollback = status.isGlobalRollbackOnly();
// 清理保存点，因为没发生任何异常，保存点没有存在的意义了..
status.releaseHeldSavepoint();
}
// 条件成立：说明事务是归属当前方法的，当前方法的事务增强后置逻辑，需要进行正常提交事务！
else if (status.isNewTransaction()) {
if (status.isDebug()) {
logger.debug("Initiating transaction commit");
}
unexpectedRollback = status.isGlobalRollbackOnly();
// 底层提交事务
doCommit(status);
}
else if (isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = status.isGlobalRollbackOnly();
}
// Throw UnexpectedRollbackException if we have a global rollback-only
// marker but still didn't get a corresponding exception from commit.
if (unexpectedRollback) {
throw new UnexpectedRollbackException(
"Transaction silently rolled back because it has been marked as rollback-only");
}
}
catch (UnexpectedRollbackException ex) {
// can only be caused by doCommit
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
throw ex;
}
catch (TransactionException ex) {
// can only be caused by doCommit
if (isRollbackOnCommitFailure()) {
doRollbackOnCommitException(status, ex);
}
else {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
}
throw ex;
}
catch (RuntimeException | Error ex) {
if (!beforeCompletionInvoked) {
triggerBeforeCompletion(status);
}
doRollbackOnCommitException(status, ex);
throw ex;
}
// Trigger afterCommit callbacks, with an exception thrown there
// propagated to callers but the transaction still considered as committed.
try {
triggerAfterCommit(status);
}
finally {
triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
}
}
finally {
// 清理+恢复现场
cleanupAfterCompletion(status);
}
}
8.总结
<tx:annotation-driven>
- 1）标签解析器AnnotationDrivenBeanDefinitionParser引入了四个BeanDefinition
- 2）一个是InfrastructureAdvisorAutoProxyCreator，用来对@Transactional注解的类创建动态代理
- 3）另外三个是BeanFactoryTransactionAttributeSourceAdvisor、切点AnnotationTransactionAttributeSource和增强TransactionInterceptor
创建代理对象：
- InfrastructureAdvisorAutoProxyCreator和AnnotationAwareAspectJAutoProxyCreator类层次结构基本一模一样
- 在父类AbstractAutoProxyCreator#postProcessAfterInitialization中会创建JDK动态代理
- 创建动态代理对象前，先要拿到跟当前Bean匹配的Advisor，BeanFactoryTransactionAttributeSourceAdvisor会先进行类匹配（基本都会通过），然后进行方法匹配（一般查找@Transactional顺序为：执行的目标方法、目标类、对应的接口方法（如果有）、接口类（如果有），其中一个找到了就直接返回，不会继续查找。）
动态代理调用过程JdkDynamicAopProxy#invoke：
- 1）this.advised.exposeProxy 如果是true，就要把当前这个代理对象，暴漏 到Aop上下文内
- 2）查找匹配该方法的所有增强chain：DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice
2-1）从ProxyFactory 获取出所有的Advisor
2-2）遍历Advisor，先进行类匹配，然后进行方法匹配，如果匹配，则获取Advisor中的Advice（TransactionInterceptor）加入interceptorList链
2-3）返回interceptorList - 3）联合chain包装成ReflectiveMethodInvocation，进行调用
3-1）ReflectiveMethodInvocation#proceed
根据currentInterceptorIndex逐个进行调用；
最终调用至被代理的方法；
3-2）MethodInterceptor#invoke(this)，这里的this就是ReflectiveMethodInvocation
3-3）最后反射调用至被代理的方法
其中事务传播机制：
- PROPAGATION_REQUIRED 如果当前没有事务，就新建一个事务，如果已存在一个事务，加入到这个事务中，这是最常见的选择。
- PROPAGATION_SUPPORTS 支持当前事务，如果没有当前事务，就以非事务方法执行。
- PROPAGATION_MANDATORY 使用当前事务，如果没有当前事务，就抛出异常。
- PROPAGATION_REQUIRES_NEW 新建事务，如果当前存在事务，把当前事务挂起。
- PROPAGATION_NOT_SUPPORTED 以非事务方式执行执行，如果当前存在事务，就把当前事务挂起。
- PROPAGATION_NEVER 以非事务方式执行操作，如果当前事务存在则抛出异常。
- PROPAGATION_NESTED 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
核心看TransactionInterceptor#invoke()，重点关注声明式事务（不关注编程式事务）：
- 1）createTransactionIfNecessary()如果有需要则创建事务
1-1）DataSourceTransactionManager#getTransaction
A）doGetTransaction()，获得是DataSourceTransactionObject
A-1）创建DataSourceTransactionObject
A-2）从TransactionSynchronizationManager.getResource()根据DataSource获取ConnectionHolder
A-3）txObject.setConnectionHolder(conHolder, false);
B）handleExistingTransaction()已存在事务时的处理（上面的txObject中的ConnectionHolder不为null）
B-1）PROPAGATION_NEVER，抛异常
B-2）PROPAGATION_NOT_SUPPORTED，先要挂起事务suspend(transaction)，然后prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources)这里参数2：transaction是null，后置处理时，不做提交；参数6：suspendedResources后置处理时用于恢复现场。
B-3）PROPAGATION_REQUIRES_NEW，先要挂起事务 suspend(transaction)，然后开启新事务startTransaction()
B-4）PROPAGATION_NESTED，如果开启了支持，则先prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null)，然后创建一个保存点savepoint。
B-5）PROPAGATION_SUPPORTS、PROPAGATION_REQUIRED、PROPAGATION_MANDATORY prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null) 这里使用已存在的事务transaction执行。
C）不存在事务时的处理
C-1）PROPAGATION_MANDATORY时，抛异常
C-2）PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、PROPAGATION_NESTED会先suspend(null)，然后开启一个事务startTransaction()
C-3）PROPAGATION_SUPPORTS、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER 以非事务方式运行，prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null) 最后一个参数suspendedResources是null，则表明执行后置处理时，不需要恢复现场。
1-2）TransactionAspectSupport#prepareTransactionInfo：创建TransactionInfo，并将TransactionInfo入栈 - 2）invocation.proceedWithInvocation() 驱动增强链继续执行ReflectiveMethodInvocation#proceed
- 3）completeTransactionAfterThrowing 发生异常时处理
3-1）异常匹配时，需要调用事务管理器进行回滚rollback()
A）PROPAGATION_NESTED，回滚到保存到savepoint
B）REQUIRES_NEW / REQUIRES，是新开的事务，则直接rollback()
C）SUPPORTS/MANDATORY / REQUIRES共享已有的事务（这里不进行实际回滚，只是设置一下标记transactionStatus->txObject->connetionHolder#rollbackOnly = true）， NOT_SUPPORTED / NEVER 事务字段为null。
D）cleanupAfterCompletion(status) 清理工作（新开的事务REQUIRES_NEW / REQUIRES，需要清理资源） + 恢复现场的工作（如果挂起了事务，则恢复现场PROPAGATION_NOT_SUPPORTED、PROPAGATION_REQUIRES_NEW）
3-2）其他情况则调用事务管理器进行提交commit() - 4）cleanupTransactionInfo 事务出栈
- 5）commitTransactionAfterReturning 正常结束时的处理
5-1）defStatus.isLocalRollbackOnly() 强制回滚
5-2）defStatus->txObject->conHolder#rollbackOnly 里面设置了回滚了，外层则回滚
5-3）处理提交
A）PROPAGATION_NESTED，清理保存点，因为没发生任何异常，保存点没有存在的意义了
B）REQUIRES_NEW / REQUIRES，是新开的事务，正常提交事务
C）cleanupAfterCompletion(status) 清理工作（新开的事务REQUIRES_NEW / REQUIRES，需要清理资源） + 恢复现场的工作（如果挂起了事务，则恢复现场PROPAGATION_NOT_SUPPORTED、PROPAGATION_REQUIRES_NEW）
