publicinterfaceConnectionextendsWrapper, AutoCloseable {
/*** 设置当前连接的自动提交(auto-commit)模式:* * 如果设置为 true，则这个后续所有的 sql 都会以每条一个事务的形式执行；* * 如果设置为 false，则后续的 sql 会包装到单个事务中执行，直到遇到 commit 或 rollback 调用为止；* * 新的连接默认 auto-commit = true* 注：如果在事务中(auto-commit = false)修改 auto-commit 的值(改为 true），则会自动提交这个事务；*/voidsetAutoCommit(booleanautoCommit) throwsSQLException;
/*** 将从前一次 commit/rollback 调用到现在的所有变更持久化，并且释放掉当前连接持有的所有锁。* 是有当 auto-commit = false 时能使用*/voidcommit() throwsSQLException;
/*** 将当前事务的所有变更撤销，并且释放掉当前连接持有的所有锁。* 是有当 auto-commit = false 时能使用*/voidrollback() throwsSQLException;
intTRANSACTION_READ_UNCOMMITTED=1;
intTRANSACTION_READ_COMMITTED=2;
intTRANSACTION_REPEATABLE_READ=4;
intTRANSACTION_SERIALIZABLE=8;
/*** 尝试将当前事务的隔离级别更新的指定值* 注：如果在事务执行过程中改变隔离级别，具体行为视 Driver 实现而论*/voidsetTransactionIsolation(intlevel) throwsSQLException;
}

publicinterfaceConnectionextendsWrapper, AutoCloseable {
/*** 在当前事务中创建一个不具名的 Savepoint，并返回。*/SavepointsetSavepoint() throwsSQLException;
/*** 在当前事务中创建一个具名的 Savepoint，并返回。*/SavepointsetSavepoint(Stringname) throwsSQLException;
/*** 回滚到给定的 SavePoint*/voidrollback(Savepointsavepoint) throwsSQLException;
/*** 释放给定的 SavePoint*/voidreleaseSavepoint(Savepointsavepoint) throwsSQLException;
}
publicinterfaceSavepoint {
/*** 自动为 Savepoint 生成的数字 ID*/intgetSavepointId() throwsSQLException;
/*** Savepoint的名称。如果是一个不具名的Savepoint，调用此方法会报错*/StringgetSavepointName() throwsSQLException;
}

