【spring源码学习】spring的事务管理的源码解析

本文涉及的产品
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
简介: 【一】spring事务管理(1)spring的事务管理,是基于aop动态代理实现的。对目标对象生成代理对象,加入事务管理的核心拦截器==>org.springframework.transaction.interceptor.TransactionInterceptor。

【一】spring事务管理
(1)spring的事务管理,是基于aop动态代理实现的。对目标对象生成代理对象,加入事务管理的核心拦截器==>org.springframework.transaction.interceptor.TransactionInterceptor。
===>spring事务管理的核心拦截器
===>需要配置的数据项:事务管理机制配置属性的查找类transactionAttributeSource,事务管理的核心处理器PlatformTransactionManager(如果能配置就配置,不能配置就从beanFactory中根据接口拿)

(2)实现事务管理需要配置事务管理处理器(事务处理的支持抽象封装(获取事务状态,提交事务,回归事务),如下是spring事务管理器的基础类。
==>org.springframework.transaction.PlatformTransactionManager
==>org.springframework.transaction.support.AbstractPlatformTransactionManager

(3)获取将要执行的方法的事务策略的配置信息的查询器。
==>org.springframework.transaction.interceptor.TransactionAttributeSource
==>org.springframework.transaction.annotation.AnnotationTransactionAttributeSource(基于注解进行事务管理配置的属性获取器)
==>该类内部也做属性配置缓存。以要执行的方法的对象Method method,和要执行的bean的Class<?> targetClass组装成org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource.DefaultCacheKey.该类重写了equals和hashCode方法。


(4)spring事务管理的配置属性的实体类
==>org.springframework.transaction.interceptor.TransactionAttribute
==>org.springframework.transaction.interceptor.DefaultTransactionAttribute(spring的默认)
==>org.springframework.transaction.interceptor.RuleBasedTransactionAttribute(基于注解的事务管理配置属性的类)
==>其实就是,事务的传播机制,事务回滚策略等配置信息


(5)spring事务管理的一个FactoryBean
==>org.springframework.transaction.interceptor.TransactionProxyFactoryBean
==>内部初始化TransactionInterceptor,配置项:可以配置事务管理拦截器增强之外的别的拦截器,需要进行事务管理的的target, 进行事务管理的目标的接口proxyInterfaces
==>该类内部会调用afterPropertiesSet()方法,对目标target类生成一个代理对象。最终返回给业务使用。



【二】事务管理拦截器的执行过程TransactionInterceptor的invoke(final MethodInvocation invocation)方法
(1)获取要进行事务管理的业务类的class的类对象
(2)根据类对象class和要执行的方法的method对象,基于事务管理配置属性查询器获取事务机制的属性TransactionAttribute
(3)根据事务配置机制的属性获取事务管理的处理器PlatformTransactionManager
(4)根据类对象class和要执行的方法method对象获取事务管理,连接点标识joinpointIdentification(类的全路径+执行方法的名字)
(5)根据事务管理处理器PlatformTransactionManager,事务机制配置属性TransactionAttribute,事务连接点标识joinpointIdentification获取当前事务信息TransactionInfo
(6)继续执行下一个拦截器或目标业务管理bean的方法
(7)根据(6)的执行结果进行相应的事务操作
(8)如果(6)没有抛出异常,则先根据TransactionInfo进行相关资源的清理,然后根据TransactionInfo进行事务提交操作
(9)如果(6)抛出异常,则根据TransactionInfo进行事务回滚操作

 

【三】以xml配置方式进行事务管理的初始化原理解析
(1)    以下配置是事务管理机制属性配置

   <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="doReweight" propagation="REQUIRES_NEW"/>
            <tx:method name="doClear*" propagation="REQUIRES_NEW"/>
            <tx:method name="doSend*" propagation="REQUIRES_NEW"/>
            <tx:method name="doBatchSave*" propagation="REQUIRES_NEW"/>

            <!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到-->
            <tx:method name="get*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="count*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="find*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="list*" propagation="REQUIRED" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config expose-proxy="true" proxy-target-class="true">
        <!-- 只对业务逻辑层实施事务 -->
        <aop:pointcut id="txPointcut" expression="execution(* com.mobile.thinks..service..*+.*(..))"/>
        <aop:advisor id="txAdvisor" advice-ref="txAdvice" pointcut-ref="txPointcut"/>
    </aop:config>
View Code

(2)   在spring的IOC阶段是用org.springframework.transaction.config.TxNamespaceHandler进行解析该<tx:advice>配置,调用解析器org.springframework.transaction.config.TxAdviceBeanDefinitionParser
==>如果没有attributes的配置,则默认的配置属性查询器为org.springframework.transaction.annotation.AnnotationTransactionAttributeSource
==>如果attributes的配置大于1个。报错
==>如果attributes的配置等于1个。
   >则解析 <tx:method>的配置。并为每一个method的配置形成一个org.springframework.transaction.interceptor.RuleBasedTransactionAttribute的对象。如果有回归策略则形成org.springframework.transaction.interceptor.RollbackRuleAttribute配置。将所有的method配置形成ManagedMap<TypedStringValue, RuleBasedTransactionAttribute> transactionAttributeMap集合
  >解析完method后,则想IOC注入事务属性配置查询器为org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource.将method解析后的transactionAttributeMap的集合赋值给其属性nameMap
==>想builder解析上下文注册了两个属性transactionAttributeSource(事务管理机制属性的查询器),transactionManager(事务管理的处理器)
==>解析tx的配置,最终形成的advisor是org.springframework.transaction.interceptor.TransactionInterceptor.其依赖了刚才解析的事务管理机制属性查询器transactionAttributeSource,和事务管理处理器transactionManager

(3)在spring的IOC阶段用的是org.springframework.aop.config.AopNamespaceHandler进行解析 <aop:config >该配置。调用的解析器为org.springframework.aop.config.ConfigBeanDefinitionParser

==>默认会向IOC容器中注册bean实力化的前后置处理器org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator(BeanPostProcessor接口实现类)
==>解析<aop:advisor>是向IOC容器中注册org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor.并建立txAdvice和txPointcut的依赖关系
==>解析<aop:pointcut>是向IOC容器中注册org.springframework.aop.aspectj.AspectJExpressionPointcut

 

=====================================================分割线========================================================

*****spring事务管理是基于对数据库链接的管理。以下所涉及的类,都是对数据库DataSource的直接管理,从而对数据库链接Connection的间接管理从而隐式进行数据库事务管理******

【一】org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy
==>该类对DataSource进行动态代理,但返回的代理对象是Connection.具体的操作见TransactionAwareInvocationHandler的invoke方法。
==>在对数据库做任何操作的时候,都在invoke方法中。


【二】org.springframework.jdbc.datasource.TransactionAwareInvocationHandler
==>该类属性targetDataSource引用的是真正的DataSource实现。
==>该类属性target引用的是由 DataSourceUtils类通过targetDataSource获取的一个数据库链接,该链接与当前线程进行绑定。
==>在事务管理过程中Connection做的任何操作,都是代理对象进行操作的。都会调用该类的invoke方法,通过该方法对当前线程的事务管理进行绑定解绑等等操作。


【三】org.springframework.jdbc.datasource.DataSourceUtils
==>该类是从DataSource获取数据库链接,并结合Spring的TransactionSynchronizationManager类进行事务管理的相关操作
==>主要有获取Connection,释放Connection等相关操作。


【四】org.springframework.transaction.support.TransactionSynchronizationManager
==>对当前线程或当前事务的一些操作进行管理的操作类
==>可以在当前事务中注册一些事件执行。TransactionSynchronization接口的实现类

【五】org.springframework.transaction.support.TransactionSynchronization
==>该类定义一些事务处理过程中的一些事件处理回调方法。
==>例子:org.activiti.spring.TransactionSynchronizationAdapter
==>org.activiti.spring.SpringTransactionContext

 

(1)一个小案例,当事务提交后发布异步事件进行相应操作。如果事务未提交,回滚。则不发布该事件

public static void publishEvent(final ApplicationEvent event) {
        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                @Override
                public void afterCommit() {
                    applicationContext.publishEvent(event);
                    super.afterCommit();
                }
                
            });
        } else {
            applicationContext.publishEvent(event);
        }
    }
