【spring源码学习】spring的事务管理的源码解析-白红宇

【一】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）以下配置是事务管理机制属性配置

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
      
        named=new NamedThreadLocal
       
        ("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方式配置的事务拦截器

View Code

===>org.springframework.transaction.interceptor.TransactionInterceptor

===>该类中存储了，事务配置的属性NameMatchTransactionAttributeSource，事务管理JpaTransactionManager

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

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事务管理=============================

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）根据配置，生成代理对象，并返回代理对象，注入到要依赖的对象里。未来调用的时候进行增强逻辑的执行。