登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›一文学习 Spring 声明式事务源码全流程总结 ...

一文学习 Spring 声明式事务源码全流程总结

米嘉怡 昨天 23:15
猛犸象科技工作室:网站开发，备案域名，渗透，服务器出租，DDOS/CC攻击，TG加粉引流
Spring 声明式事务源码学习全过程

in short 四步走

  • Srping 如何从配置中加载的入口
  • Spring 声明式事务的相关的 BeanDefinition加载流程
  • Spring 声明式事务的相关对象创建流程
  • Spring 声明式事务的拦截调用的过程(包括: 方法嵌套, 事务传播属性的处理过程)
最后再看看第三方的框架是如何支持 Spring 声明式事务, 给Spring 托管事务的
一、Spring 声明式事务的入口点

对于XML入口点

XML配置定义
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.            xmlns:aop="http://www.springframework.org/schema/aop"
  5.            xmlns:tx="http://www.springframework.org/schema/tx"
  6.            xsi:schemaLocation="
  7.                 http://www.springframework.org/schema/beans
  8.                 https://www.springframework.org/schema/beans/spring-beans.xsd
  9.                 http://www.springframework.org/schema/tx
  10.                 https://www.springframework.org/schema/tx/spring-tx.xsd
  11.                 http://www.springframework.org/schema/aop
  12.                 https://www.springframework.org/schema/aop/spring-aop.xsd">
  13.         <tx:annotation-driven></tx:annotation-driven>
  15.        
  16.         <bean id="jdbcTemplate"  >
  17.                 <property name="dataSource" ref = "dataSource"></property>
  18.         </bean>
  20.        
  21.         <bean id="bookService"  >
  22.                 <property name="jdbcTemplate" ref="jdbcTemplate"></property>
  23.         </bean>
  24.        
  25.         <bean id="dataSource"  >
  26.                 <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
  27.                 <property name="url"
  28.        
  29.        
  30.        
  31.        
  32. </aop:config>  value="jdbc:mysql://192.168.40.171:3306/workflow_test?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useSSL=false"/>
  33.                 <property name="username" value="user_dev"></property>
  34.                 <property name="password" value="dev-sny.com"></property>
  35.         </bean>
  36.        
  37.         <bean id="transactionManager"  >
  38.                 <constructor-arg ref="dataSource"></constructor-arg>
  39.         </bean>
  40.        
  41.                
  42.                
  43.                
  44.                
  45.         </aop:config>
  47.         <tx:advice id="txAdvice" transaction-manager="transactionManager">
  48.                 <tx:attributes>
  49.                         <tx:method name="get*" read-only="true"/>
  50.                         <tx:method name="insertWithTransaction" propagation="REQUIRED" />
  51.                         <tx:method name="insertWithNoTransaction" propagation="NEVER" />
  52.                 </tx:attributes>
  53.         </tx:advice>
  54. </beans>
复制代码
在XML中配置 tx:.. 启用tx标签, 在解析XML自定义标签时, 会拿到 TxNamespaceHandler 命名空间处理器, 其主要工作就是注册事务相关的标签的解析器

  • tx:advice 标签解析器：负责XML相关的标签解析 TxAdviceBeanDefinitionParser
  • tx:annotation-driven 标签解析器：负责注解相关的解析 AnnotationDrivenBeanDefinitionPar
org.springframework.transaction.config.TxNamespaceHandler
  1. public class TxNamespaceHandler extends NamespaceHandlerSupport {
  3.         static final String TRANSACTION_MANAGER_ATTRIBUTE = "transaction-manager";
  5.         static final String DEFAULT_TRANSACTION_MANAGER_BEAN_NAME = "transactionManager";
  8.         static String getTransactionManagerName(Element element) {
  9.                 return (element.hasAttribute(TRANSACTION_MANAGER_ATTRIBUTE) ?
  10.        
  11.        
  12.        
  13.        
  14. </aop:config>element.getAttribute(TRANSACTION_MANAGER_ATTRIBUTE) : DEFAULT_TRANSACTION_MANAGER_BEAN_NAME);
  15.         }
  18.         @Override
  19.         public void init() {
  20.                 //  <tx:advice> 标签解析器：负责解析XML <tx:advice> 事务标签配置 TxAdviceBeanDefinitionParser
  21.                 registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
  22.                 //  <tx:annotation-driven> 标签解析器：负责解析注解相关的事务配置 AnnotationDrivenBeanDefinitionParser
  23.                 registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
  24.                 // JTA 规范的分布式事务管理器(管理跨多个资源的事务) TODO
  25.                 registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
  26.         }
  27. }
