spring（六）：事务

事务特性ACID

• 原子性（Atomicity）：即事务是不可分割的最小工作单元，事务内的操作要么全做，要么全不做；
• 一致性（Consistency）：在事务执行前数据库的数据处于正确的状态，而事务执行完成后数据库的数据还是处于正确的状态，即数据完整性约束没有被破坏。
• 隔离性（Isolation）：并发事务执行之间无影响，在一个事务内部的操作对其他事务是不产生影响，这需要事务隔离级别来指定隔离性；
• 持久性（Durability）：事务一旦执行成功，它对数据库的数据的改变必须是永久的，不会因比如遇到系统故障或断电造成数据不一致或丢失。

常见的问题

• 丢失更新：两个事务同时更新一行数据，最后一个事务的更新会覆盖掉第一个事务的更新，从而导致第一个事务更新的数据丢失，这是由于没有加锁造成的
• 脏读：一个事务看到了另一个事务未提交的更新数据
• 不可重复读：在同一事务中，多次读取同一数据却返回不同的结果（也就是有其他事务更改了这些数据）
• 幻读：一个事务在执行过程中读取到了另一个事务已提交的插入数据（即在第一个事务开始时读取到一批数据，但此后另一个事务又插入了新数据并提交，此时第一个事务又读取这批数据但发现多了一条，即好像发生幻觉一样）

事务隔离级别

• 未提交读（Read Uncommitted）：最低隔离级别，一个事务能读取到别的事务未提交的更新数据，很不安全，可能出现丢失更新、脏读、不可重复读、幻读；
• 提交读（Read Committed）：一个事务能读取到别的事务提交的更新数据，不能看到未提交的更新数据，不可能可能出现丢失更新、脏读，但可能出现不可重复读、幻读；
• 可重复读（Repeatable Read）：保证同一事务中先后执行的多次查询将返回同一结果，不受其他事务影响，可能可能出现丢失更新、脏读、不可重复读，但可能出现幻读；
• 序列化（Serializable）：最高隔离级别，不允许事务并发执行，而必须串行化执行，最安全，不可能出现更新、脏读、不可重复读、幻读。

隔离级别越高，数据库事务并发执行性能越差，能处理的操作越少。在实际项目开发中为了考虑并发性能一般使用提交读隔离级别，它能避免丢失更新和脏读，尽管不可重复读和幻读不能避免，但可以在可能出现的场合使用悲观锁或乐观锁来解决这些问题。

事务管理器

Spring框架支持事务管理的核心是事务管理器，通过实现策略接口PlatformTransactionManager支持各种数据访问框架的事务管理。

Spring 支持两种类型的事务管理:

• 编程式事务管理 ：这意味着你在编程的帮助下有管理事务。这给了你极大的灵活性，但却很难维护。
• 声明式事务管理 ：这意味着你从业务代码中分离事务管理。你仅仅使用注释或 XML 配置来管理事务。

public interface PlatformTransactionManager {
    // 根据给定的TransactionDefinition类型参数获取一个已经激活的事务或创建一个新的事务
    // 返回值TransactionStatus对象代表了当前事务的状态
    TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
    // 提交TransactionStatus参数代表的事务
    void commit(TransactionStatus var1) throws TransactionException;
    // 回滚TransactionStatus参数代表的事务
    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();	// 获取事务是否是只读的
    @Nullable
    String getName();  	// 获取事务名字
}

public interface TransactionStatus extends SavepointManager, Flushable {
    boolean isNewTransaction();	// 当前事务状态是否是新事务
    boolean hasSavepoint();	// 当前事务是否有保存点
    void setRollbackOnly();	// 设置当前事务应该回滚
    boolean isRollbackOnly();	// 当前事务是否应该回滚
    void flush();	// 刷新底层会话中的修改到数据库
    boolean isCompleted();	// 当前事务否已经完成
}

声明式事务处理的实现分析

声明式事务的实现就是通过环绕增强的方式，在目标方法执行之前开启事务，在目标方法执行之后提交或者回滚事务。

1. 读取和处理在IoC容器中配置的事务处理属性，并转化为事务处理幼的数据结构（TransactionAttribute）（使用通知器TransactionAttributeSourceAdvisor来完成事务处理属性的处理，和TransactionProxyFactoryBean拦截下来的事务方法的处理结合起来）
2. 实现统一的事务处理过程，包含处理事务配置属性和与线程绑定完成事务处理的过程。（TransactionInfo和TransactionStatus记录和传递相关执行场景）
3. 底层的事务处理实现。即PlatformTransactionManager接口的具体实现。

