Spring事务源码解析（二）获取增强

最新推荐文章于 2023-04-01 19:40:46 发布
最新推荐文章于 2023-04-01 19:40:46 发布
阅读量227 收藏
点赞数
分类专栏： Spring源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/javaxuexilu/article/details/100738699
版权


在上一篇文章@EnableTransactionManagement注解解析中，我们搭建了源码阅读的环境，以及解析了开启Spring事务功能的注解@EnableTransactionManagement的实现逻辑

在进行接下来的源码解析之前我想大家应该知道，当我们使用传统的jdbc应用事务的时候是不是做了如下操作：

  1. 开启事务

  2. save、update、delete等操作

  3. 出现异常进行回滚

  4. 正常情况提交事务

而在Spring中我们好像只需要关心第三步，也就是我们的业务，而其他的操作都不需要关心。那么我想你应该猜到了Spring是如何实现的呢？
答案就是基于@Transactional注解的SpringAOP实现，在接着往下阅读本篇文章的时候希望您对于SpringAOP的源码有一定的了解，如果不了解可以参考如下文章：

  1. 基于注解的SpringAOP源码解析（一）

  2. 基于注解的SpringAOP源码解析（二）

  3. 基于注解的SpringAOP源码解析（三）

获取增强

在阅读完AOP的原理之后，我们知道，当一个bean实例化之后会尝试获取所有适用于此Bean的增强。而在上篇文章中，我们已经发现了，@EnableTransactionManagement注解会往Spring中注入一个增强BeanFactoryTransactionAttributeSourceAdvisor。经过一番代码调用以后，会进入这么一个方法，这里的第一个入参就是BeanFactoryTransactionAttributeSourceAdvisor增强

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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) {
	Assert.notNull(pc, "Pointcut must not be null");
	if (!pc.getClassFilter().matches(targetClass)) {
		return false;
	}
	MethodMatcher methodMatcher = pc.getMethodMatcher();
	if (methodMatcher == MethodMatcher.TRUE) {
		return true;
	}

	IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
	if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
		introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
	}

	Set<Class<?>> classes = new LinkedHashSet<>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
	classes.add(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;
			}
		}
	}

	return false;
}

到这里的时候就进入事务相关的类TransactionAttributeSourcePointcut，看名字就能知道，这是个切点类.那么接下来的逻辑应该可以想象到，无非就是判断是否是个事务方法

1
2
3
4
5
6
7
public boolean matches(Method method, @Nullable Class<?> targetClass) {
		if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
			return false;
		}
		TransactionAttributeSource tas = getTransactionAttributeSource();
		return (tas == null || tas.getTransactionAttribute(method, targetClass) != null);
	}

如果是事务方法则继续往下走

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public TransactionAttribute getTransactionAttribute(Method method,
      @Nullable Class<?> targetClass) {
    // 如果当前方法是Object类中的方法，则直接返回
    if (method.getDeclaringClass() == Object.class) {
        return null;
    }

    // 获取当前方法缓存使用的key
    Object cacheKey = getCacheKey(method, targetClass);
    Object cached = this.attributeCache.get(cacheKey);
    // 从缓存中获取当前方法解析的事务属性，如果解析过，则将解析结果返回
    if (cached != null) {
        if (cached == NULL_TRANSACTION_ATTRIBUTE) {
            return null;
        } else {
            return (TransactionAttribute) cached;
        }
    } else {
        // 解析当前方法的事务属性，这里很重要，下面说
        TransactionAttribute txAttr = computeTransactionAttribute(method, targetClass);
        if (txAttr == null) {
            // 如果当前方法上没有事务属性，则缓存一个表示空事务属性的对象
            this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
        } else {
            // 获取方法的签名
            String methodIdentification =
                ClassUtils.getQualifiedMethodName(method, targetClass);
            // 如果生成的事务属性是DefaultTransactionAttribute类型的，则将方法签名设置到其descriptor属性中
            if (txAttr instanceof DefaultTransactionAttribute) {
                ((DefaultTransactionAttribute) txAttr)
                    .setDescriptor(methodIdentification);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Adding transactional method '" + methodIdentification
                             + "' with attribute: " + txAttr);
            }
            // 缓存当前方法的解析结果
            this.attributeCache.put(cacheKey, txAttr);
        }
        return txAttr;
    }
}