复制代码
启用事务注解支持
  1. class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
  3.         /**
  4.          * Parses the {@code <tx:annotation-driven/>} tag. Will
  5.          * {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
  6.          * with the container as necessary.
  7.          */
  8.         @Override
  9.         @Nullable
  10.         public BeanDefinition parse(Element element, ParserContext parserContext) {
  11.                 registerTransactionalEventListenerFactory(parserContext);
  12.                 String mode = element.getAttribute("mode");
  13.                 if ("aspectj".equals(mode)) {
  14.                         // mode="aspectj"
  15.                         registerTransactionAspect(element, parserContext);
  16.                         if (ClassUtils.isPresent("jakarta.transaction.Transactional", getClass().getClassLoader())) {
  17.        
  18.        
  19.        
  20.        
  21. </aop:config>registerJtaTransactionAspect(element, parserContext);
  22.                         }
  23.                 }
  24.                 else {
  25.                         // 默认是  proxy 模式
  26.                         // mode="proxy"
  27.                         AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
  28.                 }
  29.                 return null;
  30.         }
  31.        
复制代码
注册三剑客
  1. /**
  2. * Inner class to just introduce an AOP framework dependency when actually in proxy mode.
  3. */
  4. private static class AopAutoProxyConfigurer {
  6.         public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
  7.                 AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
  9.                 String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
  10.                 if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
  11.                         Object eleSource = parserContext.extractSource(element);
  13.                         // Create the TransactionAttributeSource definition.
  14.                         RootBeanDefinition sourceDef = new RootBeanDefinition(
  15.        
  16.        
  17.        
  18.        
  19. </aop:config>        "org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
  20.                         sourceDef.setSource(eleSource);
  21.                         sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  22.                         String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);
  24.                         // Create the TransactionInterceptor definition.
  25.                         RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
  26.                         interceptorDef.setSource(eleSource);
  27.                         interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  28.                         registerTransactionManager(element, interceptorDef);
  29.                         interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
  30.                         String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);
  32.                         /**
  33.                          * 其中构建事务增强器(BeanFactoryTransactionAttributeSourceAdvisor)
  34.                          * - **Pointcut（切点）**: 默认匹配所有标注 `@Transactional` 的类 / 方法（由 `TransactionAttributeSourcePointcut` 实现）
  35.                          * - **Advice（通知）**: 即 `TransactionInterceptor`（事务拦截器）
  36.                          * - **TransactionAttributeSource（注解解析器）**:即 `AnnotationTransactionAttributeSource`, 负责解析 `@Transactional` 注解的属性（传播行为、隔离级别等）。
  37.                          */
  38.                         // Create the TransactionAttributeSourceAdvisor definition.
  39.                         RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
  40.                         advisorDef.setSource(eleSource);
  41.                         advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
  42.                         advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
  43.                         advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
  44.                         if (element.hasAttribute("order")) {
  45.        
  46.        
  47.        
  48.        
  49. </aop:config>advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
  50.                         }
  51.                         parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);
  53.                         CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
  54.                         compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
  55.                         compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
  56.                         compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
  57.                         parserContext.registerComponent(compositeDef);
  58.                 }
  59.         }
  60. }
复制代码
事务注解支持的三剑客


  • AnnotationTransactionAttributeSource
    ↓（解析注解）
  • TransactionInterceptor
    ↓（执行事务逻辑）
  • BeanFactoryTransactionAttributeSourceAdvisor
    ↓（组装切点+通知）
总结一下XML入口, 就是无论 xml 支持 还是注解支持都会构造 org.springframework.transaction.interceptor.TransactionInterceptor 这个核心 advice 事务拦截器
对于注解的入口
  1. @EnableTransactionManagement
  2. public class TXMain {
  4.         @Transactional
  5.         public static void main(String[] args) throws Exception {
  6.                 System.out.println("==========================================================");
  7.                 //ApplicationContext context = new ClassPathXmlApplicationContext("application-tx.xml");
  8.                 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TXMain.class);
  9.                 BookService bookService = context.getBean("bookService", BookService.class);
  10.                 Book book = new Book();
  11.                 book.setName("30秒精通javascript,一分钟精通java");
  12.                 book.setCode(""+System.currentTimeMillis());
  13. //                bookService.insertWithTransaction(book );
  14.                 bookService.insertWithNoTransaction(book);
  15.                 System.out.println("bookService = "+bookService);
  16.                 System.out.println("bookService getList = "+bookService.getList());
  17.                 System.out.println("==========================================================");
  18.         }
  19. }
