详解Spring的声明式事务

事务（Transactional）：

在软件开发领域，全有或全无的操作被称作事务，事务具有四个特性：ACID。

A:Atomic 原子性    确保事务中的所有操作全部发生或全部不发生
C:Consistent 一致性    事务的执行结果是确定
I:Isolated 隔离性     事务是彼此隔离的，避免同步读写相同数据
D:Durable 持久性     事务的结果是持久化的

Spring提供的事务管理器：
DataSourceTransactionManager  用于对jdbc和ibatis进行持久化的场景，实现了PlatformTransactionManager接口

利用IOC实例化配置如下：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource" />
</bean>

事务属性：

1、传播行为：定义了何时要创建一个事务或何时使用已有的事务；
2、隔离级别：定义了一个事务可能受其他并发事务影响的程度；
3、回滚规则：定义什么异常下回滚
4、事务超时：自动回滚时间
5、是否只读：对读数据库操作加声明，系统就会对该操作优化

Spring中声明事务的注解如下：

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {
	// 事务名
	String value() default "";
	// 事务传播行为
	Propagation propagation() default Propagation.REQUIRED;
	// 隔离级别
	Isolation isolation() default Isolation.DEFAULT;
	// 事务超时
	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
	// 是否只读
	boolean readOnly() default false;
	// 回滚规则

	// 需要回滚的异常
	Class<? extends Throwable>[] rollbackFor() default {};
	//
	String[] rollbackForClassName() default {};
	// 不需要回滚的异常
	Class<? extends Throwable>[] noRollbackFor() default {};
	//
	String[] noRollbackForClassName() default {};

}

<tx:annotation-driven transaction-manager="transactionManager"/>

上面的配置告诉Spring检查上下文中所有的Bean并查找使用@Transactional注解的Bean，不论注解级别是用在类级别上还是方法级别上，
找到Bean后会自动为它添加事务通知。

事务拦截器（AOP）

TransactionInterceptor调用invoke(final MethodInvocation invocation)进行事务处理

public Object invoke(final MethodInvocation invocation) throws Throwable {
	// Work out the target class: may be <code>null</code>.
	// 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);

	// If the transaction attribute is null, the method is non-transactional.
	final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(invocation.getMethod(), targetClass);
	final PlatformTransactionManager tm = determineTransactionManager(txAttr);
	final String joinpointIdentification = methodIdentification(invocation.getMethod(), targetClass);

	if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
		// Standard transaction demarcation with getTransaction and commit/rollback calls.
		TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
		Object retVal = null;
		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.proceed();
		}
		catch (Throwable ex) {
			// target invocation exception
			completeTransactionAfterThrowing(txInfo, ex);
			throw ex;
		}
		finally {
			cleanupTransactionInfo(txInfo);
		}
		commitTransactionAfterReturning(txInfo);
		return retVal;
	}

	else {
		// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
		try {
			Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
					// 事务回调函数
					new TransactionCallback<Object>() {
						public Object doInTransaction(TransactionStatus status) {
							TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
							try {
								return invocation.proceed();
							}
							catch (Throwable ex) {
								// 判断是否是需要回滚的异常类型
								if (txAttr.rollbackOn(ex)) {
									// A RuntimeException: will lead to a rollback.
									if (ex instanceof RuntimeException) {
										throw (RuntimeException) ex;
									}
									else {
										throw new ThrowableHolderException(ex);
									}
								}
								else {
									// 否则事务正常提交
									// A normal return value: will lead to a commit.
									return new ThrowableHolder(ex);
								}
							}
							finally {
								// Reset the TransactionInfo ThreadLocal.
								cleanupTransactionInfo(txInfo);
							}
						}
					});

			// Check result: It might indicate a Throwable to rethrow.
			if (result instanceof ThrowableHolder) {
				throw ((ThrowableHolder) result).getThrowable();
			}
			else {
				return result;
			}
		}
		catch (ThrowableHolderException ex) {
			throw ex.getCause();
		}
	}
}

AnnotationTransactionAttributeSource调用findTransactionAttribute(Method method)和findTransactionAttribute(Class<?> clazz)方法
获取TransactionAttribute（@Transactional注解中设置的五个事务属性参数）

类SpringTransactionAnnotationParser调用parseTransactionAnnotation方法生成TransactionAttribute（存储事务属性）

如果事务属性为空，则认为为非事务方法，直接调用原方法

CallbackPreferringPlatformTransactionManager调用execute(TransactionDefinition definition, TransactionCallback<T> callback)

TransactionCallback是处理事务的回调模板类（接口）

CallbackPreferringPlatformTransactionManager 继承自 PlatformTransactionManager

DataSourceTransactionManager实现的事务提交与回滚方法：

@Override
protected void doCommit(DefaultTransactionStatus status) {
	DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
	Connection con = txObject.getConnectionHolder().getConnection();
	if (status.isDebug()) {
		logger.debug("Committing JDBC transaction on Connection [" + con + "]");
	}
	try {
		con.commit();
	}
	catch (SQLException ex) {
		throw new TransactionSystemException("Could not commit JDBC transaction", ex);
	}
}

@Override
protected void doRollback(DefaultTransactionStatus status) {
	DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
	Connection con = txObject.getConnectionHolder().getConnection();
	if (status.isDebug()) {
		logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");
	}
	try {
		con.rollback();
	}
	catch (SQLException ex) {
		throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
	}
}

依懒接口：java.sql.Connection

Connection最终实现的类：com.mysql.jdbc.ConnectionImpl.class

利用visualvm查看JVM中的实例结果如下：

可以看出AOP代理和回调