接着看一下方法的事务属性是如何解析的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
protected TransactionAttribute computeTransactionAttribute(Method method,
       @Nullable Class<?> targetClass) {
    // 如果设置了只对public方法进行事务代理，并且当前方法不是public的，则返回null
    if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
        return null;
    }

    Class<?> userClass = (targetClass != null ?
        ClassUtils.getUserClass(targetClass) : null);
    // 获取最为准确的方法，即如果传入的method只是一个接口方法，则会去找其实现类的同一方法进行解析
    Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
    // 如果当前方法是一个泛型方法，则会找Class文件中实际实现的方法
    specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
    // 解析目标方法，获取其是否存在事务属性，如果存在则直接返回
    TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
    if (txAttr != null) {
        return txAttr;
    }

    // 解析目标方法所在的类，判断其是否标注有事务属性，如果存在，并且目标方法是用户实现的方法，则直接返回
    txAttr = findTransactionAttribute(specificMethod.getDeclaringClass());
    if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
        return txAttr;
    }

    // 如果通过解析到的方法无法找到事务属性，则判断解析得到的方法与传入的目标方法是否为同一个方法，
    // 如果不是同一个方法，则尝试对传入的方法及其所在的类进行事务属性解析
    if (specificMethod != method) {
        // 对传入方法解析事务属性，如果存在，则直接返回
        txAttr = findTransactionAttribute(method);
        if (txAttr != null) {
            return txAttr;
        }

        // 对传入方法所在类进行事务属性解析，如果存在，则直接返回
        txAttr = findTransactionAttribute(method.getDeclaringClass());
        if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
            return txAttr;
        }
    }

    return null;
}

这里对事务属性的解析主要分为对目标方法进行解析和对传入方法进行解析，接着看findTransactionAttribute方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
protected TransactionAttribute findTransactionAttribute(Method method) {
		return determineTransactionAttribute(method);
	}
	protected TransactionAttribute determineTransactionAttribute(AnnotatedElement ae) {
		for (TransactionAnnotationParser annotationParser : this.annotationParsers) {
			TransactionAttribute attr = annotationParser.parseTransactionAnnotation(ae);
			if (attr != null) {
				return attr;
			}
		}
		return null;
	}
	public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
		AnnotationAttributes attributes = AnnotatedElementUtils.findMergedAnnotationAttributes(
				ae, Transactional.class, false, false);
		if (attributes != null) {
			return parseTransactionAnnotation(attributes);
		}
		else {
			return null;
		}
	}
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
    // 判断目标方法上是否存在@Transactional注解，如果不存在，则直接返回
    AnnotationAttributes attributes = AnnotatedElementUtils
        .findMergedAnnotationAttributes(ae, Transactional.class, false, false);
    if (attributes != null) {
        // 如果目标方法上存在@Transactional注解，则获取注解值，并且封装为TransactionAttribute返回
        return parseTransactionAnnotation(attributes);
    } else {
        return null;
    }
}