复制代码
@EnableTransactionManagement 注解导入了 TransactionManagementConfigurationSelector 默认选中的是 ProxyTransactionManagementConfiguration
  1. public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
  3.         /**
  4.          * Returns {@link ProxyTransactionManagementConfiguration} or
  5.          * {@code AspectJ(Jta)TransactionManagementConfiguration} for {@code PROXY}
  6.          * and {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()},
  7.          * respectively.
  8.          */
  9.         @Override
  10.         protected String[] selectImports(AdviceMode adviceMode) {
  11.                 return switch (adviceMode) {
  12.                
  13.                         case PROXY -> new String[] {AutoProxyRegistrar.class.getName(),
  14.        
  15.        
  16.        
  17.        
  18. </aop:config>        ProxyTransactionManagementConfiguration.class.getName()};
  19.                         case ASPECTJ -> new String[] {determineTransactionAspectClass()};
  20.                 };
  21.         }
  23.         private String determineTransactionAspectClass() {
  24.                 return (ClassUtils.isPresent("jakarta.transaction.Transactional", getClass().getClassLoader()) ?
  25.        
  26.        
  27.        
  28.        
  29. </aop:config>TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME :
  30.        
  31.        
  32.        
  33.        
  34. </aop:config>TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME);
  35.         }
  37. }
复制代码
同样注解的三剑客


  • AnnotationTransactionAttributeSource
    ↓（解析注解）
  • TransactionInterceptor
    ↓（执行事务逻辑）
  • BeanFactoryTransactionAttributeSourceAdvisor
    ↓（组装切点+通知）
org.springframework.transaction.annotation.ProxyTransactionManagementConfiguration
  1. /*
  2. * Copyright 2002-2021 the original author or authors.
  3. *
  4. * Licensed under the Apache License, Version 2.0 (the "License");
  5. * you may not use this file except in compliance with the License.
  6. * You may obtain a copy of the License at
  7. *
  8. *      https://www.apache.org/licenses/LICENSE-2.0
  9. *
  10. * Unless required by applicable law or agreed to in writing, software
  11. * distributed under the License is distributed on an "AS IS" BASIS,
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13. * See the License for the specific language governing permissions and
  14. * limitations under the License.
  15. */
  17. package org.springframework.transaction.annotation;
  19. import org.springframework.beans.factory.config.BeanDefinition;
  20. import org.springframework.context.annotation.Bean;
  21. import org.springframework.context.annotation.Configuration;
  22. import org.springframework.context.annotation.ImportRuntimeHints;
  23. import org.springframework.context.annotation.Role;
  24. import org.springframework.transaction.config.TransactionManagementConfigUtils;
  25. import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;
  26. import org.springframework.transaction.interceptor.TransactionAttributeSource;
  27. import org.springframework.transaction.interceptor.TransactionInterceptor;
  29. /**
  30. * {@code @Configuration} class that registers the Spring infrastructure beans
  31. * necessary to enable proxy-based annotation-driven transaction management.
  32. *
  33. * @author Chris Beams
  34. * @author Sebastien Deleuze
  35. * @since 3.1
  36. * @see EnableTransactionManagement
  37. * @see TransactionManagementConfigurationSelector
  38. */
  39. @Configuration(proxyBeanMethods = false)
  40. @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  41. @ImportRuntimeHints(TransactionRuntimeHints.class)
  42. public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
  44.         @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
  45.         @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  46.         public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
  47.                         TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {
  49.                 BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
  50.                 advisor.setTransactionAttributeSource(transactionAttributeSource);
  51.                 advisor.setAdvice(transactionInterceptor);
  52.                 if (this.enableTx != null) {
  53.                         advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
  54.                 }
  55.                 return advisor;
  56.         }
  58.         @Bean
  59.         @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  60.         public TransactionAttributeSource transactionAttributeSource() {
  61.                 // Accept protected @Transactional methods on CGLIB proxies, as of 6.0.
  62.                 return new AnnotationTransactionAttributeSource(false);
  63.         }
  65.         @Bean
  66.         @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
  67.         public TransactionInterceptor transactionInterceptor(TransactionAttributeSource transactionAttributeSource) {
  68.                 TransactionInterceptor interceptor = new TransactionInterceptor();
  69.                 interceptor.setTransactionAttributeSource(transactionAttributeSource);
  70.                 if (this.txManager != null) {
  71.                         interceptor.setTransactionManager(this.txManager);
  72.                 }
  73.                 return interceptor;
  74.         }
  76. }
复制代码
总结流程图

1.png

二、事务相关的 BeanDefinition 解析过程 (XML)

bean 标签