View Code

 (2)测试线程保管箱,用于说明TransactionSynchronizationManager属性中不同的线程保管箱的声明,是用于记录不同线程的事务管理的信息的存储。各个线程的事务信息是互不干扰和影响的。

import org.springframework.core.NamedThreadLocal;
/**
 * 代码测试结果:
 * 主线程的数值==>【我是主线程】
 * 非主线程的数值====>【我是副线程】
 * 10秒后被唤醒。。。。。。
 * 主线程第二次获取===>【我是主线程】
 * 
 * @author sxf
 *
 */
public class TestThreadLocal {
    
    
    public static void main(String[] args) {
        
        //在主线程声明一个ThreadLocal的线程保管箱,用于管理不同线程存储的不同的数值。看是否会线程间干扰
        final ThreadLocal<String> named=new NamedThreadLocal<String>("sxf test");
        
        //主线程设置数值
        named.set("【我是主线程】");
        //读取主线程存取的数值
        System.out.println("主线程的数值==>"+named.get());
        
        
        //启动一个新的线程,也使用主线程声明的线程保管箱
        Thread aThread=new Thread(){

            @Override
            public void run() {
                //副线程设置数值
                named.set("【我是副线程】");
                //读取副线程的存储的数值
                String falg=named.get();
                System.out.println("非主线程的数值====>"+falg);
            }
            
        };
        aThread.start();
        //主线程休眠10妙,待副线程执行完毕,再次从ThreadLocal里读取数值,看是否被副线程覆盖
        try {
            Thread.sleep(10000L);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("10秒后被唤醒。。。。。。");
        System.out.println("主线程第二次获取===>"+named.get());
        
        
    }

}
View Code

 

 

 

========================================xml方式配置事务管理,spring向IOC注册的核心关键类================================

(1)org.springframework.transaction.PlatformTransactionManager(事务管理的核心类)
==>该接口定义了三个方法,获取事务状态,提交事务,回滚事务
==>org.springframework.transaction.support.AbstractPlatformTransactionManager.该类对PlatformTransactionManager的三个方法进行重写,并写成模板方法。在再类内部定义各种方法,由子类实现。其中,commit(TransactionStatus status),rollback(TransactionStatus status)是final方法,不允许被重写。
==>jpa的事务管理的核心类:org.springframework.orm.jpa.JpaTransactionManager

(2)org.springframework.transaction.interceptor.TransactionAttributeSource(事务属性的接口,主要指事务的传播机制,是否只读事务,什么异常回滚等属性)
==>org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource(事务属性的一个实现类,是xml方式配置的方法表达式定义事务属性的核心实现类)
==>该类记录了,所切的业务方法的事务传播机制等属性配置信息。
==>该接口就定义了该方法,获取事务配置属性。TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass);

