事务源码解析

一、事务概念：和调用入口说明
1.ACID;
atomicity- 原子性,consistency - 一致性,lsolation- 隔离性,durability - 持久性；
一致性：事务将数据库从一个一致状态转移到另一个一致状态；

2.Spring事务三大接口：
PlatformTransactionManager：事务管理器；通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供对应的事务管理器，但具体的实现由各个平台实现；
TransactionDefinition:事务定义信息(事务隔离级别–传播行为–超时–只读–回滚原则)；
TransactionStatus:事务运行状态；

3.@EnabelTransactionManagement 注解详解；
@Import(TransactionManagentConfigurationSelector.class)
–AutoProxyRegistrar -->InfrastructureAdvisorAutoProxyCreator
–ProxyTransactionManagementConfiguration类(3个方法返回值：BeanFactoryTransactionAttributeSourceAdvisor–TransactionAttributeSource–TransactionInterceptor)
3.1:InfrastructureAdvisorAutoProxyCreator 具体分析；Aware接口(代表BeanFactoryAware)，InstantiationAwareBeanPostProcessor后置处理器；

1.
/******************** 事务管理器 *******************/
public interface PlatformTransactionManager {
   
//获取事务的状态
    TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;
//事务提交
    void commit(TransactionStatus var1) throws TransactionException;
//事务回滚
    void rollback(TransactionStatus var1) throws TransactionException;
}


/******************** 事务定义信息 *******************/
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;
    int PROPAGATION_NESTED = 6;
    /***
      ** 上面-传播行为
      ** 下面-隔离级别
      **/
    int ISOLATION_DEFAULT = -1;
    int ISOLATION_READ_UNCOMMITTED = 1;
    int ISOLATION_READ_COMMITTED = 2;
    int ISOLATION_REPEATABLE_READ = 4;
    int ISOLATION_SERIALIZABLE = 8;
    //使用默认的超时时间
    int TIMEOUT_DEFAULT = -1;
//获取事务的传播行为
    int getPropagationBehavior();
//获取事务隔离级别
    int getIsolationLevel();
//获取事务超时时间
    int getTimeout();
//返回当前事务是否为只读
    boolean isReadOnly();
//获取事务名称
    String getName();
}

/******************** 事务运行的状态 *******************/
public interface TransactionStatus extends SavepointManager, Flushable {
   
//是否为新事物
    boolean isNewTransaction();
//是否有保存点
    boolean hasSavepoint();
//设置为只回滚
    void setRollbackOnly();
//是否为只回滚
    boolean isRollbackOnly();

    void flush();
//判断当前事务是否已经完成
    boolean isCompleted();
}

1.@EnableTransactionManagement

2.//通过@Import(.)，导入了2. TransactionManagementConfigurationSelector.class
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
   

3.public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
   

	/**
	 * Returns {@link ProxyTransactionManagementConfiguration} or
	 * {@code AspectJTransactionManagementConfiguration} for {@code PROXY}
	 * and {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()},
	 * respectively.
	 */
	@Override
	protected String[] selectImports(AdviceMode adviceMode) {
   
		switch (adviceMode) {
   
		//默认的配置是proxy
			case PROXY:
				return new String[] {
   AutoProxyRegistrar.class.getName(),
						ProxyTransactionManagementConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {
   
						TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};
			default:
				return null;
		}
	}

}

4.//AutoProxyRegistrar为我们容器注册了一个InfrastructureAdvisorAutoProxyCreator组件
public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
   
AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
}
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);
    }

5.public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
   
    private ConfigurableListableBeanFactory beanFactory;

InfrastructureAdvisorAutoProxyCreator继承图：

InfrastrureAdvisorAutoProxyCreator:
1.InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
   
    private ConfigurableListableBeanFactory beanFactory;

    public InfrastructureAdvisorAutoProxyCreator() {
   
    }
//重写父类的
    protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   
        super.initBeanFactory(beanFactory);
        this.beanFactory = beanFactory;
    }
2.	class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
   
3.	class AbstractAutoProxyCreator extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
   
4.	interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {
   
5.	public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
   
6.	AbstractAutoProxyCreator 实现了BeanFactoryAware ;但是又马上被AbstractAdvisorAutoProxyCreator 重写； 

public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
   
    private BeanFactoryAdvisorRetrievalHelper advisorRetrievalHelper;

    public AbstractAdvisorAutoProxyCreator() {
   
    }
//重写方法
    public void setBeanFactory(BeanFactory beanFactory) {
   
        super.setBeanFactory(beanFactory);
        if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
   
            throw new IllegalArgumentException("AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
        } else {
   
            this.initBeanFactory((ConfigurableListableBeanFactory)beanFactory);
        }
    }
6.AbstractAdvisorAutoProxyCreator实现了InstantiationAwareBeanPostProcessor 类型的后置处理器；
6.1：

        Object cacheKey = this.getCacheKey(beanClass, beanName);
        if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
   
            if (this.advisedBeans.containsKey(cacheKey)) {
   
                return null;
            }

            if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
   
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        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;
    }

6.2：postProcessAfterInstantiation方法
public boolean postProcessAfterInstantiation(Object bean, String beanName) {
   
        return true;
    }

7.BeanPostProcessor 类型后置处理器，为容器做了什么
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
   
        if (bean != null) {
   
            Object cacheKey = this.</