对于 jdbcTemplate transactionManager dataSource bookService 走的是默认命名空间的处理器, IOC标准解析流程, 不再啰嗦了
[[Spring IOC 源码学习 XML详细加载流程总结]]
org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
  1. protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
  2.         if (delegate.isDefaultNamespace(root)) {
  3.                 NodeList nl = root.getChildNodes();
  4.                 for (int i = 0; i < nl.getLength(); i++) {
  5.                         Node node = nl.item(i);
  6.                         if (node instanceof Element ele) {//是否 是元素标签
  7.        
  8.        
  9.        
  10.        
  11. </aop:config>/**
  12.        
  13.        
  14.        
  15.        
  16. </aop:config> * 处理默认命名空间的标签, 有如下四个
  17.        
  18.        
  19.        
  20.        
  21. </aop:config> * <import></import>,  </alias>, <bean></bean>, <beans></beans>
  22.        
  23.        
  24.        
  25.        
  26. </aop:config> *
  27.        
  28.        
  29.        
  30.        
  31. </aop:config> */
  32.        
  33.        
  34.        
  35.        
  36. </aop:config>if (delegate.isDefaultNamespace(ele)) {
  37.        
  38.        
  39.        
  40.        
  41. </aop:config>        parseDefaultElement(ele, delegate);
  42.        
  43.        
  44.        
  45.        
  46. </aop:config>}
  47.        
  48.        
  49.        
  50.        
  51. </aop:config>else {
  52.        
  53.        
  54.        
  55.        
  56. </aop:config>        /**
  57.        
  58.        
  59.        
  60.        
  61. </aop:config>         * 处理 非默认命名空间的标签;
  62.        
  63.        
  64.        
  65.        
  66. </aop:config>         *         注意这里包括 <context:bean ...>  <tx:xx ...> 等等所有指定命名空间的xml配置
  67.        
  68.        
  69.        
  70.        
  71. </aop:config>         *         主要逻辑是: 拿到元素的命名空间URI, 再从 XmlReaderContext 找到对应的 NamespaceHandler 调用解析 `parse`方法解析到 BeanDefinition 返回
  72.        
  73.        
  74.        
  75.        
  76. </aop:config>         */
  77.        
  78.        
  79.        
  80.        
  81. </aop:config>        delegate.parseCustomElement(ele);
  82.        
  83.        
  84.        
  85.        
  86. </aop:config>}
  87.                         }
  88.                 }
  89.         }
  90.         else {
  91.                 delegate.parseCustomElement(root);
  92.         }
  93. }
复制代码
aop 标签

对于 aop 部分的标签则的是 AOP 的流程
  1.        
  2.        
  3.        
  4.        
  5. </aop:config>
复制代码

  • : 解析为 org.springframework.aop.aspectj.AspectJExpressionPointcut 其 BeanDefinition
  • :  解析为 org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor 其 BeanDefinition
internalAutoProxyCreator 的注册

[[Spring AOP 源码学习 详细流程总结]]
这里要注意AOP 的 ConfigBeanDefinitionParser 在解析时是会注册的一个internalAutoProxyCreator! (AOP解析流程, 在BPP回调时创建代理对象的)
org.springframework.aop.config.ConfigBeanDefinitionParser#parse
  1.         @Override        @Nullable        public BeanDefinition parse(Element element, ParserContext parserContext) {                CompositeComponentDefinition compositeDef =       
  2.        
  3.        
  4.        
  5. </aop:config>new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));                parserContext.pushContainingComponent(compositeDef);                /**                 * 1. 注册一个名称为`org.springframework.aop.config.internalAutoProxyCreator` 对AOP处理的Bean Definition; 它是实现 InstantiationAwareBeanPostProcessor 接口的                 * 名称是: org.springframework.aop.config.internalAutoProxyCreator                 * 对应的类, 根据情况有以下三个可能: org.springframework.aop.config.AopConfigUtils#APC_PRIORITY_LIST                 *            InfrastructureAdvisorAutoProxyCreator.class,AspectJAwareAdvisorAutoProxyCreator.class, AnnotationAwareAspectJAutoProxyCreator.class                 *         注册一个名称为`org.springframework.aop.config.internalAutoProxyCreator` 对AOP处理的Bean Definition; 它是实现 InstantiationAwareBeanPostProcessor 接口的                 *                 */                configureAutoProxyCreator(parserContext, element);