(3)org.springframework.transaction.interceptor.TransactionAttribute
===>事务配置属性
===>xml方式配置的事务属性,org.springframework.transaction.interceptor.RuleBasedTransactionAttribute(事务传播机制,是否只读的配置属性)
===>xml方式配置的事务属性,org.springframework.transaction.interceptor.RollbackRuleAttribute(事务回滚的配置属性)
===>xml方式配置的事务属性,org.springframework.transaction.interceptor.NoRollbackRuleAttribute(事务不回滚的配置属性)
===>tx的配置,会将配置的类加入到ManagedMap<TypedStringValue, RuleBasedTransactionAttribute> transactionAttributeMap

(4)xml方式配置的事务拦截器

<tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
                <tx:method name="required*" propagation="REQUIRED"/>
                <tx:method name="supports*" propagation="SUPPORTS"/>
                <tx:method name="mandatory*" propagation="MANDATORY"/>
                <tx:method name="requires_new*" propagation="REQUIRES_NEW"/>
                <tx:method name="not_supported*" propagation="NOT_SUPPORTED"/>
                <tx:method name="never*" propagation="NEVER"/>
                <tx:method name="nested*" propagation="NESTED"/>
                <tx:method name="*" propagation="REQUIRED"/>           
        </tx:attributes>
    </tx:advice>
View Code

===>org.springframework.transaction.interceptor.TransactionInterceptor
===>该类中存储了,事务配置的属性NameMatchTransactionAttributeSource,事务管理JpaTransactionManager

(5)xml方式配置的事务aop代理

<aop:config expose-proxy="true" proxy-target-class="true">
        <!-- 只对业务逻辑层实施事务 -->
        <aop:pointcut id="txPointcut" expression="execution(* com.sxf.test.service..*+.*(..))"/>
        <aop:advisor id="txAdvisor" advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>
View Code

===>pointcut向IOC容器中注册:org.springframework.aop.aspectj.AspectJExpressionPointcut (匹配包名,决定对那些类进行事务管理,切面的定义)
===>AspectJExpressionPointcut类是org.springframework.aop.ClassFilter和org.springframework.aop.MethodMatcher和org.springframework.aop.Pointcut的实现类,用于判断当前类,是否要进行代理。

===>advisor向IOC容器中注册:org.springframework.aop.support.DefaultBeanFactoryPointcutAdvisor(这将来会在IOC申请Bean的时候,被编制到代理对象里的代理链条中,用于进行事务管理),该类有拦截器(增强,事务管理的拦截器机制)+切面(表达式决定那些类会被进行事务管理)

(6)spring进行事务管理的结构

==========================================Annotation方式进行spring事务管理=============================

    <!-- 注解方式配置事务管理机制 -->
    <!--  proxy-target-class="true" true使用cglib进行动态代理,false使用jdk -->
    <!--  expose-proxy="true" 暴露代理对象  -->
    <tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"  expose-proxy="true"/>
View Code

(1)org.springframework.transaction.event.TransactionalEventListenerFactory
===>该类是org.springframework.context.event.EventListenerFactory
===>暂时不知道什么作用。

(2)org.springframework.transaction.config.internalTransactionalEventListenerFactory