事务处理拦截器的配置

// TransactionProxyFactoryBean
	@Override
	// 在IoC容器完成bean的依赖注入时，通过bean的初始化方法被调用
	// 自此，transactionInterceptor配置被启动并成为通知器Advisor的一部分
	protected Object createMainInterceptor() {
		...
		if (this.pointcut != null) {
			return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);
		}
		else {
			// Rely on default pointcut.
			return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);
		}
	}

// AbstractSingletonProxyFactoryBean
	// 是事务处理完成aop配置的地方
    public void afterPropertiesSet() {
        // 检测bean
        ...else {
            ...
            // 创建代理工厂对象
            ProxyFactory proxyFactory = new ProxyFactory();
            // 为ProxyFactory生成代理对象、配置通知器、设置代理接口
            // 自此，拦截器被配置进代理对象中
            proxyFactory.addAdvisor(...);
            ...
            proxyFactory.setInterfaces(...);
            this.postProcessProxyFactory(proxyFactory);
            this.proxy = proxyFactory.getProxy(this.proxyClassLoader);
        }
    }

事务处理配置的读入

在TransactionInterceptor进行依赖注入时，其父类TransactionAspectSupport设置TransactionAttribute。

	public void setTransactionAttributes(Properties transactionAttributes) {
		NameMatchTransactionAttributeSource tas = new NameMatchTransactionAttributeSource();
		tas.setProperties(transactionAttributes);
		this.transactionAttributeSource = tas;
	}

	public void setProperties(Properties transactionAttributes) {
		TransactionAttributeEditor tae = new TransactionAttributeEditor();
		Enumeration<?> propNames = transactionAttributes.propertyNames();
		while (propNames.hasMoreElements()) {
			String methodName = (String) propNames.nextElement();
			String value = transactionAttributes.getProperty(methodName);
			tae.setAsText(value);
			TransactionAttribute attr = (TransactionAttribute) tae.getValue();
			addTransactionalMethod(methodName, attr);
		}
	}

事务处理拦截器的设计与实现

// TransactionInterceptor
	@Override
	@Nullable
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// Work out the target class: may be {@code null}.
		// The TransactionAttributeSource should be passed the target class
		// as well as the method, which may be from an interface.
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		// Adapt to TransactionAspectSupport's invokeWithinTransaction...
		return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
	}

// TransactionAspectSupport
	@Nullable
	protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
			final InvocationCallback invocation) throws Throwable {

		// If the transaction attribute is null, the method is non-transactional.
		TransactionAttributeSource tas = getTransactionAttributeSource();
		final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
        // 根据事务属性决定采用的事务处理器
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			// Standard transaction demarcation with getTransaction and commit/rollback calls.
            // 创建事务 ★
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);

			Object retVal;
			try {
				// This is an around advice: Invoke the next interceptor in the chain.
				// This will normally result in a target object being invoked.
                // 沿着拦截器链进行
				retVal = invocation.proceedWithInvocation();
			}...
			finally {
                // 事务信息更新
				cleanupTransactionInfo(txInfo);
			}
            // 提交事务<<PlatformTransactionManager>>
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}

		else {
			final ThrowableHolder throwableHolder = new ThrowableHolder();

			// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
			try {
				Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status -> {
					TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
					try {
						return invocation.proceedWithInvocation();
					}
					catch (Throwable ex) {
						if (txAttr.rollbackOn(ex)) {
							// A RuntimeException: will lead to a rollback.
							...
						}
						else {
							// A normal return value: will lead to a commit.
							...
						}
					}
					finally {
						cleanupTransactionInfo(txInfo);
					}
				});

				// Check result state: It might indicate a Throwable to rethrow.
				...
				return result;
			}
			...
		}
	}

	protected TransactionInfo createTransactionIfNecessary(@Nullable PlatformTransactionManager tm,
			@Nullable TransactionAttribute txAttr, final String joinpointIdentification) {

		// If no name specified, apply method identification as transaction name.
		if (txAttr != null && txAttr.getName() == null) {
			txAttr = new DelegatingTransactionAttribute(txAttr) {
				@Override
				public String getName() {
					return joinpointIdentification;
				}
			};
		}

		TransactionStatus status = null;
		if (txAttr != null) {
			if (tm != null) {
                // 获取事务对象，创建TransactionStatus对象
				status = tm.getTransaction(txAttr);
			}
			...
		}
        // 把TransactionStatus设置到TransactionInfo中，并绑定到当前线程
		return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
	}