复制代码
解析 , , 没有切面标签
org.springframework.aop.config.ConfigBeanDefinitionParser#parse
  1.         @Override        @Nullable        public BeanDefinition parse(Element element, ParserContext parserContext) {                CompositeComponentDefinition compositeDef =       
  2.        
  3.        
  4.        
  5. </aop:config>new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));                parserContext.pushContainingComponent(compositeDef);                /**                 * 1. 注册一个名称为`org.springframework.aop.config.internalAutoProxyCreator` 对AOP处理的Bean Definition; 它是实现 InstantiationAwareBeanPostProcessor 接口的                 * 名称是: org.springframework.aop.config.internalAutoProxyCreator                 * 对应的类, 根据情况有以下三个可能: org.springframework.aop.config.AopConfigUtils#APC_PRIORITY_LIST                 *            InfrastructureAdvisorAutoProxyCreator.class,AspectJAwareAdvisorAutoProxyCreator.class, AnnotationAwareAspectJAutoProxyCreator.class                 *         注册一个名称为`org.springframework.aop.config.internalAutoProxyCreator` 对AOP处理的Bean Definition; 它是实现 InstantiationAwareBeanPostProcessor 接口的                 *                 */                configureAutoProxyCreator(parserContext, element);                /**                 * 2. 解析  标签的子元素 (pointcut, advisor, aspect)                 * 解析 :                 * 每一个通知(Advice) 都会封装为一个 AspectJPointcutAdvisor 的BeanDefinition 然后将其注册到 BeanFactory                 *                 *  AspectJPointcutAdvisor 的包含情况                 * 每一个通知(Advice) 都会封装为一个 AspectJPointcutAdvisor(通知器) 类型的BeanDefinition 然后将其注册到 BeanFactory                 *         AspectJPointcutAdvisor 内部包含五种通知类类型:  AspectJAfterReturningAdvice AspectJAfterAdvice AspectJAroundAdvice AspectJMethodBeforeAdvice AspectJAfterThrowingAdvice                 *  而每种通知类型的内部又主要有三个关键属性,包括:                 *  1. java.lang.reflect.Method(通知切面的方法)                 *        2. org.springframework.aop.aspectj.AspectJExpressionPointcut(切入点表达式)                 *         3. org.springframework.aop.aspectj.AspectInstanceFactory (切面实例工厂)                 */                List childElts = DomUtils.getChildElements(element);                for (Element elt: childElts) {                        String localName = parserContext.getDelegate().getLocalName(elt);                        switch (localName) {       
  6.        
  7.        
  8.        
  9. </aop:config>/**       
  10.        
  11.        
  12.        
  13. </aop:config> * 解析 pointcut/切入点  //筛选连接点, 即: 哪些方法需要被代理       
  14.        
  15.        
  16.        
  17. </aop:config> * 解析为 org.springframework.aop.aspectj.AspectJExpressionPointcut 注册其 BeanDefinition       
  18.        
  19.        
  20.        
  21. </aop:config> */       
  22.        
  23.        
  24.        
  25. </aop:config>case POINTCUT -> parsePointcut(elt, parserContext);       
  26.        
  27.        
  28.        
  29. </aop:config>/**       
  30.        
  31.        
  32.        
  33. </aop:config> *  解析 advisor/通知/建议/增强处理  //即: 增强功能这一部分代码       
  34.        
  35.        
  36.        
  37. </aop:config> * 解析为 org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor 注册其 BeanDefinition       
  38.        
  39.        
  40.        
  41. </aop:config> */       
  42.        
  43.        
  44.        
  45. </aop:config>case ADVISOR -> parseAdvisor(elt, parserContext);       
  46.        
  47.        
  48.        
  49. </aop:config>/**       
  50.        
  51.        
  52.        
  53. </aop:config>       
  54.        
  55.        
  56.        
  57. </aop:config> */       
  58.        
  59.        
  60.        
  61. </aop:config>case ASPECT -> parseAspect(elt, parserContext);                        }                }                parserContext.popAndRegisterContainingComponent();                return null;        }
复制代码
tx 标签

前文说了由 org.springframework.transaction.config.TxAdviceBeanDefinitionParser 负责XML解析
先来到父类方法解析 TransactionInterceptor

org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#parseInternal
[code]/**         * Creates a {@link BeanDefinitionBuilder} instance for the         * {@link #getBeanClass bean Class} and passes it to the         * {@link #doParse} strategy method.         * @param element the element that is to be parsed into a single BeanDefinition         * @param parserContext the object encapsulating the current state of the parsing process         * @return the BeanDefinition resulting from the parsing of the supplied {@link Element}         * @throws IllegalStateException if the bean {@link Class} returned from         * {@link #getBeanClass(org.w3c.dom.Element)} is {@code null}         * @see #doParse         *         */        @Override        protected final AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {                /**                 *                 * 1. 解析
一文学习Spring声明事务

使用道具 举报

相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
米嘉怡
昨天 23:15

0

粉丝关注

18

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