publicinterfacePlatformTransactionManager {
/*** 根据具体需求，获取当前活动的事务，或者新建一个事务。* 部分需求只能在新建事务时生效，若是使用当前获得的事务会被忽略。* 并不是所有需求都能被具体的实现所支持，这个时候会抛出一个异常。* * @params definition 描述所需的事务需求，包含传播行为，隔离级别，超时时间等等* @returns 用来表示返回的当前事务或新建事务的对象 */TransactionStatusgetTransaction(@NullableTransactionDefinitiondefinition) throwsTransactionException;
/*** 完成给定的事务。如果事务对象被标记为 rollback-only，则回滚事务；否则提交事务。* 如果这个事务不是 getTransaction 调用中新建的，则忽略本次调用，将提交或回滚留给事务更外层的参与者决定。*/voidcommit(TransactionStatusstatus) throwsTransactionException;
/*** 回滚给定的事务。* 如果这个事务不是 getTransaction 调用中新建的，则忽略掉这个操作，并将当前的事务对象设置为 rollback-only*/voidrollback(TransactionStatusstatus) throwsTransactionException;
}
/*** 用来定义一个 Spring 事务的需求。* 注：定义的隔离级别和超时时间，仅会在新建一个事务时生效（复用当前已有事务时会被忽略）。当且仅当传播行为为  PROPAGATION_REQUIRED, PROPAGATION_REQUIRES_NEW 和 PROPAGATION_NESTED 可能会新建一个事务，所以使用其他的传播行为通常不会设置隔离级别和超时时间。* 此外，不是所有的事务管理器实现都支持这些属性的（隔离级别设置、超时时间设置），如果使用这些管理器实现，且指定了某些不支持的属性值，就会抛出异常。* */publicinterfaceTransactionDefinition {
/** 传播行为配置可选值 */// 默认的传播行为。当前上下文有事务，则使用当前事务；否则新开一个事务。intPROPAGATION_REQUIRED=0;
// 如果当前上下文有事务，则使用当前事务；否则在无事务的上下文中执行。intPROPAGATION_SUPPORTS=1;
// 强制使用当前上下文中的事务；如果当前上下文没有事务，则抛出异常。intPROPAGATION_MANDATORY=2;
// 始终新开一个事务，如果当前上下文中有事务，则将其挂起。intPROPAGATION_REQUIRES_NEW=3;
// 始终在无事务的上下文中执行，如果当前上下文中有事务，则将其挂起。intPROPAGATION_NOT_SUPPORTED=4;
// 始终在无事务的上下文中执行，如果当前上下文中有事务，则抛出异常。intPROPAGATION_NEVER=5;
// 如果当前上下文有事务，则新开一个嵌套事务；如果当前上下文没有事务，则新开一个事务。注意，不是所有的事务管理器实现都支持嵌套事务的intPROPAGATION_NESTED=6;
/** 隔离级别配置可选值 */// 不显示设置隔离级别。默认根据事务管理的实现，或使用JDBC、数据库设定的隔离级别intISOLATION_DEFAULT=-1;
intISOLATION_READ_UNCOMMITTED=Connection.TRANSACTION_READ_UNCOMMITTED;
intISOLATION_READ_COMMITTED=Connection.TRANSACTION_READ_COMMITTED;
intISOLATION_REPEATABLE_READ=Connection.TRANSACTION_REPEATABLE_READ;
intISOLATION_SERIALIZABLE=Connection.TRANSACTION_SERIALIZABLE;
// 不显示设置超时时间。默认根据事务管理的实现，或使用JDBC、数据库设定的超时时间intTIMEOUT_DEFAULT=-1;
intgetPropagationBehavior();
intgetIsolationLevel();
intgetTimeout();
// 是否是只读事务booleanisReadOnly();
// 可选，事务的名称@NullableStringgetName();
}
/*** 用来代表一个事务和它关联的状态信息*/publicinterfaceTransactionStatusextendsSavepointManager, Flushable {
/*** 是否是在 getTransaction 调用中新建的一个事务*/booleanisNewTransaction();
/*** 事务中是否创建了Savepoint*/booleanhasSavepoint();
/** 将当前事务标记为 rollback-only，即告诉事务管理器这个事务只能够回滚。*/voidsetRollbackOnly();
/*** 当前事务是否被标记为 rollback-only*/booleanisRollbackOnly();
/*** Flush the underlying session to the datastore, if applicable:* for example, all affected Hibernate/JPA sessions.* <p>This is effectively just a hint and may be a no-op if the underlying* transaction manager does not have a flush concept. A flush signal may* get applied to the primary resource or to transaction synchronizations,* depending on the underlying resource.*//*** 当前事务是否已完成（已提交或已混滚）*/booleanisCompleted();
// 创建并返回一个 Savepoint@OverrideObjectcreateSavepoint() throwsTransactionException;
// 回滚到指定的 Savepoint@OverridevoidrollbackToSavepoint(Objectsavepoint) throwsTransactionException;
// 显示地删除指定的 Savepoint@OverridevoidreleaseSavepoint(Objectsavepoint) throwsTransactionException;
}

