spring的声明式事务本质还是基于spring aop,只不过少去了解析切面的过程,核心为Transactional这个注解,本篇将基于spring源码详解声明式事务。
@EnableTransactionManagement首先来到Spring声明式事务入口注解EnableTransactionManagement,有了这个注解表明开启声明式事务功能。看一下这个注解:
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
boolean proxyTargetClass() default false;
AdviceMode mode() default AdviceMode.PROXY;
int order() default Ordered.LOWEST_PRECEDENCE;
}
可以看到Import了TransactionManagementConfigurationSelector这个类,是一个ImportSelector,用来注册bean定义:
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector{ @Override protected String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { case PROXY: //注册两个bean定义,AutoProxyRegistrar和ProxyTransactionManagementConfiguration return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()}; case ASPECTJ: return new String[] {determineTransactionAspectClass()}; default: return null; } } }
这里会引入两个bean,AutoProxyRegistrar和ProxyTransactionManagementConfiguration,先看AutoProxyRegistrar,这个bean是一个ImportBeanDefinitionRegistrar,意味着它还会注册bean定义:
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean candidateFound = false;
Set annTypes = importingClassMetadata.getAnnotationTypes();
for (String annType : annTypes) {
AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
if (candidate == null) {
continue;
}
Object mode = candidate.get("mode");
Object proxyTargetClass = candidate.get("proxyTargetClass");
//获取EnableTransactionManagement注解上的mode和proxyTargetClass属性
if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
Boolean.class == proxyTargetClass.getClass()) {
candidateFound = true;
if (mode == AdviceMode.PROXY) {
//如果是动态代理模式,那么注册相关的bean,以jdk动态代理为例
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
if ((Boolean) proxyTargetClass) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
return;
}
}
}
}
}
这个BeanDefinitionRegistrar会注册用于创建动态代理的核心bean:InfrastructureAdvisorAutoProxyCreator,注册逻辑其实和aop完全一样,在之前aop的源码中有过介绍:
private static BeanDefinition registerOrEscalateApcAsRequired(
Class> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
//如果容器中已经有了名为AUTO_PROXY_CREATOR_BEAN_NAME的bean,则会根据优先级Priority选择是否覆盖(aop会覆盖声明式事务)
if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
}
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
//设置最高优先级
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
//设置bean角色为基础设施bean
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
//注册beanDefinition
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
ok,下面看下另外一个bean:ProxyTransactionManagementConfiguration。这其实是一个声明式事务的配置类:
@Configuration(proxyBeanMethods = false)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
//事务的核心通知器,可以立理解为aop中的一个环绕通知器
@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
//设置事务属性源,Transactional注解上的属性
advisor.setTransactionAttributeSource(transactionAttributeSource);
//设置通知(切面),为下面的TransactionInterceptor
advisor.setAdvice(transactionInterceptor);
//enableTx为EnableTransactionManagement注解属性
if (this.enableTx != null) {
advisor.setOrder(this.enableTx.getNumber("order"));
}
return advisor;
}
//这个bean为事务属性源,用于获取Transactional注解上的属性,内部有一个SpringTransactionAnnotationParser
//用于解析Transactional注解,获取上面的参数值
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}
//切面通知,本质是一个环绕通知,用于需要开启事务的方法的方法增强
@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
TransactionInterceptor interceptor = new TransactionInterceptor();
interceptor.setTransactionAttributeSource(transactionAttributeSource);
if (this.txManager != null) {
//设置事务管理器,事务管理器用于操作事务,在springboot中会自动装配DataSourceTransactionManager
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}
}
下面再看下InfrastructureAdvisorAutoProxyCreator这个类,在没有开启aop时,spring会用这个类为事务方法进行匹配和创建动态代理,逻辑是和aop一样的,之前已经详细分析过,在此就不赘述了,不同的时匹配过程,这里使用Transactional注解去匹配,还记得SpringTransactionAnnotationParser吗,最终是用SpringTransactionAnnotationParser来解析是否有Transactional注解,有的话就匹配上了。简单看下:
public static boolean canApply(Advisor advisor, Class> targetClass, boolean hasIntroductions) {
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
}
else {
return true;
}
}
public static boolean canApply(Pointcut pc, Class> targetClass, boolean hasIntroductions) {
//...
for (Class> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
//使用methodMatcher.matches匹配,这里的methodMatcher就是上面的配置类中注册的
//BeanFactoryTransactionAttributeSourceAdvisor中的切点TransactionAttributeSourcePointcut
if (introductionAwareMethodMatcher != null ?
introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}
下面看这个切点的匹配逻辑:
public boolean matches(Method method, Class> targetClass) {
TransactionAttributeSource tas = getTransactionAttributeSource();
return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
}
public TransactionAttribute getTransactionAttribute(Method method, @Nullable Class> targetClass) {
//...
//获取事务属性值
TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
//...
}
}
computeTransactionAttribute:
//先从方法上找Transaction注解
TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
//从类上找Transaction注解
txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
protected TransactionAttribute findTransactionAttribute(Class> clazz) {
return determineTransactionAttribute(clazz);
}
protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
for (TransactionAnnotationParser parser : this.annotationParsers) {
TransactionAttribute attr = parser.parseTransactionAnnotation(element);
if (attr != null) {
return attr;
}
}
return null;
}
最终用SpringTransactionAnnotationParser解析注解:
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
element, Transactional.class, false, false);
//有Transactional注解则返回相应的参数值,否则视为没有匹配上
if (attributes != null) {
return parseTransactionAnnotation(attributes);
}
else {
return null;
}
}
到此声明式事务需要的相关bean都已经准备好了,下面从一个@Transactional注解进入一个事务方法,在此之前先介绍下这个注解。
@Transactional@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
@AliasFor("transactionManager")
String value() default "";//用于指定特定的事务管理器
@AliasFor("value")
String transactionManager() default "";//用于指定特定的事务管理器
Propagation propagation() default Propagation.REQUIRED;//设置传播行为,默认REQUIRED
Isolation isolation() default Isolation.DEFAULT;//隔离级别,默认使用数据库的隔离级别
int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;//事务超时时间
boolean readOnly() default false;
Class extends Throwable>[] rollbackFor() default {};//需要事务回滚的异常
String[] rollbackForClassName() default {};//需要事务回滚的异常
Class extends Throwable>[] noRollbackFor() default {};//不需要事务回滚的异常
String[] noRollbackForClassName() default {};//不需要事务回滚的异常
}
其中比较重要的是传播行为和隔离级别,隔离级别大家应该很熟悉了,看下各种传播行为:
| 事务传播行为类型 | 外部不存在事务 | 外部存在事务 | 使用方式 |
| REQUIRED(默认) | 开启新的事务 | 融合到外部事务中 | @Transactional(propagation = Propagation.REQUIRED) 适用增删改查 |
| SUPPORTS | 不开启新的事务 | 融合到外部事务中 | @Transactional(propagation = Propagation.SUPPORTS) 适用查询 |
| REQUIRES_NEW | 开启新的事务 | 挂起外部事务,创建新的事务 | @Transactional(propagation = Propagation.REQUIRES_NEW) 适用内部事务和外部事务不存在业务关联情况,如日志 |
| NOT_SUPPORTED | 不开启新的事务 | 挂起外部事务,不开启事务 | @Transactional(propagation = Propagation.NOT_SUPPORTED) 不常用 |
| NEVER | 不开启新的事务 | 抛出异常 | @Transactional(propagation = Propagation.NEVER ) 不常用 |
| MANDATORY | 抛出异常 | 融合到外部事务中 | @Transactional(propagation = Propagation.MANDATORY) 不常用 |
| NESTED | 开启新的事务 | 融合到外部事务中,SavePoint机制,外层影响内层, 内层不会影响外层 | @Transactional(propagation = Propagation.NESTED) 不常用 |
未完待续...