(3)org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator
==>该类是org.springframework.beans.factory.config.BeanPostProcessor接口的实现类,会在IOC容器申请bean的时候,对bean进行加工,形成具有事务管理的代理对象,返回。


(4)org.springframework.transaction.annotation.AnnotationTransactionAttributeSource
==>该类是事务管理配置属性的类的查找。
(5)org.springframework.transaction.interceptor.TransactionInterceptor
==>该类拥有事务管理的transcationManage和AnnotationTransactionAttributeSource

(6)org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor
===>该类拥有TransactionInterceptor和AnnotationTransactionAttributeSource


InfrastructureAdvisorAutoProxyCreator在申请bean的时候,会根据当前的class找到beanFactory里所有的advisor,然后从所有的Advisor中找到有资格作为该class的advisor,如果存在,则创建代理对象返回。Advisor里有PointCut来界定是否支持。



============================================spring框架的基础架构和实现策略=================================================
spring的IOC容器
(1)解析xml,将所有bean加载成BeanDefinition形式存储在DefaultListableBeanFactory中。
(2)控制依赖反转注入,向IOC容器中申请bean,创建bean,返回注入bean(递归形式进行链式注入,在创建的过程中对其进行前后加工bean,生成代理对象,或改变行为,注入属性)

spring的AOP代理
(1)会有一个创建代理对象的BeanPostProcessor接口实现对象,会在创建bean的前后进行处理bean,最终返回该bean一个代理对象。
(2)先在IOC容器中查找到所有的Advisor(增强+切面定义),然后在所有的Advisor中根据bean的class属性,进行匹配,看当前class是否需要增强。
(3)通过切面定义对class进行判定(Pointcut,ClassFilter,MethodMatcher),如果适合,收集起所有的Advisor,然后根据Order接口定义的优先级,进行排序。
(4)根据配置,生成代理对象,并返回代理对象,注入到要依赖的对象里。未来调用的时候进行增强逻辑的执行。

相关文章
|
7天前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
25 2
|
24天前
|
数据采集 监控 前端开发
二级公立医院绩效考核系统源码,B/S架构,前后端分别基于Spring Boot和Avue框架
医院绩效管理系统通过与HIS系统的无缝对接,实现数据网络化采集、评价结果透明化管理及奖金分配自动化生成。系统涵盖科室和个人绩效考核、医疗质量考核、数据采集、绩效工资核算、收支核算、工作量统计、单项奖惩等功能,提升绩效评估的全面性、准确性和公正性。技术栈采用B/S架构,前后端分别基于Spring Boot和Avue框架。
|
26天前
|
搜索推荐 Java Spring
Spring Filter深度解析
【10月更文挑战第21天】Spring Filter 是 Spring 框架中非常重要的一部分,它为请求处理提供了灵活的控制和扩展机制。通过合理配置和使用 Filter,可以实现各种个性化的功能,提升应用的安全性、可靠性和性能。还可以结合具体的代码示例和实际应用案例,进一步深入探讨 Spring Filter 的具体应用和优化技巧,使对它的理解更加全面和深入。
|
13天前
|
前端开发 Java 开发者
Spring生态学习路径与源码深度探讨
【11月更文挑战第13天】Spring框架作为Java企业级开发中的核心框架,其丰富的生态系统和强大的功能吸引了无数开发者的关注。学习Spring生态不仅仅是掌握Spring Framework本身,更需要深入理解其周边组件和工具,以及源码的底层实现逻辑。本文将从Spring生态的学习路径入手,详细探讨如何系统地学习Spring,并深入解析各个重点的底层实现逻辑。
40 9
|
1月前
|
前端开发 Java 数据库
SpringBoot学习
【10月更文挑战第7天】Spring学习
36 9
|
1月前
|
XML Java 数据格式
Spring学习
【10月更文挑战第6天】Spring学习
21 1
|
1月前
|
XML Java 数据格式
Spring IOC容器的深度解析及实战应用
【10月更文挑战第14天】在软件工程中,随着系统规模的扩大,对象间的依赖关系变得越来越复杂,这导致了系统的高耦合度,增加了开发和维护的难度。为解决这一问题,Michael Mattson在1996年提出了IOC(Inversion of Control,控制反转)理论,旨在降低对象间的耦合度,提高系统的灵活性和可维护性。Spring框架正是基于这一理论,通过IOC容器实现了对象间的依赖注入和生命周期管理。
67 0
|
1月前
|
缓存 Java 程序员
Map - LinkedHashSet&Map源码解析
Map - LinkedHashSet&Map源码解析
67 0
|
1月前
|
算法 Java 容器
Map - HashSet & HashMap 源码解析
Map - HashSet & HashMap 源码解析
54 0
|
1月前
|
存储 Java C++
Collection-PriorityQueue源码解析
Collection-PriorityQueue源码解析
60 0

推荐镜像

更多
下一篇
无影云桌面