public<T>Texecute(TransactionCallback<T>action) throwsTransactionException {
Assert.state(this.transactionManager!=null, "No PlatformTransactionManager set");
if (this.transactionManagerinstanceofCallbackPreferringPlatformTransactionManager) {
return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action);
}
else {
TransactionStatusstatus=this.transactionManager.getTransaction(this);
Tresult;
try {
result=action.doInTransaction(status);
}
catch (RuntimeException|Errorex) {
// Transactional code threw application exception -> rollbackrollbackOnException(status, ex);
throwex;
}
catch (Throwableex) {
// Transactional code threw unexpected exception -> rollbackrollbackOnException(status, ex);
thrownewUndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
}
this.transactionManager.commit(status);
returnresult;
}
}
privatevoidrollbackOnException(TransactionStatusstatus, Throwableex) throwsTransactionException {
Assert.state(this.transactionManager!=null, "No PlatformTransactionManager set");
logger.debug("Initiating transaction rollback on application exception", ex);
try {
this.transactionManager.rollback(status);
}
catch (TransactionSystemExceptionex2) {
logger.error("Application exception overridden by rollback exception", ex);
ex2.initApplicationException(ex);
throwex2;
}
catch (RuntimeException|Errorex2) {
logger.error("Application exception overridden by rollback exception", ex);
throwex2;
}
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited@Documentedpublic@interfaceTransactional {
@AliasFor("transactionManager")
Stringvalue() default"";
@AliasFor("value")
StringtransactionManager() default"";
Propagationpropagation() defaultPropagation.REQUIRED;
Isolationisolation() defaultIsolation.DEFAULT;
inttimeout() defaultTransactionDefinition.TIMEOUT_DEFAULT;
booleanreadOnly() defaultfalse;
Class<?extendsThrowable>[] rollbackFor() default {};
String[] rollbackForClassName() default {};
Class<?extendsThrowable>[] noRollbackFor() default {};
String[] noRollbackForClassName() default {};
}

protectedObjectinvokeWithinTransaction(Methodmethod, @NullableClass<?>targetClass,
finalInvocationCallbackinvocation) throwsThrowable {
// If the transaction attribute is null, the method is non-transactional.TransactionAttributeSourcetas=getTransactionAttributeSource();
finalTransactionAttributetxAttr= (tas!=null?tas.getTransactionAttribute(method, targetClass) : null);
finalPlatformTransactionManagertm=determineTransactionManager(txAttr);
finalStringjoinpointIdentification=methodIdentification(method, targetClass, txAttr);
if (txAttr==null||!(tminstanceofCallbackPreferringPlatformTransactionManager)) {
// Standard transaction demarcation with getTransaction and commit/rollback calls.TransactionInfotxInfo=createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
ObjectretVal=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.proceedWithInvocation();
}
catch (Throwableex) {
// target invocation exceptioncompleteTransactionAfterThrowing(txInfo, ex);
throwex;
}
finally {
cleanupTransactionInfo(txInfo);
}
commitTransactionAfterReturning(txInfo);
returnretVal;
}
else {
finalThrowableHolderthrowableHolder=newThrowableHolder();
// It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.try {
Objectresult= ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr, status-> {
TransactionInfotxInfo=prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
try {
returninvocation.proceedWithInvocation();
}
catch (Throwableex) {
if (txAttr.rollbackOn(ex)) {
// A RuntimeException: will lead to a rollback.if (exinstanceofRuntimeException) {
throw (RuntimeException) ex;
}
else {
thrownewThrowableHolderException(ex);
}
}
else {
// A normal return value: will lead to a commit.throwableHolder.throwable=ex;
returnnull;
}
}
finally {
cleanupTransactionInfo(txInfo);
}
});
// Check result state: It might indicate a Throwable to rethrow.if (throwableHolder.throwable!=null) {
throwthrowableHolder.throwable;
}
returnresult;
}
catch (ThrowableHolderExceptionex) {
throwex.getCause();
}
catch (TransactionSystemExceptionex2) {
if (throwableHolder.throwable!=null) {
logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
ex2.initApplicationException(throwableHolder.throwable);
}
throwex2;
}
catch (Throwableex2) {
if (throwableHolder.throwable!=null) {
logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
}
throwex2;
}
}
}

@ComponentpublicclassFoo {
publicvoida() {
this.b();
    }
@Transactionalpublicvoidb() {
// do something    }
}

@ComponentpublicclassFoo {
@AutowireprivateApplicationContextapplicationContext;
publicvoida() {
// 从 spring 中拿到代理之后的 bean，再发起调用applicationContext.getBean(Foo.class).b();
    }
@Transactionalpublicvoidb() {
// do something    }
}