class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {
// 拦截器的拦截方法
public Object invoke(MethodInvocation invocation) {
// 获取目标的原始对象
Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
// 开始事务执行
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed) {
// 获取事务属性源对象,内部包含已经解析过的@Transactional注解信息
TransactionAttributeSource tas = getTransactionAttributeSource();
// 获取解析好的@Transactional注解信息
final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
// 获取事务管理器,因为有多种不同的方式来指定事务管理器
final TransactionManager tm = determineTransactionManager(txAttr);
// 处理普通事务的管理器只支持PlatformTransactionManager这种类型,否则抛出异常
PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
// 获取方法签名,类名.方法名,它要作为最后的事务名称
final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
// 如果不存在注解信息,或者事务管理器不是CallbackPreferringPlatformTransactionManager这种特殊类型
if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
// 根据情况看一下是否需要事务信息
TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);
{
// 如果事务属性没有设置名称,使用方法签名作为事务名称
if (txAttr != null && txAttr.getName() == null) {
txAttr = new DelegatingTransactionAttribute(txAttr) {
@Override
public String getName() {
return joinpointIdentification;
}
};
}
TransactionStatus status = null;
// 如果存在事务注解信息,并且存在事务管理器
if (txAttr != null && tm != null) {
// 获取事务信息,返回事务状态
status = tm.getTransaction(txAttr) {
// 获取事务定义信息,实际上就是事务属性,解析到了事务注解信息
TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
// 获取事务对象
Object transaction = doGetTransaction() {
// 创建事务对象
DataSourceTransactionObject txObject = new DataSourceTransactionObject();
// 设置当前事务对象是否允许设置保存点
txObject.setSavepointAllowed(isNestedTransactionAllowed());
// 看一下在这之前有没有事务将jdbc链接信息保存到事务同步管理器中
// key为当前数据源对象
// 如果是当前为新增的事务,那么肯定没有,如果在这之前开启了事务,那么连接是存在的
ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.getResource(obtainDataSource());
// 如果存在连接信息,保存到事务对象中,并且标记为当前链接不是新建的
txObject.setConnectionHolder(conHolder, false);
// 返回事务对象
return txObject;
}
// 判断是否是已经存在的事务
if (isExistingTransaction(transaction) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
// 需要判断当前ConnectionHolder存在,并且判断ConnectionHolder中的事务是否设置了活跃标识
// 因为在获取连接的时候,会设置连接手动提交,接着会将当前连接持有者ConnectionHolder设置事务状态为活跃的
// 因此,只有获取到了连接,并且开启了事务控制,那么就确定当前判断的事务对象是存在的
return (txObject.hasConnectionHolder() && txObject.getConnectionHolder().isTransactionActive());
})
{
// 处理已存在的事务
return handleExistingTransaction(def, transaction, debugEnabled);
{
// 标识了有事务就要抛异常
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
throw new IllegalTransactionStateException("Existing transaction found for transaction marked with propagation 'never'");
}
// 标识了不支持事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
// 暂停当前事务
Object suspendedResources = suspend(transaction) {
// 当前同步信息是否激活,进行了初始化
// 之前调用过prepareSynchronization方法就会进行激活
// 如果之前存在事务,那么一定被激活过,除非手动重置了
if (TransactionSynchronizationManager.isSynchronizationActive()) {
// 获取到当前线程绑定的所有TransactionSynchronization,回调接口的suspend暂停方法
List<TransactionSynchronization> suspendedSynchronizations = doSuspendSynchronization();
Object suspendedResources = null;
if (transaction != null) {
// 如果存在事务,将事务暂停
suspendedResources = doSuspend(transaction);
{
// 解绑存在当前线程中的数据库链接
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
txObject.setConnectionHolder(null);
return TransactionSynchronizationManager.unbindResource(obtainDataSource());
}
}
// 保存暂停之前的配置
String name = TransactionSynchronizationManager.getCurrentTransactionName();
TransactionSynchronizationManager.setCurrentTransactionName(null);
boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
TransactionSynchronizationManager.setActualTransactionActive(false);
// 封装成暂停的资源对象
return new SuspendedResourcesHolder(suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
}
}
// 如果没有进行同步
if (transaction != null) {
// 如果存在事务,将事务暂停
Object suspendedResources = doSuspend(transaction);
// 封装成暂停的资源对象
return new SuspendedResourcesHolder(suspendedResources);
}
}
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 提前设置事务状态信息,进行同步
return prepareTransactionStatus(definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}
// 新事务是PROPAGATION_REQUIRES_NEW,下面有详细的PROPAGATION_REQUIRES_NEW解析
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
// 暂停当前事务
SuspendedResourcesHolder suspendedResources = suspend(transaction);
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 创建事务状态
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 开启jdbc事务
doBegin(transaction, definition);
// 提前设置同步信息
prepareSynchronization(status, definition);
return status;
}
// 如果新事物是嵌套事务
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
if (!isNestedTransactionAllowed()) {
throw new NestedTransactionNotSupportedException("Transaction manager does not allow nested transactions by default - " + "specify 'nestedTransactionAllowed' property with value 'true'");
}
// 支持嵌套事务
if (useSavepointForNestedTransaction()) {
// 提前设置事务状态信息,同时进行同步设置
DefaultTransactionStatus status = prepareTransactionStatus(definition, transaction, false, false, debugEnabled, null);
// 创建保存点
status.createAndHoldSavepoint();
return status;
} else {
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 新建事务状态
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);
// 开启事务
doBegin(transaction, definition);
// 提前进行同步设置
prepareSynchronization(status, definition);
return status;
}
}
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 提前设置事务状态信息,进行同步设置
return prepareTransactionStatus(definition, transaction, false, newSynchronization, debugEnabled, null);
}
}
// 如果是新事务的话,校验事务的超时事件合法型
if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
}
// PROPAGATION_MANDATORY:强制在事务中执行,如果不存在事务,那么就抛出异常
if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
throw new IllegalTransactionStateException("No existing transaction found for transaction marked with propagation 'mandatory'");
}
// PROPAGATION_REQUIRED,PROPAGATION_REQUIRES_NEW,PROPAGATION_NESTED只有这三种需要开启事务,其他的都可以不开启或者是不需要事务
int behavior = def.getPropagationBehavior();
if (behavior == TransactionDefinition.PROPAGATION_REQUIRED || behavior == TransactionDefinition.PROPAGATION_REQUIRES_NEW || behavior == TransactionDefinition.PROPAGATION_NESTED) {
// 暂停当前事务,如果手动设置了同步信息,返回手动设置的一些同步信息配置,并且封装成SuspendedResourcesHolder
// 如果没有手动设置,就不需要暂停
SuspendedResourcesHolder suspendedResources = suspend(null);
try {
// getTransactionSynchronization默认为: SYNCHRONIZATION_ALWAYS,总是同步,所以这个总为true,除非手动设置了
boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
// 封装成DefaultTransactionStatus对象
DefaultTransactionStatus status = newTransactionStatus(def, transaction, true, newSynchronization, debugEnabled, suspendedResources);
// 开启jdbc事务
doBegin(transaction, def) {
DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
Connection con = null;
// 当前事务对象中不存在ConnectionHolder,或者synchronizedWithTransaction标识了资源与事务已经进行了同步,默认为false
// 如果是新事物,那么ConnectionHolder肯定是空的
// ConnectionHolder中的连接已经与事务进行同步了,那么也要获取新链接,用当前新连接与当前事务进行同步(这个条件极少满足)
if (!txObject.hasConnectionHolder() || txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
// 通过数据源获取链接
Connection newCon = obtainDataSource().getConnection();
// 将jdbc连接封装到ConnectionHolder中,并保存到事务对象中,并且表示ConnectionHolder为新创建的
txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
}
// 获取jdbc连接之后,将synchronizedWithTransaction设置为true,标识资源与事务进行同步了
txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
// 获取连接信息
con = txObject.getConnectionHolder().getConnection();
// 设置隔离级别和只读标识
Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
txObject.setPreviousIsolationLevel(previousIsolationLevel);
txObject.setReadOnly(definition.isReadOnly());
// 如果为自动提交事务
if (con.getAutoCommit()) {
// 标记必须要重置自动提交标识
txObject.setMustRestoreAutoCommit(true);
// 设置手动提交
con.setAutoCommit(false);
}
// 提前处理事务链接信息
prepareTransactionalConnection(con, definition) {
// 设置只读指令
if (isEnforceReadOnly() && definition.isReadOnly()) {
Statement stmt = con.createStatement();
stmt.executeUpdate("SET TRANSACTION READ ONLY");
}
}
// 设置当前事务已开启,处于活跃状态
txObject.getConnectionHolder().setTransactionActive(true);
// 设置超时时间
int timeout = determineTimeout(definition);
if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
}
// 如果是新的jdbc连接
if (txObject.isNewConnectionHolder()) {
// 将当前jdbc连接持有者绑定都当前线程的资源中
TransactionSynchronizationManager.bindResource(obtainDataSource(), txObject.getConnectionHolder());
}
}
}
// 提前设置同步信息,下面有详细讲到
prepareSynchronization(status, def);
// 返回事务状态
return status;
} catch(RuntimeException | Error ex){
// 如果出现异常,需要恢复之前的状态
resume(null, suspendedResources);
throw ex;
}
} else {
// 创建“空”事务:没有实际的事务,但可能需要同步
// 就是没有实际开启jdbc事务
// getTransactionSynchronization默认为: SYNCHRONIZATION_ALWAYS,总是同步,所以这个总为true,除非手动设置了
boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
// 提前设置事务状态信息
return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
{
// 封装成DefaultTransactionStatus对象
DefaultTransactionStatus status = newTransactionStatus(definition, transaction, newTransaction, newSynchronization, debug, suspendedResources);
// 提前设置同步信息
prepareSynchronization(status, definition);
{
// TransactionSynchronizationManager,是管理整个事务范围同步操作的一个工具类
// 他可以管理事务同步回调
// 在 Spring 中，可以通过 TransactionSynchronizationManager 类注册事务同步回调，这些回调操作会在事务的不同阶段（比如提交、回滚、完成）执行。这样可以确保在事务执行过程中的关键时刻执行一些自定义的逻辑
// 将线程绑定事务状态
// TransactionSynchronizationManager 通过使用 ThreadLocal 来绑定事务状态到当前线程，确保在同一个事务范围内可以访问相同的事务状态。这样可以方便地在多个方法间共享事务状态
// 执行事务同步操作
// 通过 TransactionSynchronizationManager，可以注册 TransactionSynchronization 对象，这些对象中定义了在事务提交、回滚等操作时要执行的方法。这样可以实现一些与事务相关的操作，例如清理资源、发送消息等
// 支持多个事务管理器
// TransactionSynchronizationManager 支持同时管理多个事务管理器的事务状态，在多数据源或者不同的事务管理方案下，都可以保证各自的事务状态独立维护
// 判断当前事务状态是否是一个新的同步信息,是上面传递的,默认为true
// newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
if (status.isNewSynchronization()) {
// 如果是新的同步信息
// 将当前真实存在的事务状态进行同步,进行事务状态共享
TransactionSynchronizationManager.setActualTransactionActive(status.hasTransaction());
// 将当前事务的隔离级别进行同步
TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT ? definition.getIsolationLevel() : null);
// 将是否只读表示进行同步
TransactionSynchronizationManager.setCurrentTransactionReadOnly(definition.isReadOnly());
// 将事务名称进行同步,就是方法名称
TransactionSynchronizationManager.setCurrentTransactionName(definition.getName());
// 初始化同步信息
TransactionSynchronizationManager.initSynchronization();
{
// 初始化所有的同步器,synchronizations保存了TransactionSynchronization,它是定义了在事务提交、回滚等操作时要执行的回调方法
// 这就是为什么没有真实的开启jdbc事务,但是还是要进行同步的原因,因为注册了事务同步的回调,需要在不同的场景回调目标方法
synchronizations.set(new LinkedHashSet<>());
}
}
}
return status;
}
}
}
}
return prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);{
// 封装成事务信息
TransactionInfo txInfo = new TransactionInfo(tm, txAttr, joinpointIdentification);
// 设置事务状态
txInfo.newTransactionStatus(status);
// 将事务信息绑定到当前线程
txInfo.bindToThread();
}
}
}
}
扫一扫
07-25
453
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
