spring事务接口规范

        spring事务管理现阶段主要通过三个重要接口规范，TransactionDefinition事务定义，主要定义事务的名称，传播属性，事务隔离级别，是否只读，超时时间等；TransactionStatus事务执行中的状态，主要封装保存事务执行过程中的数据及状态；TransactionManager事务管理器，管理事务的执行（开启事务，提交或回滚事务）。

TransactionDefiniton事务定义

TransactionDefiniton规范是通过jdk8以上采用默认方法实现。主要定义了事务的属性：

1. 事务名称
2. 事务传播行为
3. 事务隔离级别
4. 是否只读
5. 执行超时时间

public interface TransactionDefinition {
 
    // 7种事务传播行为
    // 1.如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。
	int PROPAGATION_REQUIRED = 0; 
    // 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。
	int PROPAGATION_SUPPORTS = 1; 
    // 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
	int PROPAGATION_MANDATORY = 2; 
    // 开启一个新的事务。如果一个事务已经存在，则先将这个存在的事务挂起。
	int PROPAGATION_REQUIRES_NEW = 3; 
    // 以非事务的方式运行，若当前存在事务，就挂起当前事务
	int PROPAGATION_NOT_SUPPORTED = 4; 
    // 总是非事务地执行，并挂起任何存在的事务
	int PROPAGATION_NEVER = 5; 
    // 如果一个活动的事务存在，则运行在一个嵌套的事务中。 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。
 	int PROPAGATION_NESTED = 6; 
    
	int ISOLATION_DEFAULT = -1;// 默认使用数据库隔离级别
	int ISOLATION_READ_UNCOMMITTED = 1;  // same as java.sql.Connection.TRANSACTION_READ_UNCOMMITTED;
	int ISOLATION_READ_COMMITTED = 2;  // same as java.sql.Connection.TRANSACTION_READ_COMMITTED;
	int ISOLATION_REPEATABLE_READ = 4;  // same as java.sql.Connection.TRANSACTION_REPEATABLE_READ;
	int ISOLATION_SERIALIZABLE = 8;  // same as java.sql.Connection.TRANSACTION_SERIALIZABLE;
 
	int TIMEOUT_DEFAULT = -1;
 
	default int getPropagationBehavior() {
		return PROPAGATION_REQUIRED;
	}
	default int getIsolationLevel() {
		return ISOLATION_DEFAULT;
	}
	default int getTimeout() {
		return TIMEOUT_DEFAULT;
	}
	default boolean isReadOnly() {
		return false;
	}
	@Nullable
	default String getName() {
		return null;
	}
	static TransactionDefinition withDefaults() {
		return StaticTransactionDefinition.INSTANCE;
    }
}

TransactionDefinition UML

public class DefaultTransactionDefinition implements TransactionDefinition, Serializable {
	private int propagationBehavior = PROPAGATION_REQUIRED;
	private int isolationLevel = ISOLATION_DEFAULT;
	private int timeout = TIMEOUT_DEFAULT;
	private boolean readOnly = false;
	@Nullable
	private String name;
}

DefaultTransactionDefinition默认事务定义中定义了属性规范中的属性字段。

TransactionAttribute定义

TransactionAttribute继承了TransactionDefinition增加了一些标签属性及rollbackOn字段。

public interface TransactionAttribute extends TransactionDefinition {
	@Nullable
	String getQualifier();
	Collection<String> getLabels();
	boolean rollbackOn(Throwable ex);
}

TransactionStatus事务运行状态

TransactionStatus主要作为事务运行时载体，保存着事务信息，事务的状态。

public interface SavepointManager {
	Object createSavepoint() throws TransactionException;
	void rollbackToSavepoint(Object savepoint) throws TransactionException;
	void releaseSavepoint(Object savepoint) throws TransactionException;
}

public interface TransactionExecution {
	boolean isNewTransaction();
	void setRollbackOnly();
	boolean isRollbackOnly();
	boolean isCompleted();
}
// 主要组合了保存点规范（SavepointManager）及执行中状态规范（TransactionExecution）
public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {
	boolean hasSavepoint();
	@Override
	void flush();
}

DefaultTransactionStatus默认实现

抽象实现

public abstract class AbstractTransactionStatus implements TransactionStatus {

	private boolean rollbackOnly = false;
	private boolean completed = false;
	@Nullable
	private Object savepoint;

    // --------------对savePoint的操作----------------------
    public void createAndHoldSavepoint() throws TransactionException {
		setSavepoint(getSavepointManager().createSavepoint());
	}
 
	public void rollbackToHeldSavepoint() throws TransactionException {
		Object savepoint = getSavepoint();
		if (savepoint == null) {
			throw new TransactionUsageException("Cannot roll back to savepoint - no savepoint associated with current transaction");
		}
		getSavepointManager().rollbackToSavepoint(savepoint);
		getSavepointManager().releaseSavepoint(savepoint);
		setSavepoint(null);
	}
 
	public void releaseHeldSavepoint() throws TransactionException {
		Object savepoint = getSavepoint();
		if (savepoint == null) {
			throw new TransactionUsageException("Cannot release savepoint - no savepoint associated with current transaction");
		}
		getSavepointManager().releaseSavepoint(savepoint);
		setSavepoint(null);
	}

	//---------------------------------------------------------------------
	// Implementation of SavepointManager
	//---------------------------------------------------------------------
 
	@Override
	public Object createSavepoint() throws TransactionException {
		return getSavepointManager().createSavepoint();
	}
 
	@Override
	public void rollbackToSavepoint(Object savepoint) throws TransactionException {
		getSavepointManager().rollbackToSavepoint(savepoint);
	}
 
	@Override
	public void releaseSavepoint(Object savepoint) throws TransactionException {
		getSavepointManager().releaseSavepoint(savepoint);
	}
}

默认实现：

public class DefaultTransactionStatus extends AbstractTransactionStatus {

	@Nullable
	private final Object transaction;// 底层具体事务对象（封装了连接等）
	private final boolean newTransaction;//是否是新开启的事务（=true时才会提交事务）
	private final boolean newSynchronization;// 是否是新建的同步器（=true时才会执行回调事件）
	private final boolean readOnly;

    // 挂起的资源信息（事务传播行为要求挂起当前事务时，挂起的事务暂存信息，执行完后用于恢复）
	@Nullable
	private final Object suspendedResources;
 
	public DefaultTransactionStatus(
			@Nullable Object transaction, boolean newTransaction, boolean newSynchronization,
			boolean readOnly, boolean debug, @Nullable Object suspendedResources) {
		this.transaction = transaction;
		this.newTransaction = newTransaction;
		this.newSynchronization = newSynchronization;
		this.readOnly = readOnly;
		this.debug = debug;
		this.suspendedResources = suspendedResources;
	}
}

TransactionManager事务管理器

TransactionManager事务管理器，主要管理spring的事务传播行为，事务的开始，提交或回滚，以及诸多事务执行过程中的事件监听机制。

public interface TransactionManager {
	// TransactionManager只是一个标记接口
}

// 
public interface PlatformTransactionManager extends TransactionManager {
    // 根据事务的定义，创建事务并返回事务运行状态对象
	TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
	// 提交或回滚
    void commit(TransactionStatus status) throws TransactionException;
	void rollback(TransactionStatus status) throws TransactionException;
}

事务管理器的实现模板在于AbstractPlatformTransactionManager，在这个类中提供了事务的开启，事务传播行为的执行，事务挂起提交等模板方法的封装，参见AbstractPlatformTransactionManager详解