核心注解@EnableTransactionManagement,作用,导入aop的BeanPostProcessorInfrastructureAdvisorAutoProxyCreator
@EnableTransactionManagement作用
@Import(TransactionManagementConfigurationSelector.class)
class TransactionManagementConfigurationSelector {
protected String[] selectImports(AdviceMode adviceMode) {
return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
}
// 负责注入创建AOP对象的BeanPostProcessor
class AutoProxyRegistrar {
// 注册Bean
// importingClassMetadata是正在解析的配置类对应的元数据信息,也就是标注@EnableTransactionManagement这个类的配置类
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 获取配置类上的所有注解
Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
for (String annType : annTypes) {
// 遍历所有的注解
AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
// 找到一些符合AOP条件的共性,mode,proxyTargetClass等等
Object mode = candidate.get("mode");
Object proxyTargetClass = candidate.get("proxyTargetClass");
// 如果符合这个条件,表示当前类需要进行AOP
if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() && Boolean.class == proxyTargetClass.getClass()) {
candidateFound = true;
// 判断当前配置类的代理模式
if (mode == AdviceMode.PROXY) {
// 注册创建AOP代理对象的BeanPostProcessor,InfrastructureAdvisorAutoProxyCreator
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
// 如果proxyTargetClass为true,表示使用CGLIB代理
/*
三种情况
1. proxyTargetClass =false(默认值) 目标实现了接口 JDK代理
2. proxyTargetClass =false(默认值) 目标未实现接口 CGLIB代理
3. proxyTargetClass =true 总是CGLIB代理
*/
if ((Boolean) proxyTargetClass) {
// 强制设置创建代理的使用使用CGLIB代理
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
return;
}
}
}
}
}
}
// 负责注入切面,包含切点(通过事务属性值来创建)和通知
class ProxyTransactionManagementConfiguration {
// 注入一个切面,这种切面只包含一个切点和一个通知
@Bean(name = "internalTransactionAdvisor")
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
{
// 切面内部的切点,是依靠transactionAttributeSource来创建的
private final TransactionAttributeSourcePointcut pointcut = new TransactionAttributeSourcePointcut() {
protected TransactionAttributeSource getTransactionAttributeSource() {
return transactionAttributeSource;
}
};
}
// 设置事务属性值,依靠他来创建切点
advisor.setTransactionAttributeSource(transactionAttributeSource);
// 设置通知
advisor.setAdvice(transactionInterceptor);
return advisor;
}
// 处理注解Transactional的类
@Bean
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
{
this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
}
}
// 增强器
@Bean
public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
// 新建通知
TransactionInterceptor interceptor = new TransactionInterceptor();
// 设置事务属性源
interceptor.setTransactionAttributeSource(transactionAttributeSource);
// 如果存在事务管理器
if (this.txManager != null) {
// 设置事务管理器
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}
// 父类中注入,处理带有事务的TransactionalEventListener注解
@Bean(name = "internalTransactionalEventListenerFactory")
public static TransactionalEventListenerFactory transactionalEventListenerFactory() {
return new TransactionalEventListenerFactory();
}
}
org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator
{
public Object postProcessAfterInitialization (@Nullable Object bean, String beanName){
// 看一下当前类和beanName是否被处理过
Object cacheKey = getCacheKey(bean.getClass(), beanName);
// 如果两者不等,表示没有保存在earlyProxyReferences中,返回的是null,和bean肯定不匹配
// 如果提前Aop了,那么就会保存到earlyProxyReferences,和bean就匹配了
if (this.earlyProxyReferences.remove(cacheKey) != bean) {
// 是否需要进行AOP
return wrapIfNecessary(bean, beanName, cacheKey);
{
// targetSourcedBeans存入的是一写需要自定义创建代理的Bean
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
return bean;
}
// advisedBeans存入Bean对应是否需要代理的标识
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
}
// 判断当前类有没有必要代理,如果没有必要代理,标记该类不需要代理
if (isInfrastructureClass(bean.getClass() {
// 如果是切面相关的类,那么就不需要被代理
boolean retVal = Advice.class.isAssignableFrom(beanClass) ||
Pointcut.class.isAssignableFrom(beanClass) ||
Advisor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass);
return retVal;
})||shouldSkip(bean.getClass(), beanName)){
// String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";是一个约定后缀,表示强制返回一个原始对象
// 例如@Component("luck.spring.tx.TransactionalConfig" + ORIGINAL_INSTANCE_SUFFIX)
if (!StringUtils.hasLength(beanName) || beanName.length() != beanClass.getName().length() + AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX.length()) {
return false;
}
return (beanName.startsWith(beanClass.getName()) && beanName.endsWith(AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX));
}
{
// 记录当前bean不需要被代理
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
// 如果有当前Bean有符合的切面,则需要创建代理对象
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
{
// 找到对当前Bean可以用的切面
List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
{
// 找到一些候选的切面
List<Advisor> candidateAdvisors = findCandidateAdvisors();
{
// 获取已换成的切面名称
String[] advisorNames = this.cachedAdvisorBeanNames;
// 如果不存在缓存的切面名称
if (advisorNames == null) {
// 根据类型在Spring中找到这些Advisor的BeanName
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
this.cachedAdvisorBeanNames = advisorNames;
}
// 没有切面
if (advisorNames.length == 0) {
return new ArrayList<>();
}
// 存在切面
List<Advisor> advisors = new ArrayList<>();
// 遍历所有切面
for (String name : advisorNames) {
// 判断是不是合格的Bean
if (isEligibleBean(name)) {
// 如果Bean正在创建中,就不处理,因为在初始化之后会自动判断是否需要代理
if (!this.beanFactory.isCurrentlyInCreation(name)) {
// 从Spring容器中获取这个Bean
advisors.add(this.beanFactory.getBean(name, Advisor.class));
}
}
}
// 返回这些存在的切面
return advisors;
}
// 通过上面找到的切面,判读是否可以用到该类
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
{
List<Advisor> eligibleAdvisors = new ArrayList<>();
// 遍历所有的切面
for (Advisor candidate : candidateAdvisors) {
// 处理IntroductionAdvisor这种切面,不含切面的切面
// IntroductionAdvisor是类级别的切面,详见类级别的切面IntroductionAdvisor
// 这个接口的作用就是在不改变原有的类同时给该类增加指定接口的所有方法,使用IntroductionAdvisor的getInterfaces来指定要动态增强这些接口的方法
// canApply下面代码会详细解析,就是判断当前类是否可以符合该切面的规则
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
// 如果可用,保存起来
eligibleAdvisors.add(candidate);
}
}
// 上面的逻辑是否找到了可用的Advisor切面,上面只处理IntroductionAdvisor这种类型的切面
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
// 再次遍历所有切面
for (Advisor candidate : candidateAdvisors) {
// 上面一次单独处理过IntroductionAdvisor这种类型的切面,这种切面特殊
if (candidate instanceof IntroductionAdvisor) {
continue;
}
// 判断当前类是否可用该切面,根据不同的切面来判断切面是否可用
if (canApply(candidate, clazz, hasIntroductions) {
// 如果通知是IntroductionAdvisor类型
if (advisor instanceof IntroductionAdvisor) {
// 获取当前实现类提供的ClassFilter,来匹配当前类是否需要增强
return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
}
// 如果是PointcutAdvisor这种带有切面的切面
else if (advisor instanceof PointcutAdvisor) {
PointcutAdvisor pca = (PointcutAdvisor) advisor;
// 判断PointcutAdvisor是否可用
return canApply(pca.getPointcut(), targetClass, hasIntroductions);
{
// 使用切点来匹配当前类是否符合规则
if (!pc.getClassFilter().matches(targetClass)) {
return false;
}
// 获取方法匹配器,因为PointcutAdvisor这种切面是方法级别的切面
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
return true;
}
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
// 如果匹配器是IntroductionAwareMethodMatcher这种类型
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
// 强转
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
}
Set<Class<?>> classes = new LinkedHashSet<>();
// 判断当前类是不是JDK代理类
if (!Proxy.isProxyClass(targetClass)) {
// 如果不是JDK代理,那就是CGLIC代理,获取到原始类
// 保存起来
classes.add(ClassUtils.getUserClass(targetClass));
}
// 保存当前类实现的所有接口
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
// 遍历当前类实现的所有接口以及当前类
for (Class<?> clazz : classes) {
// 所有类的所有方法
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
// 如果方法匹配器是IntroductionAwareMethodMatcher这种类型来匹配
// 总之这里就是获取方法匹配器根据表达式来匹配当前类是否可以用到这个切面
// 有各种实现
if (introductionAwareMethodMatcher != null ? introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
// 讲我符合我们当前事务的匹配器TransactionAttributeSourcePointcut
methodMatcher.matches(method, targetClass) {
// 获取TransactionAttributeSource,它是用来解析@Transactional注解的,上面讲过了ProxyTransactionManagementConfiguration注入了
TransactionAttributeSource tas = getTransactionAttributeSource();
// 解析事务属性来判断是否可用,如果解析成功,不为null表示可用
return (tas == null || tas.getTransactionAttribute(method, targetClass)
{
// 如果父类为方法是Object中的方法,不需要解析,直接不可用
if (method.getDeclaringClass() == Object.class) {
return null;
}
// 处理过的进行缓存
Object cacheKey = getCacheKey(method, targetClass);
// 看一下之前有没有处理过
TransactionAttribute cached = this.attributeCache.get(cacheKey);
// 表示处理过
if (cached != null) {
// 没有事务属性,也就是如果处理过,标记该类为不需要处理
if (cached == NULL_TRANSACTION_ATTRIBUTE) {
return null;
}
// 返回缓存事务属性值
return cached;
} else {
// 如果没有处理过,解析事务注解
TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
{
// publilc方法的逻辑校验,字面意思,如果当前类只支持public方法,但是该方法又不是public,就不处理
if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
}
/**
* Set<Class<?>> classes = new LinkedHashSet<>();
* if (!Proxy.isProxyClass(targetClass)) {
* classes.add(ClassUtils.getUserClass(targetClass));
* }
* classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
*
* for (Class<?> clazz : classes) {
* Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
* for (Method method : methods) {
* if (introductionAwareMethodMatcher != null ?
* introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
* methodMatcher.matches(method, targetClass)) {
* return true;
* }
* }
* }
*/
// 上面注释,method是从外面传递过来的,要单独处理JDK动态代理
// specificMethod是被调用的类的方法对象,根据上面注释代码,method可能是原始方法,CBLIB方法,也可能是接口的方法对象
// 例如:targetClass = B B impl A => B.test() 此时,specificMethod = B.test() , method = A.test()
Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
// 第一次解析,解析正在处理的目标类中方法的@Transactional注解
TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
{
// 使用事务注解解析器解析,annotationParsers是根据引入支持的事务类型来添加的解析器
// 在AnnotationTransactionAttributeSource中处理了
// if (jta12Present)this.annotationParsers.add(new JtaTransactionAnnotationParser());
// if (ejb3Present) this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
// this.annotationParsers.add(new SpringTransactionAnnotationParser());
for (TransactionAnnotationParser parser : this.annotationParsers) {
// 解析注解
TransactionAttribute attr = parser.parseTransactionAnnotation(element);
{
// 找Transactional注解
AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(element, Transactional.class, false, false);
// 如果存在Transactional注解,解析Transactional注解
if (attributes != null) {
// 将注解信息封装成RuleBasedTransactionAttribute对象
return parseTransactionAnnotation(attributes);
{
RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
Propagation propagation = attributes.getEnum("propagation");
rbta.setPropagationBehavior(propagation.value());
Isolation isolation = attributes.getEnum("isolation");
rbta.setIsolationLevel(isolation.value());
rbta.setTimeout(attributes.getNumber("timeout").intValue());
rbta.setReadOnly(attributes.getBoolean("readOnly"));
rbta.setQualifier(attributes.getString("value"));
List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
rbta.setRollbackRules(rollbackRules);
return rbta;
}
}
// 不存在,返回null
return null;
}
if (attr != null) {
return attr;
}
}
return null;
}
// 解析成功,直接返回
if (txAttr != null) {
return txAttr;
}
// 第二次解析,正在调用的目标类中的方法中不存在@Transactional注解,再解析该类上的注解
txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
// specificMethod是被调用的类的方法对象,根据上面注释代码,method可能是原始方法,CBLIB方法,也可能是接口的方法对象
// 例如:targetClass = B B impl A => B.test() 此时,specificMethod = B.test() , method = A.test()
// specificMethod != method,表示该方法是继承或者实现过来的,不是自身的方法
if (specificMethod != method) {
// 再通过method本身来找方法上的注解
txAttr = findTransactionAttribute(method);
if (txAttr != null) {
return txAttr;
}
// 最后在找method所属的类或者接口上的注解
txAttr = findTransactionAttribute(method.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
}
// 都没找到,那就是没有
return null;
}
// 如果没有找到@Transactional注解,标记该类不需要被代理
if (txAttr == null) {
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
} else {
// 找到了
// 获取方法的全名称
String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
// 如果事务属性为DefaultTransactionAttribute类型,将名称给它
if (txAttr instanceof DefaultTransactionAttribute) {
((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
}
// 缓存当前类的事务属性
this.attributeCache.put(cacheKey, txAttr);
}
return txAttr;
}
} !=null);
})
{
return true;
}
}
}
return false;
}
}
// 如果是其他类型的切面,默认为可用的
else {
return true;
}
}
}){
// 如果可用,保存起来
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
// 给子类的扩展方法,可以动态的添加扩展的切面
// 例如: advisors.add(0, ExposeInvocationInterceptor.ADVISOR);
extendAdvisors(eligibleAdvisors);
if (!eligibleAdvisors.isEmpty()) {
// 排序
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
// 如果没有找到,表示不需要代理
if (advisors.isEmpty()) {
return DO_NOT_PROXY;
}
// 返回所有可以用的切面
return advisors.toArray();
}
// 上面得到的结果为需要被代理
if (specificInterceptors != DO_NOT_PROXY) {
// 保存Bean需要被代理
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建代理对象
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
{
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
// 暴露目标类,将目标类设置到BD中
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
{
beanFactory.getMergedBeanDefinition(beanName).setAttribute(ORIGINAL_TARGET_CLASS_ATTRIBUTE, targetClass);
}
}
// 创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();
// 从当前类拷贝配置对象
proxyFactory.copyFrom(this);
// 判断要代理的方式,如果没有设置成CGLIB
if (!proxyFactory.isProxyTargetClass()) {
// 判断该Bean是不是设置了需要CBLIB代理
if (shouldProxyTargetClass(beanClass, beanName)) {
// 如果Bean设置了,那么就修改为CGLIB代理
proxyFactory.setProxyTargetClass(true);
} else {
// 计算需要代理的接口,在确定使用CGLIB还是JDK
evaluateProxyInterfaces(beanClass, proxyFactory);
{
// 获取类的所有接口
Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
boolean hasReasonableProxyInterface = false;
// 遍历所有接口
for (Class<?> ifc : targetInterfaces) {
// 如果不是实现的Spring内部的配置接口,例如InitializingBean,DisposableBean,并且不是其他语言的接口groovy
// 如果符合这个条件,表示实现了有代理意义的接口
if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) && ifc.getMethods().length > 0) {
hasReasonableProxyInterface = true;
break;
}
}
// 如果有代理意义的接口
if (hasReasonableProxyInterface) {
// 将接口设置到工厂中,这个就可以使用JDK代理
for (Class<?> ifc : targetInterfaces) {
proxyFactory.addInterface(ifc);
}
} else {
// 如果没有实现有代理意义的接口,那就使用CGLIB代理
proxyFactory.setProxyTargetClass(true);
}
}
}
}
// 构建切面,将公共的拦截器,
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
{
// specificInterceptors是上面找到的可用的切面传递过来成
List<Object> allInterceptors = new ArrayList<>();
if (specificInterceptors != null) {
allInterceptors.addAll(Arrays.asList(specificInterceptors));
}
Advisor[] advisors = new Advisor[allInterceptors.size()];
for (int i = 0; i < allInterceptors.size(); i++) {
// 将拦截器包装成切面
advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
{
// 如果是切面类型,直接返回
if (adviceObject instanceof Advisor) {
return (Advisor) adviceObject;
}
// 如果不是切面类型,也不是通知类型,就报错
if (!(adviceObject instanceof Advice)) {
throw new UnknownAdviceTypeException(adviceObject);
}
// 如果是通知类型,拦截器就属于通知的一种
Advice advice = (Advice) adviceObject;
// 判断是不是MethodInterceptor的通知拦截器
if (advice instanceof MethodInterceptor) {
// 包装成默认的切点类型的切面,内部包含切点和一个通知
return new DefaultPointcutAdvisor(advice);
}
// 如果是其他类型的通知,就需要进行适配
// 适配器包括下面三种
// registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
// registerAdvisorAdapter(new AfterReturningAdviceAdapter());
// registerAdvisorAdapter(new ThrowsAdviceAdapter());
for (AdvisorAdapter adapter : this.adapters) {
// 遍历所有的适配器进行适配
if (adapter.supportsAdvice(advice)) {
// 适配成功,包装成DefaultPointcutAdvisor切面
return new DefaultPointcutAdvisor(advice);
}
}
}
}
return advisors;
}
// 添加切面
proxyFactory.addAdvisors(advisors);
// 设置目标类的数据源
proxyFactory.setTargetSource(targetSource);
// 自定义工厂配置
customizeProxyFactory(proxyFactory);
// 设置是否冻结此配置,一旦冻结,不能被修改,默认为false
proxyFactory.setFrozen(this.freezeProxy);
// 是否先过滤切面,默认为true
if (advisorsPreFiltered()) {
// 设置过滤标识
proxyFactory.setPreFiltered(true);
}
// 获取代理对象
return proxyFactory.getProxy(getProxyClassLoader());
{
// 如果需要优化性能,或者是设置了CGLIB代理,或者该类没有实现有意义的接口,就是用户定义的接口
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
// 获取到目标类
Class<?> targetClass = config.getTargetClass();
// 如果目标类是一个接口,或者目标类是一个JDK代理对象,使用JDK代理
// 这里是处理接口的default默认方法的操作
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 否则使用CGLIB代理
return new ObjenesisCglibAopProxy(config);
{
// 获取目标类
Class<?> rootClass = this.advised.getTargetClass();
// 目标类就是代理的父类
Class<?> proxySuperClass = rootClass;
// 如果类已经是CGLIB代理的类
if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
// 还要获取到具体的目标原始类
proxySuperClass = rootClass.getSuperclass();
// 获取代理类实现的接口
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
// 保存这些接口
for (Class<?> additionalInterface : additionalInterfaces) {
this.advised.addInterface(additionalInterface);
}
}
// 配置CGLIB增强器,创建代理对象
Enhancer enhancer = createEnhancer();
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));
Callback[] callbacks = getCallbacks(rootClass);
{
// 这个拦截器是拦截器CGLIB代理对象的intercept方法
Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);
// ...,还有其他的拦截器
}
enhancer.setCallbackFilter(new ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
// 创建实例
return createProxyClassAndInstance(enhancer, callbacks);
{
enhancer.setInterceptDuringConstruction(false);
enhancer.setCallbacks(callbacks);
// 使用增强器创建代理对象
return (this.constructorArgs != null && this.constructorArgTypes != null ?
enhancer.create(this.constructorArgTypes, this.constructorArgs) :
enhancer.create());
}
}
} else {
// 其他条件,表示实现了接口,使用JDK动态代理
return new JdkDynamicAopProxy(config);
{
// 计算需要实现的接口
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
// 使用JDK代理
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
}
}
}
// 保存当前bean的代理类型
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
// 如果上面结果是不需要被代理,标记起来
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
}
return bean;
}
}
// 上述创建好了代理对象,那么调用方法的时候就会被代理对象所拦截
// 详见Spring中JDK动态代理和CBLIB代理的拦截逻辑
// 最终会执行代理对象的拦截器的拦截逻辑
class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {
@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
// 获取到目标类对象,如果target不为null,获取target的类对象
Class<?> targetClass = (invocation.getThis() {
return this.target;
}!=null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// 使用事务执行目标方法,invocation::proceed传递的是一个lambda函数
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed) {
// 获取事务属性源,如果有事务,tas就不为空,上面配置的时候就已经设置了TransactionAttributeSource
TransactionAttributeSource tas = getTransactionAttributeSource();
// 获取已经解析了@Transactional注解事务属性,上面有getTransactionAttribute的详细源码讲解,并且预先缓存了
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 确定事务管理器
final TransactionManager tm = determineTransactionManager(txAttr);
{
// 如果没有事务属性,表示没有解析到@Transactional注解,就没有事务
if (txAttr == null || this.beanFactory == null) {
// 如果TransactionInterceptor有设置就有,没有设置就没有
return getTransactionManager();
{
return this.transactionManager;
}
}
// 获取transactionManager的BeanName,就是@Transactional注解的value值
// @AliasFor("transactionManager")
String qualifier = txAttr.getQualifier();
// 如果执行了transactionManager的BeanName
if (StringUtils.hasText(qualifier)) {
// 从Spring中获取指定名称的transactionManager事务管理器
return determineQualifiedTransactionManager(this.beanFactory, qualifier);
{
// 先看一下之前是否缓存过
TransactionManager txManager = this.transactionManagerCache.get(qualifier);
// 未被缓存
if (txManager == null) {
// 从Spring中获取
txManager = BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, TransactionManager.class, qualifier);
// 缓存起来
this.transactionManagerCache.putIfAbsent(qualifier, txManager);
}
return txManager;
}
}
// 如果单独调用了setTransactionManagerBeanName,指定要transactionManagerBeanName的事务管理器
else if (StringUtils.hasText(this.transactionManagerBeanName)) {
// 和上面一样,就根据自己设置的beanName获取对应的txManager
return determineQualifiedTransactionManager(this.beanFactory, this.transactionManagerBeanName);
} else {
// 默认情况,都没设置beanName,先获取当前类的TransactionManager,如果设置了就有,否则就没
// 如果没有,那就根据类型去Spring中获取,上面都是根据beanName获取
TransactionManager defaultTransactionManager = getTransactionManager();
// 如果没有设置
if (defaultTransactionManager == null) {
// 查看是否被缓存过事务管理器
defaultTransactionManager = this.transactionManagerCache.get(DEFAULT_TRANSACTION_MANAGER_KEY);
// 双重校验
if (defaultTransactionManager == null) {
// 从Spring中获取TransactionManager类型的事务管理器
defaultTransactionManager = this.beanFactory.getBean(TransactionManager.class);
// 缓存事务管理器
this.transactionManagerCache.putIfAbsent(DEFAULT_TRANSACTION_MANAGER_KEY, defaultTransactionManager);
}
}
return defaultTransactionManager;
}
}
// 如果事务管理器是响应式的ReactiveTransactionManager类型
if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
ReactiveTransactionSupport txSupport = this.transactionSupportCache.computeIfAbsent(method, key -> {
// 获取对应方法类型的适配器
ReactiveAdapter adapter = this.reactiveAdapterRegistry.getAdapter(method.getReturnType());
if (adapter == null) {
throw new IllegalStateException("Cannot apply reactive transaction to non-reactive return type: " + method.getReturnType());
}
// 将ReactiveTransactionSupport缓存到transactionSupportCache的map中
return new ReactiveTransactionSupport(adapter);
});
// ReactiveTransactionSupport的invokeWithinTransaction方法,里面就是一些响应式的逻辑,例如Mono...
return txSupport.invokeWithinTransaction(method, targetClass, invocation, txAttr, (ReactiveTransactionManager) tm);
}
// 将事务管理器转换成PlatformTransactionManager类型
// 因为事务管理器分为两大类,一类是响应式的ReactiveTransactionManager,一种是PlatformTransactionManager
// ReactiveTransactionManager响应式的上面单独处理,到了这里,事务管理器必然是PlatformTransactionManager类型
// 如果不是,就要抛出异常了
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
{
// 不是PlatformTransactionManager类型的事务管理器要抛出异常
if (transactionManager == null || transactionManager instanceof PlatformTransactionManager) {
return (PlatformTransactionManager) transactionManager;
}
throw new IllegalStateException("Specified transaction manager is not a PlatformTransactionManager: " + transactionManager);
}
// 获取方法的名称
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
{
// 方法识别,默认返回null
String methodIdentification = methodIdentification(method, targetClass);
if (methodIdentification == null) {
// 如果事务属性是DefaultTransactionAttribute类型,需要获取方法签名
// 例如:luck.spring.tx.Demo$TransactionalConfig.test
// 对应着解析注解的时候设置的代码
// String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
// if (txAttr instanceof DefaultTransactionAttribute) {
// ((DefaultTransactionAttribute) txAttr).setDescriptor(methodIdentification);
// }
if (txAttr instanceof DefaultTransactionAttribute) {
methodIdentification = ((DefaultTransactionAttribute) txAttr).getDescriptor();
}
// 如果是其他类型事务属性
if (methodIdentification == null) {
// 通过类名.方法名拼接
methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
{
return (clazz != null ? clazz : method.getDeclaringClass()).getName() + '.' + method.getName();
}
}
}
return methodIdentification;
}
// 如果事务属性为null,或者事务管理器的类型不是CallbackPreferringPlatformTransactionManager类型
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// 创建事务,如果有必要
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
{
// 如果事务属性没有名称,使用方法签名做为名称
if (txAttr != null && txAttr.getName() == null) {
// 代理一下原有的事务属性,添加事务名称
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
public String getName() {
return joinpointIdentification;
}
};
}
// 事务状态
TransactionStatus status = null;
// 如果存在事务属性,并且存在事务管理器
if (txAttr != null && tm != null) {
// 获取一个事务
status = tm.getTransaction(txAttr);
{
{
// 如果没有给出事务定义,则使用默认值,txAttr = TransactionAttribute事务属性就是TransactionDefinition
// 所以有事务定义信息
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
// 创建事务
Object transaction = doGetTransaction();
{
// 创建数据源事务对象
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
// 设置此事务中是否允许保存点,如果支持嵌套事务,就允许有保存点,到时候可以通过这个回滚到指定的点位
txObject.setSavepointAllowed(isNestedTransactionAllowed());
// 获取数据源,使用TransactionSynchronizationManager事务同步管理器
// 检索绑定到当前线程的给定Key的资源。@param key要检查的键(通常是资源工厂)@返回一个绑定到当前线程的值(通常是活动的资源对象)，如果没有则返回{@code null}
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource())
{
// 通过获取数据源的真实类型
Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
// 获取资源值
Object value = doGetResource(actualKey);
{
// 获取到线程的所有资源
Map<Object, Object> map = resources.get();
// 如果没有,返回null
if (map == null) {
return null;
}
// 如果存在某些线程的资源
// 则根据数据源类型,获取当前线程绑定的值
Object value = map.get(actualKey);
// 如果缓存的值为ResourceHolder类型,并且hodler是空的
if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
// 异常这个Key
map.remove(actualKey);
// 所有线程的值都为空，删除整个ThreadLocal
if (map.isEmpty()) {
resources.remove();
}
value = null;
}
return value;
}
return value;
}
// 将链接的Hodler设置都事务对象中,第二个参数表示:是否是新的newConnectionHolder
txObject.setConnectionHolder(conHolder, false);
// 返回事务对象
return txObject;
}
boolean debugEnabled = logger.isDebugEnabled();
// 判断事务是否存在
if (isExistingTransaction(transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 事务对象中的ConnectionHolder存在,并且ConnectionHolder对事务的标记是活跃的
return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
})
{
// 处理已存在的事务
return handleExistingTransaction(def, transaction, debugEnabled);
{
// 如果存在事务,并且传播行为设置不允许事务,抛出异常
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
throw new IllegalTransactionStateException("Existing transaction found for transaction marked with propagation 'never'");
}
// 如果传播行为为不支持事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
// 暂停已存在的事务
Object suspendedResources = suspend(transaction);
{
// 事务同步管理器是否处于同步状态,就是同步状态信息在当前线程TransactionSynchronization存不存在
// 存在,表示现在事务处于同步状态
if (TransactionSynchronizationManager.isSynchronizationActive()) {
// 开始暂停事务
List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
{
// 获取当前线程所有的同步回调信息
List<TransactionSynchronization> suspendedSynchronizations = TransactionSynchronizationManager.getSynchronizations();
// 遍历所有的事务同步回调信息
for (TransactionSynchronization synchronization : suspendedSynchronizations) {
// 调用对象的暂停方法
synchronization.suspend();
{
// 解绑事务管理器中绑定当前线程的资源
TransactionSynchronizationManager.unbindResource(this.resourceKey);
}
}
// 清空当前线程的事务同步回调信息
TransactionSynchronizationManager.clearSynchronization();
// 返回暂停的事务同步回调信息
return suspendedSynchronizations;
}
try {
// 需要暂停的资源
Object suspendedResources = null;
// 如果存在事务对象
if (transaction != null) {
// 开始暂停
suspendedResources = doSuspend(transaction);
{
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 设置ConnectionHolder为null
txObject.setConnectionHolder(null);
// 解绑资源
return TransactionSynchronizationManager.unbindResource(obtainDataSource());
{
// 获取到真实的数据源对象Key
Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
// 做解绑操作
Object value = doUnbindResource(actualKey);
{
// 如果当前线程不存在资源绑定
Map<Object, Object> map = resources.get();
// 不处理
if (map == null) {
return null;
}
// 获取资当前线程绑定的值
Object value = map.remove(actualKey);
// 如果没有任何资源,清空ThreadLocal
if (map.isEmpty()) {
resources.remove();
}
// 绑定的值为ResourceHolder类型,并且值为空
if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
// 加快垃圾回收
value = null;
}
return value;
}
return value;
}
}
}
// 获取原有的事务名称
String name = TransactionSynchronizationManager.getCurrentTransactionName();
// 设置当前事务名称为null
TransactionSynchronizationManager.setCurrentTransactionName(null);
// 当前原有的事务是否仅读
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
// 设置当前可以读写
TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
// 获取原有的隔离级别
Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
// 设置当前事务的隔离界别为null
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
// 获取是否有实际活动的事务
boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
// 设置为false
TransactionSynchronizationManager.setActualTransactionActive(false);
// 保存暂停之前的配置信息返回
return new SuspendedResourcesHolder(suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
} catch (RuntimeException | Error ex) {
// 恢复事务
doResumeSynchronization(suspendedSynchronizations);
{
// 初始化同步信息
TransactionSynchronizationManager.initSynchronization();
{
// 如果事务处于活跃的,表示出问题了,因为现在是在恢复暂停的事务
if (isSynchronizationActive()) {
throw new IllegalStateException("Cannot activate transaction synchronization - already active");
}
synchronizations.set(new LinkedHashSet<>());
}
// 遍历所有暂停的事务
for (TransactionSynchronization synchronization : suspendedSynchronizations) {
// 调用事务同步信息的恢复方法
synchronization.resume();
{
// 绑定当前资源到事务同步管理器中
TransactionSynchronizationManager.bindResource(this.resourceKey, this.resourceHolder);
}
// 注册事务同步信息,将当前事务信息绑定到当前线程
TransactionSynchronizationManager.registerSynchronization(synchronization);
{
Set<TransactionSynchronization> synchs = synchronizations.get();
if (synchs == null) {
throw new IllegalStateException("Transaction synchronization is not active");
}
synchs.add(synchronization);
}
}
}
throw ex;
}
}
// 事务处于非同步状态,但是事务对象不为空
else if (transaction != null) {
// 暂停事务
Object suspendedResources = doSuspend(transaction);
{
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 设置ConnectionHolder为null
txObject.setConnectionHolder(null);
// 解绑绑定到当前线程的资源,返回绑定的值
return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
// 返回SuspendedResourcesHolder对象
return new SuspendedResourcesHolder(suspendedResources);
} else {
// 其他情况,返回null
return null;
}
}
// 判断是否是新的事务,当前事务标识是否是默认的SYNCHRONIZATION_ALWAYS,如果是表示是新的事务
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 预处理事务状态
return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);
{
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, newTransaction, newSynchronization, debug, suspendedResources);
{
// 是否是一个新的事务,新创建的,并且没有进行任何同步信息
boolean actualNewSynchronization = newSynchronization && !TransactionSynchronizationManager.isSynchronizationActive();
// 封装成DefaultTransactionStatus对象
return new DefaultTransactionStatus(transaction, newTransaction, actualNewSynchronization, definition.isReadOnly(), debug, suspendedResources);
}
// 预处理同步信息
prepareSynchronization(status, definition);
{
// 是否是新实物
if (status.isNewSynchronization()) {
// 设置真实的事务活动状态,如果存在事务对象,就表示有事务,那么事务的真实活动状态就为true
TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
// 设置当前的隔离级别
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ? definition.getIsolationLevel() : null);
// 设置当前事务是否只读
TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
// 设置当前事务的名称
TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
// 初始化事务信息,上面有同样的代码解析
TransactionSynchronizationManager.initSynchronization();
}
}
return status;
}
}
// 如果传播行为为开启新事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
// 暂停当前事务,上面有这个方法的代码讲解
SuspendedResourcesHolder suspendedResources = suspend(transaction);
try {
// 判断当前是否是新事务
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 封装成事务状态对象
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 开启事务
doBegin(transaction, definition) {
// 事务对象
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// jdbc连接
Connection con = null;
try {
// 如果事务对象ConnectionHolder为null,或者ConnectionHolder的事务同步标识为true,默认值为false
if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
// 通过数据源获取jdbc连接
Connection newCon = obtainDataSource().getConnection();
// 将连接封装成ConnectionHolder保存到事务对象中
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
// 设置ConnectionHolder的事务同步标识为true,标识开始同步
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
// 获取jdbc连接
con = txObject.getConnectionHolder().getConnection();
// 预处理事务,并获取隔离级别
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
{
// 当前事务是否只读
if (definition != null && definition.isReadOnly()) {
try {
// 设置到连接中
con.setReadOnly(true);
} catch (SQLException | RuntimeException ex) {
Throwable exToCheck = ex;
while (exToCheck != null) {
// 只有出现超时异常,才将异常抛出
// 其他的异常都不管
if (exToCheck.getClass().getSimpleName().contains("Timeout")) {
throw ex;
}
exToCheck = exToCheck.getCause();
}
}
}
// 之前的隔离级别
Integer previousIsolationLevel = null;
// 隔离级别不为默认值
if (definition != null && definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
// 获取连接对应的原始隔离级别
int currentIsolation = con.getTransactionIsolation();
// 如果原来的隔离级别和新的隔离级别不一样
if (currentIsolation != definition.getIsolationLevel()) {
// 保存原有的隔离级别
// 保存原有的隔离级别
previousIsolationLevel = currentIsolation;
// 设置新的隔离级别
con.setTransactionIsolation(definition.getIsolationLevel());
}
}
// 返回原有的隔离级别
return previousIsolationLevel;
}
// 经之前的隔离级别保存到事务对象中
txObject.setPreviousIsolationLevel(previousIsolationLevel);
// 保存当前事务的只读标识
txObject.setReadOnly(definition.isReadOnly());
// 当前连接是否自动提交
if (con.getAutoCommit()) {
// 设置需要还原自动提交的标识
txObject.setMustRestoreAutoCommit(true);
// 设置为手动提交
con.setAutoCommit(false);
}
// 预处理事务连接
prepareTransactionalConnection(con, definition);
{
// 如果事务标记只读,并且强制只读表示为true,默认值为false
if (isEnforceReadOnly() && definition.isReadOnly()) {
// 执行指令,设置当前事务为只读事务
try (Statement stmt = con.createStatement()) {
stmt.executeUpdate("SET TRANSACTION READ ONLY");
}
}
}
// 获取ConnectionHolder对象,设置事务正在活动
txObject.getConnectionHolder().setTransactionActive(true);
// 确定事务的超时时间
int timeout = determineTimeout(definition);
{
// 获取自己设置的超时时间
if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT) {
return definition.getTimeout();
}
// TransactionDefinition.TIMEOUT_DEFAULT = -1 不超时
return getDefaultTimeout();
}
// 如果超时时间不为默认的不超时
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
// 将超时时间设置到ConnectionHolder中
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// 判断当前的ConnectionHolder是不是新创建的,在创建ConnectionHolder的时候会传递一个true
if (txObject.isNewConnectionHolder()) {
// 如果是新的,那么将当前连接的ConnectionHolder绑定到事务同步管理器的资源集合中
TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
{
// 将数据源作为绑定资源的Key
Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
Map<Object, Object> map = resources.get();
// 如果不存在任何资源,初始化
if (map == null) {
map = new HashMap<>();
resources.set(map);
}
// 将当前线程连接资源保存到map中
Object oldValue = map.put(actualKey, value);
// 如果之前保存过值,并且值为ResourceHolder类型,并且是一个空的数据
if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
// 将资源回收
oldValue = null;
}
// 因为这里是新连接,所以如果之前就被绑定了值,那就是有异常了
if (oldValue != null) {
throw new IllegalStateException("Already value [" + oldValue + "] for key [" + actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
}
}
}
} catch (Throwable ex) {
// 如果出现异常
// ConnectionHolder是不是新创建的,在创建ConnectionHolder的时候会传递一个true
if (txObject.isNewConnectionHolder()) {
// 释放连接
DataSourceUtils.releaseConnection(con, obtainDataSource());
{
doReleaseConnection(con, dataSource);
{
if (dataSource != null) {
// 获取当前数据源绑定的资源值
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
// 如果存在绑定的值,并且绑定的值与当前连接是同一个
if (conHolder != null && connectionEquals(conHolder, con)) {
// 释放当前连接,重置conHolder的配置
conHolder.released();
return;
}
}
// 释放jdbc连接
doCloseConnection(con, dataSource);
{
if (!(dataSource instanceof SmartDataSource) || ((SmartDataSource) dataSource).shouldClose(con)) {
con.close();
}
}
}
}
// 重置事务对象的ConnectionHolder
txObject.setConnectionHolder(null, false);
}
// 重置事务对象之后
// 抛出创建事务失败异常
throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
}
}
// 预处理事务,上面有该方法的详解
prepareSynchronization(status, definition);
// 返回创建的事务状态对象
return status;
} catch (RuntimeException | Error beginEx) {
// 内部事务开始失败后恢复外部事务
resumeAfterBeginException(transaction, suspendedResources, beginEx);
{
resume(transaction, suspendedResources);
{
// 如果前外层事务暂停成功,就会返回外层事务的resourcesHolder
if (resourcesHolder != null) {
// 获取暂停的资源值
Object suspendedResources = resourcesHolder.suspendedResources;
// 如果绑定了资源值
if (suspendedResources != null) {
// 恢复事务,将暂停的时候保存的资源继续绑定进去
doResume(transaction, suspendedResources);
{
// 继续绑定当前资源
TransactionSynchronizationManager.bindResource(obtainDataSource(), suspendedResources);
}
}
// 获取到被暂停的所有事务信息,因为一个业务,一个线程可能开启了N多事务
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);
}
}
}
}
throw beginEx;
}
}
// 如果传播行为为嵌套事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// 如果不支持嵌套事务,抛出异常
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException();
}
// 判断对嵌套事务是否使用保存点,默认返回true
if (useSavepointForNestedTransaction()) {
// 预处理事务状态,上面有讲解
DefaultTransactionStatus status = prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
// 给当前状态创建一个保存点,并保存到事务状态中
status.createAndHoldSavepoint();
{
SavepointManager sm = getSavepointManager();
{
Object transaction = this.transaction;
// 如果事务对象,如果存在保存点的事务对象就必须是SavepointManager类型
if (!(transaction instanceof SavepointManager)) {
throw new NestedTransactionNotSupportedException("Transaction object [" + this.transaction + "] does not support savepoints");
}
return (SavepointManager) transaction;
}
// 创建保存点
Object sp = sm.createSavepoint();
{
// 获取连接的持有对象
ConnectionHolder conHolder = getConnectionHolderForSavepoint();
return conHolder.createSavepoint();
{
// 保存点+1
this.savepointCounter++;
// 获取连接对象创建保存点
return getConnection().setSavepoint(SAVEPOINT_NAME_PREFIX + this.savepointCounter);
}
}
// 设置保存点信息
setSavepoint(sp);
}
return status;
} else {
// 其他的传播行为
// 是否是新事务
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 封装成事务状态对象
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);
// 开启事务,上面有讲解
doBegin(transaction, definition);
// 预处理事务同步信息
prepareSynchronization(status, definition);
return status;
}
}
// 是否要验证已存在的事务信息,默认为false
if (isValidateExistingTransaction()) {
// 如果隔离级别不为为默认值
if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
// 获取当前事务的隔离级别
Integer currentIsolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
// 如果当前隔离级别为null,获取当前隔离级别不等于定义的隔离级别,表示在别的地方改了隔离级别,导致隔离级别不同步
if (currentIsolationLevel == null || currentIsolationLevel != definition.getIsolationLevel()) {
// 抛出异常
Constants isoConstants = DefaultTransactionDefinition.constants;
throw new IllegalTransactionStateException("Participating transaction with definition");
}
}
// 如果事务不是只读的
if (!definition.isReadOnly()) {
// 但是当前事务同步管理器保存当前事务的信息为只读,表示只读也被暗改了,抛出异常
if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
throw new IllegalTransactionStateException("Participating transaction with definition [" + definition + "] is not marked as read-only but existing transaction is");
}
}
}
// 判断是否是新的事务
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 预处理事务信息,上面有讲解
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}
}
// 检查新事务的定义设置,如果定义的超时时间,小于默认的超时时间(-1),表示时间是无效的
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
// 如果传播行为为强制要有事务,如果没有事务抛出异常\
// 上面如果当前已存在事务,在上面就会按照已存在事务的逻辑处理
// 到了之前,表示之前没有存在的饰物,就要报错,PROPAGATION_MANDATORY表示要运行在已存在的事务中
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
throw new IllegalTransactionStateException();
}
// 如果传播行为为下面几种,表示需要开启事务
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
// 暂停当前事务,上面有讲解该方法,并且返回暂停之前的事务信息
SuspendedResourcesHolder suspendedResources = suspend(null);
try {
// 下面逻辑在上面都有详细解析
// 是否是新事务
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 封装成事务状态
DefaultTransactionStatus status = newTransactionStatus(def, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 开始事务
doBegin(transaction, def);
// 预处理事务
prepareSynchronization(status, def);
return status;
} catch (RuntimeException | Error ex) {
// 恢复当前事务信息
resume(null, suspendedResources);
throw ex;
}
}
// 除了PROPAGATION_REQUIRED,PROPAGATION_REQUIRES_NEW,PROPAGATION_NESTED这三中传播行为
// 其他的都不需要创建开启新的事物
else {
// 判断是否是新事物
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 预处理事物状态,封装成事物状态对象
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
}
}
}
}
// 预处理事物信息,封装成事物信息对象
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
{
// 将事务管理器,事务属性,和方法签名封装成事务信息对象
TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
// 如果存在事务属性
if (txAttr != null) {
// 将事务状态保存到事务信息中
txInfo.newTransactionStatus(status);
}
// 将事务信息绑定到当前线程
txInfo.bindToThread();
{
// 从ThreadLocal中获取原有的事务信息
this.oldTransactionInfo = transactionInfoHolder.get();
// 设置为当前的事务信息
transactionInfoHolder.set(this);
}
return txInfo;
}
}
Object retVal;
try {
// 执行回调函数,这个的回调是是一个lambda
// 是org.springframework.aop.framework.ReflectiveMethodInvocation.proceed的变种
// 也就是这个invocation.proceedWithInvocation();就是触发ReflectiveMethodInvocation.proceed的执行
// 在Spring中JDK动态代理和CBLIB代理的拦截逻辑有详细讲解
retVal = invocation.proceedWithInvocation();
} catch (Throwable ex) {
// 如果执行目标方法中存在异常
completeTransactionAfterThrowing(txInfo, ex);
{
// 如果存在事务信息,并且创建了事务状态(创建了事务)
if (txInfo != null && txInfo.getTransactionStatus() != null) {
// 获取事务属性,以及事务属性中设置的回滚异常标识
// 如果当前异常与事务属性设置的异常符合条件,需要进行回滚
// rollbackOn: return (ex instanceof RuntimeException || ex instanceof Error);
if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) {
try {
// 调用事务管理器进行回滚
// 将事务状态信息传递
txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());
{
// 如果已经提交了
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);
{
try {
boolean unexpectedRollback = unexpected;
try {
// 触发提交之前的回调方法
triggerBeforeCompletion(status);
{
// 如果当前事务状态是一个新的事物
if (status.isNewSynchronization()) {
// 获取当前线程绑定到事务同步管理器中的所有事务
// 并且执行这些事务的提交之前的回调方法
TransactionSynchronizationUtils.triggerBeforeCompletion();
}
}
// 如果存在保存点,表示是嵌套事务
if (status.hasSavepoint()) {
// 将状态
status.rollbackToHeldSavepoint();
{
Object savepoint = getSavepoint();
// 获取保存点管理器,回滚
getSavepointManager().rollbackToSavepoint(savepoint);
{
// 获取到连接
ConnectionHolder conHolder = getConnectionHolderForSavepoint();
// 回滚到保存点
conHolder.getConnection().rollback((Savepoint) savepoint);
// 重置当前仅回滚标识,可能在之前逻辑设置了当前事务仅回滚
// 回滚之后要重置标识
conHolder.resetRollbackOnly();
}
// 重置保存点
getSavepointManager().releaseSavepoint(savepoint);
{
conHolder.getConnection().releaseSavepoint((Savepoint) savepoint);
}
// 删除保存点
setSavepoint(null);
}
}
// 如果不是嵌套事务
// 是一个新事务
else if (status.isNewTransaction()) {
// 回滚
doRollback(status);
{
// 获取到事务对象
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
// 获取到jdbc连接
Connection con = txObject.getConnectionHolder().getConnection();
// 回滚
con.rollback();
}
}
// 如果不是一个新事物,表示之前已经存在事务
else {
// 当前是否存在事务
if (status.hasTransaction()) {
// 如果当前事务标记了仅回滚,并且全局事务的仅回滚标识为true,默认为true
if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
// 设置当前事务为仅状态
doSetRollbackOnly(status);
{
// 获取对事务对象
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
if (status.isDebug()) {
logger.debug("Setting JDBC transaction [" + txObject.getConnectionHolder().getConnection() + "] rollback-only");
}
// 设置当前事务为仅回滚
txObject.setRollbackOnly();
}
}
}
// 如果事务被全局标记为仅回滚，则返回是否提前失败
if (!isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = false;
}
}
} catch (RuntimeException | Error ex) {
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
throw ex;
}
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
// 如果有意想不到的异常,则抛出异常,这个是外部传递过来的
if (unexpectedRollback) {
throw new UnexpectedRollbackException("Transaction rolled back because it has been marked as rollback-only");
}
} finally {
// 提交之后,清理逻辑
cleanupAfterCompletion(status);
{
// 设置当前事务已经提交
status.setCompleted();
// 如果是新事物同步信息
if (status.isNewSynchronization()) {
// 情况当前事物的所有配置
TransactionSynchronizationManager.clear();
}
// 如果是新事物对象信息
if (status.isNewTransaction()) {
// 清理事务对象
doCleanupAfterCompletion(status.getTransaction());
{
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 如果是新的连接
if (txObject.isNewConnectionHolder()) {
// 解绑当前绑定的值(连接Hodler对象)
TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
// 获取连接对象
Connection con = txObject.getConnectionHolder().getConnection();
// 重置为自动提交
if (txObject.isMustRestoreAutoCommit()) {
con.setAutoCommit(true);
}
// 恢复原来的连接状态
DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel(), txObject.isReadOnly());
{
con.setTransactionIsolation(previousIsolationLevel);
con.setReadOnly(false);
}
// 如果是新的连接
if (txObject.isNewConnectionHolder()) {
// 释放连接,上面有详细解释
DataSourceUtils.releaseConnection(con, this.dataSource);
}
// 重置连接信息配置
txObject.getConnectionHolder().clear();
}
}
// 如果存在暂停的事务资源
if (status.getSuspendedResources() != null) {
// 获取到事务对象
Object transaction = (status.hasTransaction() ? status.getTransaction() : null);
// 恢复事务
resume(transaction, (SuspendedResourcesHolder) status.getSuspendedResources());
}
}
}
}
}
} catch (TransactionSystemException ex2) {
throw ex2;
} catch (RuntimeException | Error ex2) {
throw ex2;
}
}
// 非Error和非RuntimeException,提交事务
else {
try {
// 提交事务
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus()) {
// 如果已经提交了
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()) {
// 执行回滚逻辑,上面有详细讲解
processRollback(defStatus, false);
return;
}
// shouldCommitOnGlobalRollbackOnly:默认值为false
// 如果当前状态标记了整个大事务全局回滚,则进行回滚
// 这里是判断整个事务中,是否有被标记了仅回滚的事务,因为一次可能存在多个事务的情况,只要有一个事务被标记了,那么所有的事务将回滚
if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly() {
// 当事务类型是SmartTransactionObject,其中DataSourceTransactionObject就是这种类型
// 并且给txObject设置了RollbackOnly
// 因为this.transaction.isRollbackOnly()实际上获取的是return getConnectionHolder().isRollbackOnly();
// 而已存在的ConnectionHolder是会被绑定到当前线程的资源中,如果一个或者多个事务中,并没有将这些事务隔离,那么其他事务获取到的也是同一个ConnectionHolder
// 所以最终共享这个回滚的变量,有一个事务设置了,那么整个事务将被回滚
return ((this.transaction instanceof SmartTransactionObject) && ((SmartTransactionObject) this.transaction).isRollbackOnly());
}){
// 回滚
processRollback(defStatus, true);
return;
}
// 提交事务
processCommit(defStatus);
{
try {
boolean beforeCompletionInvoked = false;
try {
boolean unexpectedRollback = false;
// 预处理提交信息,默认空实现
prepareForCommit(status);
// 触发提交之前的所有事务回调
triggerBeforeCommit(status);
// 触发完成之前的所有事务回调
triggerBeforeCompletion(status);
// 回调执行完毕标识
beforeCompletionInvoked = true;
// 如果是嵌套事务,存在保存点
if (status.hasSavepoint()) {
unexpectedRollback = status.isGlobalRollbackOnly();
// 重置保存点
status.releaseHeldSavepoint();
{
Object savepoint = getSavepoint();
getSavepointManager().releaseSavepoint(savepoint);
setSavepoint(null);
}
}
// 如果是新事务
else if (status.isNewTransaction()) {
unexpectedRollback = status.isGlobalRollbackOnly();
// 提交事务
doCommit(status);
{
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
Connection con = txObject.getConnectionHolder().getConnection();
con.commit();
}
} else if (isFailEarlyOnGlobalRollbackOnly()) {
unexpectedRollback = status.isGlobalRollbackOnly();
}
// 如果全局回滚,则抛出异常,但是事务已经提交了
if (unexpectedRollback) {
throw new UnexpectedRollbackException("Transaction silently rolled back because it has been marked as rollback-only");
}
} catch (UnexpectedRollbackException ex) {
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
throw ex;
} catch (TransactionException ex) {
// 在调用commit的时候失败,是否需要调用回滚
// 默认为false
if (isRollbackOnCommitFailure()) {
// 提交出现异常执行回滚
doRollbackOnCommitException(status, ex);
{
try {
// 如果是新事务,直接回滚
if (status.isNewTransaction()) {
// 上面有详解
doRollback(status);
}
// 如果存在事务,并且标记了全局事务回滚
else if (status.hasTransaction() && isGlobalRollbackOnParticipationFailure()) {
// 标记当前事务为仅回滚
doSetRollbackOnly(status);
}
} catch (RuntimeException | Error rbex) {
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
throw rbex;
}
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
}
} else {
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
}
throw ex;
} catch (RuntimeException | Error ex) {
// beforeCompletion已经执行过的标识
// 如果未执行过,标识执行之前出现了异常
if (!beforeCompletionInvoked) {
// 触发完成之前的所有事务回调
triggerBeforeCompletion(status);
}
// 提交出现异常执行回滚,上面有详解
doRollbackOnCommitException(status, ex);
throw ex;
}
try {
// 触发所有事务信息提交之后的回调
triggerAfterCommit(status);
} finally {
// 触发当前事务同步管理器保存的当前线程所有的事务提交之后的回调
triggerAfterCompletion(status, TransactionSynchronization.STATUS_COMMITTED);
}
} finally {
// 提交之后,清理逻辑,上面有讲解
cleanupAfterCompletion(status);
}
}
} ;
} catch (TransactionSystemException ex2) {
throw ex2;
} catch (RuntimeException | Error ex2) {
throw ex2;
}
}
}
}
throw ex;
} finally {
// 清理事务信息
cleanupTransactionInfo(txInfo);
{
if (txInfo != null) {
txInfo.restoreThreadLocalStatus();
{
// 还原之前的事务状态信息
transactionInfoHolder.set(this.oldTransactionInfo);
}
}
}
}
// 正常返回的情况下提交事务
commitTransactionAfterReturning(txInfo);
{
// 如果存在事务信息,并且存在事务状态
if (txInfo != null && txInfo.getTransactionStatus() != null) {
// 获取事务管理器提交事务,上面有详细讲解
txInfo.getTransactionManager().commit(txInfo.getTransactionStatus());
}
}
// 返回执行结果
return retVal;
} else {
final ThrowableHolder throwableHolder = new ThrowableHolder();
// 事务属性不为空,并且事务管理器为CallbackPreferringPlatformTransactionManager类型
try {
// 调用事务管理器的execute方法,开始执行
Object result = ((CallbackPreferringPlatformTransactionManager) ptm).execute(txAttr, status -> {
// 预处理事务信息,上面有讲过
TransactionInfo txInfo = prepareTransactionInfo(ptm, txAttr, joinpointIdentification, status);
try {
// 执行回调函数,这个的回调是是一个lambda
// 是org.springframework.aop.framework.ReflectiveMethodInvocation.proceed的变种
// 也就是这个invocation.proceedWithInvocation();就是触发ReflectiveMethodInvocation.proceed的执行
// 在Spring中JDK动态代理和CBLIB代理的拦截逻辑有详细讲解
Object retVal = invocation.proceedWithInvocation();
return retVal;
} catch (Throwable ex) {
if (txAttr.rollbackOn(ex)) {
if (ex instanceof RuntimeException) {
throw (RuntimeException) ex;
} else {
throw new ThrowableHolderException(ex);
}
} else {
throwableHolder.throwable = ex;
return null;
}
} finally {
// 清理事务信息,上面有讲
cleanupTransactionInfo(txInfo);
}
});
if (throwableHolder.throwable != null) {
throw throwableHolder.throwable;
}
return result;
} catch (ThrowableHolderException ex) {
throw ex.getCause();
} catch (TransactionSystemException ex2) {
throw ex2;
} catch (Throwable ex2) {
throw ex2;
}
}
}
;
}
}
Transactional事务注解实现原理
于 2024-03-05 16:30:44 首次发布
博客围绕Java开发语言展开，但具体内容缺失。Java是重要的后端开发语言，应用广泛。
扫一扫
247
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
