一、事务的概念
1.1什么是事务
事务就是逻辑上的一批执行单元，它们要么都执行，要么都不执行。
1.2事务的特性(ACID)
ACID就是数据库管理系统DBMS中事务所具有的的四个特性。
- atomicity:原子性，原子性表现为操作不能 被分割，一个事务由一系列数据库操作组成一个完整的逻辑过程，比如银行转账，原账户扣减、新账户增加金额，这两个操作要么都不完成，要么都完成，如果事务出错了，那就回回滚事务；
- Consistency[一致性]：数据库要处于一致性的状态，事务开始前是一致状态，事务结束后就是另外一个一致状态；
- Isolation[隔离性]:所谓的隔离性就是说并发的事务之间互不影响，如果一个事务要访问的数据正在被另外一个事务修改，只要另外一个事务没有提交，那么它所访问的数据就不受未提交事务的影响。换一句话来说就是：一个事务的影响在该事务提交前对其他事务是不可见的；
- Durability[持久性]：若事务提交了，那么该事务所影响到数据将永远保存在数据库中；
二、Spring事务三大接口介绍
- PlatformTransactionManager:平台事务管理器；
- TransactionDefinition:事务定义信息(事务隔离级别、传播行为、超时、只读、回滚规则)；
- TransactioniStatus:事务运行状态；
2.1PlatformTransactionManager接口介绍
Spring并不直接管理事务，而是提供了多种事务管理器，他们将事务管理的职责委托给了Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。
Spring管理事务的接口是：org.springframework.transaction.PlatformTransactionManager，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，但是具体的实现 就是各个平台自己的事情了。
package org.springframework.transaction;
public interface PlatformTransactionManager {
// 获取事务状态
TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;
// 提交事务
void commit(TransactionStatus var1) throws TransactionException;
// 回滚事务
void rollback(TransactionStatus var1) throws TransactionException;
}
2.2TransactionDefination 事务属性的定义
org.springframework.transaction.TransactionDefinition,TransactionDefinition接口中定义了5个方法以及一些表示事务属性的常量比如隔离级别、传播行为等常量。
public interface TransactionDefinition {
// 支持当前事物，若当前没有事物就创建一个事物
int PROPAGATION_REQUIRED = 0;
// 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行
int PROPAGATION_SUPPORTS = 1;
// 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常
int PROPAGATION_MANDATORY = 2;
// 创建一个新的事务，如果当前存在事务，则把当前事务挂起
int PROPAGATION_REQUIRES_NEW = 3;
// 以非事务方式运行，如果当前存在事务，则把当前事务挂起
int PROPAGATION_NOT_SUPPORTED = 4;
// * 以非事务方式运行，如果当前存在事务，则抛出异常。
int PROPAGATION_NEVER = 5;
/** 表示如果当前正有一个事务在运行中，则该方法应该运行在 一个嵌套的事务中， 被嵌套的事务可
*以独立于封装事务进行提交或者回滚(保存点)， 如果封装事务不存在,行为就像
*PROPAGATION_REQUIRES NEW
*/
int PROPAGATION_NESTED = 6;
// 使用后端数据库默认的隔离级别，Mysql 默认采用的 REPEATABLE_READ隔离级别 Oracle 默认采用的 READ_COMMITTED隔离级别
int ISOLATION_DEFAULT = -1;
// 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读
int ISOLATION_READ_UNCOMMITTED = 1;
// 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生
int ISOLATION_READ_COMMITTED = 2;
// 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生
int ISOLATION_REPEATABLE_READ = 4;
// 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰
// 也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能通常情况下也不会用到该级别
int ISOLATION_SERIALIZABLE = 8;
// 使用默认的超时时间
int TIMEOUT_DEFAULT = -1;
// 获取事物的传播行为
int getPropagationBehavior();
// 获取事物的隔离级别
int getIsolationLevel();
// 返回事物的超时时间
int getTimeout();
// 返回当前是否为只读事物
boolean isReadOnly();
// 获取事物的名称
String getName();
}
具体如下：
2.3TransactionStatus接口介绍
TransactionStatus接口用来记录事务的状态，该接口定义了一组方法用来获取或者判断事务的状态的信息。
PlatformTransactionManager.getTransaction(…) 方法返回一个 TransactionStatus 对象。返回的 TransactionStatus 对象可能代表一个新的或已经存在的事务（如果在当前调用堆栈有一个符合条件的 事物。
public interface TransactionStatus extends SavepointManager, Flushable {
// 是否为新事物
boolean isNewTransaction();
// 是否存在保存点
boolean hasSavepoint();
// 设置为只回滚
void setRollbackOnly();
// 是否为只回滚
boolean isRollbackOnly();
void flush();
// 判断当前事物是否已经完成
boolean isCompleted();
}
三、@EnableTransactionManager注解的作用
其实@EnableTransactionManager就是我们容器里面导入了几个组件，具体如下：
接下来我们从源码的角度来看下，@EnableTransactionManager是如何给我们导入这些组件的。
3.1@EnableTransactionManager源码开始分析
首先一看到@Import大家就知道，它是给我们的spring源码导入一个bean；
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({TransactionManagementConfigurationSelector.class})
public @interface EnableTransactionManagement {
// 指定使用什么代理模式 (true为cglib代理，false为jdk动态代理)
boolean proxyTargetClass() default false;
// 通知模式 是使用代理模式还是aspectj 我们一般使用Proxy
AdviceMode mode() default AdviceMode.PROXY;
int order() default 2147483647;
}
3.2TransactionManagementConfigurationSelector组件介绍
从3.1我们知道，他给我们容器导入了TransactionManagementConfigurationSelector这个组件，接下来我们对这个组件进行源码分析，从下来的代码我们可以看得到，他继续向我们的容器导入了两个组件。
- AutoProxyRegister
- ProxyTransactionManagerConfiguration
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
public TransactionManagementConfigurationSelector() {
}
protected String[] selectImports(AdviceMode adviceMode) {
switch(adviceMode) {
//因为我们配置的默认模式是PROXY
case PROXY:
return new String[]{AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()};
case ASPECTJ:
return new String[]{"org.springframework.transaction.aspectj.AspectJTransactionManagementConfiguration"};
default:
return null;
}
}
}
3.2.1AutoProxyRegister的作用
从源码我们可以看得出来,AutoProxyRegister为我们容器里面导入了一个bean：InfrastuctureAdvisorAutoProxyCreator组件。
public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
private final Log logger = LogFactory.getLog(getClass());
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
boolean candidateFound = false;
// 从我们传入进去的配置类上获取所有的注解的
Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
// 循环我们上一步获取的注解
for (String annoType : annoTypes) {
// 获取注解的元信息
AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
if (candidate == null) {
continue;
}
// /获取注解的mode属性
Object mode = candidate.get("mode");
// 获取注解的proxyTargetClass
Object proxyTargetClass = candidate.get("proxyTargetClass");
// 根据mode和proxyTargetClass的判断来注册不同的组件
if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
Boolean.class == proxyTargetClass.getClass()) {
candidateFound = true;
if (mode == AdviceMode.PROXY) {
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
if ((Boolean) proxyTargetClass) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
return;
}
}
}
}
if (!candidateFound && logger.isWarnEnabled()) {
String name = getClass().getSimpleName();
logger.warn(String.format("%s was imported but no annotations were found " +
"having both 'mode' and 'proxyTargetClass' attributes of type " +
"AdviceMode and boolean respectively. This means that auto proxy " +
"creator registration and configuration may not have occurred as " +
"intended, and components may not be proxied as expected. Check to " +
"ensure that %s has been @Import'ed on the same class where these " +
"annotations are declared; otherwise remove the import of %s " +
"altogether.", name, name, name));
}
}
}
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
return registerAutoProxyCreatorIfNecessary(registry, (Object)null);
}
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
// /判断容器中有没有org.springframework.aop.config.internalAutoProxyCreator名字的bean定义
if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
} else {
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", -2147483648);
beanDefinition.setRole(2);
registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
return beanDefinition;
}
}
所以通过我们对AutoProxyRegister的源码分析我们可以得出，其实这个组件就是给我们导入了一个叫做InfrastructureAdvisorAutoPorxyCreator的组件，接下来我们看下这个组件的继承图；
看到这里是不是感觉有点熟悉，以为AOP的流程也是这样子；我们通过继承图我们看到InfrastructureAdvisorAutoPorxyCreator实现了对应的接口所带来的作用；
①:实现了Aware接口(具体代表 BeanFactoryAware接口) 做了什么事情）
- 把我们的BeanFacotry容器设置到了InfrastructureAdvisorAutoProxyCreator组件中去
- 创建了一个advisorRetrievalHelper组件 增强器检索工具；
// org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
// 马上又被org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator重写了
@Override
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException(
"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
}
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}
// 但是AbstractAdvisorAutoProxyCreator类的initBeanFactory又被InfrastructureAdvisorAutoProxyCreator重写了
@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
this.beanFactory = beanFactory;
}
②:实现了我们的接口 InstantiationAwareBeanPostProcessor类型的后置处理器，为我们容器中做了 什么事情
org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInitialization postProcessBeforeInstantiation方法;
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = getCacheKey(beanClass, beanName);
if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
// Create proxy here if we have a custom TargetSource.
// Suppresses unnecessary default instantiation of the target bean:
// The TargetSource will handle target instances in a custom fashion.
if (beanName != null) {
TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
this.targetSourcedBeans.add(beanName);
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
}
return null;
}
postProcessAfterInstantiation方法没有做任何事情，直接就返回了；
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) {
return true;
}③:实现了我们的接口BeanPostProcessor类型的后置处理器，为我们容器中做了什么事情？
postProcessBeforeInitialization方法没有做任何事情,直接返回；
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
return bean;
}postProcessAfterInitialization 为我们做了事情；
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
3.3ProxyTransactionManagerConfiguration的作用
@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
public ProxyTransactionManagementConfiguration() {
}
// * 为我我们容器中导入了 beanName为org.springframework.transaction.config.internalTransactionAdvisor
// 类型为：BeanFactoryTrancsactionAttributeSourceAdvisor的增强器
@Bean(
name = {"org.springframework.transaction.config.internalTransactionAdvisor"}
)
@Role(2)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
// 设置事务源属性对象
advisor.setTransactionAttributeSource(this.transactionAttributeSource());
// 设置事务拦截器对象
advisor.setAdvice(this.transactionInterceptor());
advisor.setOrder((Integer)this.enableTx.getNumber("order"));
return advisor;
}
// 定义了一个事务属性源对象
@Bean
@Role(2)
public TransactionAttributeSource transactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}
// 定义了一个事务拦截器对象
@Bean
@Role(2)
public TransactionInterceptor transactionInterceptor() {
TransactionInterceptor interceptor = new TransactionInterceptor();
// 把事务源属性对象设置进来
interceptor.setTransactionAttributeSource(this.transactionAttributeSource());
if (this.txManager != null) {
interceptor.setTransactionManager(this.txManager);
}
return interceptor;
}
}
然后我们来看下BeanFactoryTransactionAttributeSourceAdvisor、TransactionAttributeSource、TransactionInterceptor的继承图；
我们通过对@EnableTransactionManagement的源码分析，下面我们对它进行一个总结；
四、Spring事务源代码解析流程分析
4.1创建源代码流程
我们通过上面的分析，知道事务创建代理对象最主要的逻辑在InfrastuctureAdvisorAutoProxyCreator这个组件实现的后置处理器为我们创建代理对象，实际上他是的父类AbstractAutoProxyCreator实现了postProcessBeforeInstantiation这这个接口，所以我们先来看下这个postProcessBeforeInstantiation这个方法为我们做了什么事情？
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
Object cacheKey = this.getCacheKey(beanClass, beanName);
// 判断我们的bean是否处理过
if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
if (this.advisedBeans.containsKey(cacheKey)) {
return null;
}
// 判断是否是基础的bean或者直接跳过，不需要代理的
if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return null;
}
}
/** * 判断我们容器中有没有自定义的targetSource 有为我们自动创建对象 * 当时这一步
的要求比较高，而且我们正常不会这里创建对象 ... * */
if (beanName != null) {
TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
if (targetSource != null) {
this.targetSourcedBeans.add(beanName);
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
}
return null;
}
protected TargetSource getCustomTargetSource(Class<?> beanClass, String beanName) {
// 容器中必须要包含有个TargetSourceCreators 并且我们的组件也需要实现TargetSource接口
if (this.customTargetSourceCreators != null && this.beanFactory != null && this.beanFactory.containsBean(beanName)) {
TargetSourceCreator[] var3 = this.customTargetSourceCreators;
int var4 = var3.length;
for(int var5 = 0; var5 < var4; ++var5) {
TargetSourceCreator tsc = var3[var5];
TargetSource ts = tsc.getTargetSource(beanClass, beanName);
if (ts != null) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("TargetSourceCreator [" + tsc + "] found custom TargetSource for bean with name '" + beanName + "'");
}
return ts;
}
}
}
return null;
}4.2postProcessAfterInitialization方法的作用
从上面的分析我们知道，InfrastructrueAdvisorAutoPorxyCreator实现了后置处理器为我们创建代理对象，实际上是他的父类AbstractAutoProxyCreator实现了postProcessAfterInitiialization方法为我们创建代理对象，接下来我们来看下这个方法的源码解析。
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (bean != null) {
Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
if (!this.earlyProxyReferences.contains(cacheKey)) {
// 当前的对象是否需要包装，其实流程跟aop差不多
return this.wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 判断代理对象再postProcessAfterInitialization接口中是否被处理过
if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
return bean;
} else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
return bean;
} else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) { //判断是否是基础的bean或者是不需要处理
// 找到我们容器里面所有的增强器
Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
// 如果找到的增强器不为空
if (specificInterceptors != DO_NOT_PROXY) {
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 创建代理对象
Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
} else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
} else {
this.advisedBeans.put(cacheKey, Boolean.FALSE);
return bean;
}
}接下来我们要看看他具体是怎么去容器里面找到所有的增强器的。
// 查找合适的增强器
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
// 找到合适的增强器
List<Advisor> advisors = this.findEligibleAdvisors(beanClass, beanName);
// 如果找不到增强器则代表不需要代理
return advisors.isEmpty() ? DO_NOT_PROXY : advisors.toArray();
}
// 查找合适的增强器
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 查找候选的增强器
List<Advisor> candidateAdvisors = this.findCandidateAdvisors();
// 从候选的增强器中查找合适的增强器
List<Advisor> eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
// 对增强器进行扩展
this.extendAdvisors(eligibleAdvisors);
// 对增强器进行排序
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
// 找到候选的增强器
protected List<Advisor> findCandidateAdvisors() {
// 通过我们的增强器探测器进行查找
return this.advisorRetrievalHelper.findAdvisorBeans();
}
public List<Advisor> findAdvisorBeans() {
// 首先从缓存里面去查找看没有
String[] advisorNames = this.cachedAdvisorBeanNames;
if (advisorNames == null) {
// 若缓存里面查找不到，则去找实现了我们Advisor接口的实现类名称，org.springframework.aop.config.internalAutoProxyCreator
advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
// 放入到缓存里面去
this.cachedAdvisorBeanNames = advisorNames;
}
if (advisorNames.length == 0) {
return new ArrayList();
} else {
List<Advisor> advisors = new ArrayList();
String[] var3 = advisorNames;
int var4 = advisorNames.length;
// 循环增强器
for(int var5 = 0; var5 < var4; ++var5) {
String name = var3[var5];
// 判断是不是合适的
if (this.isEligibleBean(name)) {
// 判断当前增强器是不是正在创建
if (this.beanFactory.isCurrentlyInCreation(name)) {
if (logger.isDebugEnabled()) {
logger.debug("Skipping currently created advisor '" + name + "'");
}
} else {
try {
// 通过getBean的显示调用获取BeanFactoryTransactionAttributeSourceAdvisor 组件
advisors.add(this.beanFactory.getBean(name, Advisor.class));
} catch (BeanCreationException var10) {
Throwable rootCause = var10.getMostSpecificCause();
if (rootCause instanceof BeanCurrentlyInCreationException) {
BeanCreationException bce = (BeanCreationException)rootCause;
if (this.beanFactory.isCurrentlyInCreation(bce.getBeanName())) {
if (logger.isDebugEnabled()) {
logger.debug("Skipping advisor '" + name + "' with dependency on currently created bean: " + var10.getMessage());
}
continue;
}
}
throw var10;
}
}
}
}
return advisors;
}
}
// 判断是否适合的最终逻辑
// 容器中的bean定义包含当前的增强器的bean定义，且bean的role是int ROLE_INFRASTRUCTURE = 2;
protected boolean isEligibleAdvisorBean(String beanName) {
return this.beanFactory.containsBeanDefinition(beanName) && this.beanFactory.getBeanDefinition(beanName).getRole() == 2;
}
//============================================== findAdvisorsThatCanApply(candidateAdvisor)
protected List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
ProxyCreationContext.setCurrentProxiedBeanName(beanName);
List var4;
try {
// 真正的去候选器中查找出当前bean能用的增强器
var4 = AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
} finally {
ProxyCreationContext.setCurrentProxiedBeanName((String)null);
}
return var4;
}
public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
// 若传进来的候选器为空则直接返回
if (candidateAdvisors.isEmpty()) {
return candidateAdvisors;
} else {
// 创建一个本类能用的增前期集合
List<Advisor> eligibleAdvisors = new LinkedList();
Iterator var3 = candidateAdvisors.iterator();
// 循环候选的增强器
while(var3.hasNext()) {
Advisor candidate = (Advisor)var3.next();
// 判断当前的候选器是否是实现了IntroductionAdvisor ，很明显我们的不是
if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
eligibleAdvisors.add(candidate);
}
}
boolean hasIntroductions = !eligibleAdvisors.isEmpty();
Iterator var7 = candidateAdvisors.iterator();
while(var7.hasNext()) {
Advisor candidate = (Advisor)var7.next();
// 找出能用的增强器
if (!(candidate instanceof IntroductionAdvisor) && canApply(candidate, clazz, hasIntroductions)) {
eligibleAdvisors.add(candidate);
}
}
return eligibleAdvisors;
}
}
//找出本bean能够使用的增强器
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
// 根据继承图我们可以发现，BeanFactoryTransactionManagerAttributeAdvisor并没有实现IntroductionAdvisor
if (advisor instanceof IntroductionAdvisor) {
return ((IntroductionAdvisor)advisor).getClassFilter().matches(targetClass);
} else if (advisor instanceof PointcutAdvisor) {
// 强制转换为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;
} else {
// 获取切点中的方法匹配器
// 该切点在创建BeanFactoryTransactionAttributeSourceAdvisor的时候 创建了切点TransactionAttributeSourcePointcut
MethodMatcher methodMatcher = pc.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
return true;
} else {
IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
// 判断该方法匹配器是不是IntroductionAwareMethodMatcher
if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher)methodMatcher;
}
// 获取类实现的接口类型
Set<Class<?>> classes = new LinkedHashSet(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
classes.add(targetClass);
Iterator var6 = classes.iterator();
// 循环上一步的接口类型
while(var6.hasNext()) {
Class<?> clazz = (Class)var6.next();
// 获取接口的所有方法
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
Method[] var9 = methods;
int var10 = methods.length;
for(int var11 = 0; var11 < var10; ++var11) {
Method method = var9[var11];
// 正在进行匹配的是methodMatcher.matches(method, targetClass)这个逻辑
if (introductionAwareMethodMatcher != null && introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) || methodMatcher.matches(method, targetClass)) {
return true;
}
}
}
return false;
}
}
}
org.springframework.transaction.interceptor.TransactionAttributeSourcePointcut#matches
public boolean matches(Method method, Class<?> targetClass) {
if (targetClass != null && TransactionalProxy.class.isAssignableFrom(targetClass)) {
return false;
} else {
//获取我们的事务源对象在PorxyTransactionManagerConfiguration配置类中导入了这个类
TransactionAttributeSource tas = this.getTransactionAttributeSource();
// 从事务源对象中获取事务属性
return tas == null || tas.getTransactionAttribute(method, targetClass) != null;
}
}
// 获取事务属性对象
public TransactionAttribute getTransactionAttribute(Method method, Class<?> targetClass) {
if (method.getDeclaringClass() == Object.class) {
return null;
} else {
// 通过目标类和目标方法拼接缓存的key，例如：public abstract void org.springframework.beans.factory.SmartInitializingSingleton.afterSingletonsInstantiated()
// 去缓存中取
Object cacheKey = this.getCacheKey(method, targetClass);
TransactionAttribute cached = (TransactionAttribute)this.attributeCache.get(cacheKey);
if (cached != null) {
// 缓存中有就直接返回就好了
return cached == NULL_TRANSACTION_ATTRIBUTE ? null : cached;
} else {
// 计算事务属性
TransactionAttribute txAttr = this.computeTransactionAttribute(method, targetClass);
// 若事务属性为空
if (txAttr == null) {
// 则在缓存标记为事务方法
this.attributeCache.put(cacheKey, NULL_TRANSACTION_ATTRIBUTE);
} else {
String methodIdentification = ClassUtils.getQualifiedMethodName(method, targetClass);
// 为事务属性创建方法标记符
if (txAttr instanceof DefaultTransactionAttribute) {
((DefaultTransactionAttribute)txAttr).setDescriptor(methodIdentification);
}
if (this.logger.isDebugEnabled()) {
this.logger.debug("Adding transactional method '" + methodIdentification + "' with attribute: " + txAttr);
}
// 加入缓存中
this.attributeCache.put(cacheKey, txAttr);
}
return txAttr;
}
}
}
// 计算事务属性
protected TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {
// 这里判断方式修饰符
if (this.allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
return null;
} else {
Class<?> userClass = ClassUtils.getUserClass(targetClass);
// method为接口中的方法,specificMethod为我们实现类方法
Method specificMethod = ClassUtils.getMostSpecificMethod(method, userClass);
specificMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);
// 找我们【实现类】中的【方法】上的事物属性
TransactionAttribute txAttr = this.findTransactionAttribute(specificMethod);
if (txAttr != null) {
return txAttr;
} else {
// 【方法所在类】上有没有事物属性,则在实现类上查找
txAttr = this.findTransactionAttribute(specificMethod.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
} else {
if (specificMethod != method) {
// 实现方法、跟实现类上都没有事务属性，则在接口方法上面去查找
txAttr = this.findTransactionAttribute(method);
if (txAttr != null) {
return txAttr;
}
// 以上的都没有事务属性，则在接口上去查找
txAttr = this.findTransactionAttribute(method.getDeclaringClass());
if (txAttr != null && ClassUtils.isUserLevelMethod(method)) {
return txAttr;
}
}
return null;
}
}
}
}
// 从方法上查找事务属性
protected TransactionAttribute findTransactionAttribute(Method method) {
return this.determineTransactionAttribute(method);
}
protected TransactionAttribute determineTransactionAttribute(AnnotatedElement element) {
// 获取方法上的注解
if (element.getAnnotations().length > 0) {
Iterator var2 = this.annotationParsers.iterator();
while(var2.hasNext()) {
// 事务注解解析器
TransactionAnnotationParser annotationParser = (TransactionAnnotationParser)var2.next();
// 解析注解
TransactionAttribute attr = annotationParser.parseTransactionAnnotation(element);
if (attr != null) {
return attr;
}
}
}
return null;
}
// 解析我们的Transactional注解
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(element, Transactional.class);
// 这里真正的去解析@Transactional注解
return attributes != null ? this.parseTransactionAnnotation(attributes) : 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());
//事务超时
rbta.setTimeout(attributes.getNumber("timeout").intValue());
// 是否为只读
rbta.setReadOnly(attributes.getBoolean("readOnly"));
//事务的名称
rbta.setQualifier(attributes.getString("value"));
// 事务回滚规则
List<RollbackRuleAttribute> rollbackRules = new ArrayList();
Class[] var6 = attributes.getClassArray("rollbackFor");
int var7 = var6.length;
int var8;
Class rbRule;
for(var8 = 0; var8 < var7; ++var8) {
rbRule = var6[var8];
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
String[] var10 = attributes.getStringArray("rollbackForClassName");
var7 = var10.length;
String rbRule;
for(var8 = 0; var8 < var7; ++var8) {
rbRule = var10[var8];
rollbackRules.add(new RollbackRuleAttribute(rbRule));
}
var6 = attributes.getClassArray("noRollbackFor");
var7 = var6.length;
// 对哪些异常不进行回滚
for(var8 = 0; var8 < var7; ++var8) {
rbRule = var6[var8];
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
var10 = attributes.getStringArray("noRollbackForClassName");
var7 = var10.length;
// 对哪些类不会滚
for(var8 = 0; var8 < var7; ++var8) {
rbRule = var10[var8];
rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
}
rbta.setRollbackRules(rollbackRules);
return rbta;
}
到这里我们分析完了他是如果去查找出所有合适的增强器，下面我话一个流程图，大家看着这个流程图来理解也可以。
4.2.1真正的创建代理对象createProxy方法
源码位置：org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#createProxy
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
}
// 创建代理工厂
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.copyFrom(this);
// 判断是cglib代理还是jdk代理
if (!proxyFactory.isProxyTargetClass()) {
if (shouldProxyTargetClass(beanClass, beanName)) {
proxyFactory.setProxyTargetClass(true);
}
else {
evaluateProxyInterfaces(beanClass, proxyFactory);
}
}
// 把合适的拦截器转换为增强器
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
proxyFactory.addAdvisors(advisors);
proxyFactory.setTargetSource(targetSource);
customizeProxyFactory(proxyFactory);
proxyFactory.setFrozen(this.freezeProxy);
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
// 真正的创建代理对象
return proxyFactory.getProxy(getProxyClassLoader());
}
//创建代理对象
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
// 创建cglib接口
return new ObjenesisCglibAopProxy(config);
}
else {
// jdk代理
return new JdkDynamicAopProxy(config);
}
}
到这里我们分析完了Spring事务创建代理对象的流程，在Spring事务源码分析上篇中我们就分析到这里了，接下来下篇我们将分析代理对象调用流程分析，大家可以多debug这个流程。好了分享就到这里，大家相互加油,共同进步
583
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