protected TransactionAttribute parseTransactionAnnotation(
        AnnotationAttributes attributes) {
    RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();
    // 获取注解上的propagation值
    Propagation propagation = attributes.getEnum("propagation");
    rbta.setPropagationBehavior(propagation.value());
    // 获取注解上的isolation属性值
    Isolation isolation = attributes.getEnum("isolation");
    rbta.setIsolationLevel(isolation.value());
    // 获取注解上的timeout属性值
    rbta.setTimeout(attributes.getNumber("timeout").intValue());
    // 获取注解上的readOnly属性值
    rbta.setReadOnly(attributes.getBoolean("readOnly"));
    // 获取注解上的value属性值
    rbta.setQualifier(attributes.getString("value"));
    ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<>();
    // 获取注解上的rollbackFor属性列表
    Class<?>[] rbf = attributes.getClassArray("rollbackFor");
    for (Class<?> rbRule : rbf) {
        RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    // 获取注解上的rollbackForClassName属性列表
    String[] rbfc = attributes.getStringArray("rollbackForClassName");
    for (String rbRule : rbfc) {
        RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    // 获取注解上的noRollbackFor属性列表
    Class<?>[] nrbf = attributes.getClassArray("noRollbackFor");
    for (Class<?> rbRule : nrbf) {
        NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    // 获取注解上的noRollbackForClassName属性列表
    String[] nrbfc = attributes.getStringArray("noRollbackForClassName");
    for (String rbRule : nrbfc) {
        NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule);
        rollBackRules.add(rule);
    }
    rbta.getRollbackRules().addAll(rollBackRules);
    return rbta;
}

可以看到这里已经把方法上或者类上的@Transactional注解的属性封装成TransactionAttribute返回了，关于@Transactional注解的更多知识可参考我的这篇文章：
Spring@Transactional注解

640?wx_fmt=jpeg


javaxuexilu
关注
专栏目录
《Spring》第二十一篇 事务底层源码解析
入坑太深起不来
02-09 346
一.事务的底层执行原理 1. 解析注解@EnableTransactionManagement 2. Bean生命周期的初始化后阶段,校验是否需要进行AOP 3. 示例FruitsService已经成功生成,并注册到IOC容器中,此时执行pay()方法 二. 事务的传播机制
Spring 5.x 源码之旅-18getBean详解四
最新发布
smart_an的专栏
03-04 877
clazz) {if (clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {//如果包含CGLIB的名字符号，尝试获取父类Class
SpringMVC 源码解析 - Controller 的扫描注册及匹配过程
小毕超博客
04-01 1686
源码梳理的文章中就分析过，但那次分析的确实不怎么详细，因此这里再继续梳理下，看是如何和上面注册的过程形成呼应的。对应一个接口，如果这里匹配出多个并且一致的话，则会抛出异常，否则最后返回匹配出来的。，其作用是在容器启动后将系统中所有控制器方法的请求条件和控制器方法的对应关系注册到。路径，接着尝试获取映射存储器的读锁，主要防止有写的情况造成线程安全问题，拿到锁后通过。会根据请求条件和容器中存储的系统接口信息比对，再执行对应的控制器方法，从而帮助。，我们要通过反射执行方法的话，是需要目标对象的，因此在。
Spring中的各种Utils（四）：ClassUtils详解
热门推荐
wolfcode_cn的博客
06-12 2万+
原创文章，转载请注明出处本节中主要介绍ClassUtils，这是关于类级别相关的工具类，虽然只是提供给Spring框架内部使用，但是很多方法还是有一定使用价值，并且理解这些方法的实现，也是有一定价值的。首先ClassUtils是一个非常大的工具类，提供了很多缓存数据和初始化内容，在涉及到相关方法的时候，再介绍。ClassLoader getDefaultClassLoader()该方法用于获取默认...
实例化bean中有@Autowired注解的有参构造函数（二）
nandao158的博客
07-13 1273
实例化bean中有@Autowired注解的有参构造函数
Spring源码学习（七）-- 依赖注入源码解析（上）
学习笔记
11-03 721
Spring中到底有几种依赖注入的方式？ 首先分两种： 手动注入 自动注入 手动注入 在XML中定义Bean时，就是手动注入，因为是程序员手动给某个属性指定了值。 <bean name="userService" class="com.fztx.service.UserService"> <property name="orderService" ref="orderService"/> </bean> 上面这种底层是通过set方法进行注入。 &lt
Spring 事务源码解析
寒武没有纪
09-14 1217
准备 Spring版本：5.0.8 解析过程 标签解析分析 事务注解驱动标签 &lt;tx:annotation-driven/&gt; 解析，首先定位到 TxNamespaceHandler // TxNamespaceHandler public void init() { registerBeanDefinitionParser("advice", new TxAdv...
Spring AOP源码详细解析
pengjianglilive的专栏
11-10 3312
一 . 以下是bean的初始化过程: 注意: 先明白beanPostProcessor的作用,才能够明白aop的加载时机 在bean实例化完成之前和完成之后分别会自动BeanPostProcessor接口的postProcessBeforeInitialization和postProcessAfterInitialization方法。 二: 介绍一些Spring Aop中一些核心类，大致分为三类： advisorCreator，继承 spring ioc的扩展接口 beanPos...
Spring源码解析
xiang_yu_pai的博客
04-10 2313
一、IOC过程 第一步：xml配置文件 第二步：使用工厂类 第三步：通过反射创建类 二、IOC接口 1.BeanFactory：IOC基本实现，Spring内部使用，不提供给开发人员使用。加载配置文件时不创建对象 2.ApplicationContext：BeanFactory的子接口，功能更强大，加载配置文件随便创建对象 三、管理Bean对象 1.DI：依赖注入，配置属性 （1）通过set方法注入（通过在xml bean标签配置property属性，也是通过set方法注入的） （2）通过构造器注入（通过在
第八节-spring-事物源码解析1
08-03
【Spring 事务源码解析】 在Spring框架中，事务管理是其核心功能之一，它确保了数据操作的完整性和一致性。本节将深入探讨Spring事务的源码解析，特别是涉及的事务概念、三大核心接口以及相关属性。 1. **事务概念...
MyBatis3源码阅读（二）2020-12-24
lujiedebaba的博客
12-15 597
SELECT的执行过程 前言 前一节我们通过源码认识了SqlSessionFactoryBuilder、SqlSessionFactory 和 SqlSession的创建过程，开胃菜算是尝过了，今天该开始吃正餐了,因为想把详细的过程呈现和记录下来，所以本篇有过多的截图，请保持耐心，我会在每一步下有详细的理解。 step1：得到sqlSession对象，创建与表users对应的pojo对象users，通过setUserName("king")赋值, 获取mapper接口对象，调用方法接口 测试代码如.
Java之.class和.getClass()的区别
LVXIANGAN的专栏
11-14 3841
class属性 当你要获得一个类的Class对象时（作函数参数的时候），你不能调用getClass方法，那你只能用类名.class来达到效果 例子： System.out.println(JButton.class);   输出： class javax.swing.JButtongetClass方法：该方法只能由类的实例变量调用 类型：public final Class&lt;? extend...
Spring事务源码（三）
mlplds的博客
12-01 190
Spring事务源码（三） 一、开始，看过我前面Aop源码的朋友，对于事务整个流程应该非常熟悉 二、源码分析，本章只分析寻找符合条件的增强器这一块源码findAdvisorsThatCanApply，对于寻找增强器的源码findCandidateAdvisors请参照博客https://blog.csdn.net/mlplds/article/details/103145409 protecte...
Spring 50例常见错误（十六）
weixin_44513658的博客
06-24 1099
Spring 50例常见错误 案例40-41，案例40：事务默认捕获的异常 RuntimeException 、Error；案例 38：不适用的默认配置；案例41：试图给 private 方法添加事务
SpringCloud Alibaba系列——12Dubbo的RPC通讯原理
Eclipse_2019的博客
08-04 1177
Dubbo的RPC通讯流程推导；Dubbo的RPC通讯原理
SpringTransaction源码解析（下）
恐龙弟旺仔的博客
08-24 2263
前言：     通过上一篇博客 https://blog.csdn.net/qq_26323323/article/details/81948682 的分析， 我们从大的结构上分析了Spring事务的实现方式。     主要从通过Spring代理生成代理类，然后通过执行TransactionInterceptor.invoke()方法，来完成Spring事务控制。     本文主要来分析Tr...
Spring 事务源码分析
技术分享、唠嗑水文、如有不周、还望海涵
11-14 753
内容来自【自学星球】欢迎大家来了解我的星球，和星主（也就是我）一起学习 Java ，深入 Java 体系中的所有技术。我给自己定的时间是一年，无论结果如何，必定能给星球中的各位带来点东西。
spring aop 一本正经的胡说八道笔记
枕簟、冷秋
08-20 918
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
Retrofit 动态代理+反射 基本原理
Android_小牧的博客
08-31 482
retrofit = new Retrofit.Builder().baseUrl("https://www.httpbin.org/").build(); httpbinService = retrofit.create(HttpbinService.class); public <T> T create(final Class<T> service) { validateServiceInterface(service); return (T) ..
Spring事务源码解析：XML配置与AOP增强机制
Spring事务的源码分析揭示了其对依赖注入和AOP的强大整合，通过解析XML配置和运行时的动态代理机制，提供了灵活且强大的事务管理能力。理解这些核心源码有助于开发者更深入地掌握Spring框架，并在实际项目中更好地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值