TransactionSynchronizationManager和TransactionAspectSupport的作用

/**
 * TransactionSynchronizationManager类主要用来管理和执行TransactionSynchronization回调
 * 确保在JDBC事务的不同阶段执行相应的回调操作,除了执行TransactionSynchronization回调外
 * TransactionSynchronizationManager还有以下几个主要作用：
 * <p>
 * 管理事务状态：TransactionSynchronizationManager可以帮助跟踪当前事务的状态，包括事务是否已经开启、是否处于激活状态等。
 * 它提供了静态方法来管理事务的状态，确保在多线程环境下的事务状态可以被正确管理。
 * <p>
 * 提供事务同步资源访问：TransactionSynchronizationManager允许开发者存储和访问在事务生命周期内需要共享的资源。
 * 通过TransactionSynchronizationManager，开发者可以在不同的事务阶段访问并操作共享资源，确保资源的一致性和可靠性。
 * <p>
 * 支持多种事务管理机制：TransactionSynchronizationManager不依赖于特定的事务管理机制，可以与不同的事务管理实现（如JDBC、Hibernate、JPA等）结合使用
 * 它提供了统一的接口和管理机制，使得不同的事务管理机制可以更容易地集成和使用。
 * <p>
 * 总的来说，TransactionSynchronizationManager在Spring框架中扮演着重要的角色，不仅用于执行TransactionSynchronization回调，还在事务管理和资源访问等方面提供了便利。通过TransactionSynchronizationManager，开发者可以更加灵活地处理事务相关操作，并确保事务的一致性和可靠性。希望这些信息能帮助你更好地理解TransactionSynchronizationManager的作用。如果有任何疑问，欢迎继续提问。
 */
public class TransactionSynchronizationManager {

    // 绑定到当前线程的事务相关的资源
    private static final ThreadLocal<Map<Object, Object>> resources = new NamedThreadLocal<>("Transactional resources");
    // 与事务同步的接口,里面定义了与同步的事件回调,例如提交之前回调,提交完成回调,事务暂停回调
    private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal<>("Transaction synchronizations");
    // 当前事务的名称
    private static final ThreadLocal<String> currentTransactionName = new NamedThreadLocal<>("Current transaction name");
    // 当前事务是否只读
    private static final ThreadLocal<Boolean> currentTransactionReadOnly = new NamedThreadLocal<>("Current transaction read-only status");
    // 当前事务的隔离级别
    private static final ThreadLocal<Integer> currentTransactionIsolationLevel = new NamedThreadLocal<>("Current transaction isolation level");
    // 当前是否存在实际的活跃事务,因为可能存在只需要同步,但是实际上不需要开启事务的场景
    private static final ThreadLocal<Boolean> actualTransactionActive = new NamedThreadLocal<>("Actual transaction active");

    // 获取绑定到当前线程的事务相关资源
    public static Map<Object, Object> getResourceMap() {
        Map<Object, Object> map = resources.get();
        return (map != null ? Collections.unmodifiableMap(map) : Collections.emptyMap());
    }

    // 判断资源是否存在
    public static boolean hasResource(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doGetResource(actualKey);
        return (value != null);
    }

    // 获取绑定的资源
    public static Object getResource(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doGetResource(actualKey);
        return value;
    }

    // 实际获取资源信息
    private static Object doGetResource(Object actualKey) {
        Map<Object, Object> map = resources.get();
        if (map == null) {
            return null;
        }
        Object value = map.get(actualKey);
        if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
            map.remove(actualKey);
            if (map.isEmpty()) {
                resources.remove();
            }
            value = null;
        }
        return value;
    }

    // 将给定Key和Value绑定到当前线程中
    public static void bindResource(Object key, Object value) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Map<Object, Object> map = resources.get();
        if (map == null) {
            map = new HashMap<>();
            resources.set(map);
        }
        Object oldValue = map.put(actualKey, value);
        if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
            oldValue = null;
        }
    }

    // 将当前线程绑定的资源解绑
    public static Object unbindResource(Object key) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Object value = doUnbindResource(actualKey);
        return value;
    }

    // 解绑资源如果需要的话
    public static Object unbindResourceIfPossible(Object key) {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        return doUnbindResource(actualKey);
    }

    // 解绑资源
    private static Object doUnbindResource(Object actualKey) {
        Map<Object, Object> map = resources.get();
        if (map == null) {
            return null;
        }
        Object value = map.remove(actualKey);
        if (map.isEmpty()) {
            resources.remove();
        }
        if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
            value = null;
        }
        return value;
    }


    // 判断当前事务同步回调是否初始化了,设置了值
    public static boolean isSynchronizationActive() {
        return (synchronizations.get() != null);
    }

    // 初始化事务同步回调
    public static void initSynchronization() throws IllegalStateException {
        // 如果不为空,表示已经同步过了,抛出异常
        if (isSynchronizationActive()) {
            throw new IllegalStateException("Cannot activate transaction synchronization - already active");
        }
        synchronizations.set(new LinkedHashSet<>());
    }

    // 注册事务同步回调
    public static void registerSynchronization(TransactionSynchronization synchronization) throws IllegalStateException {
        // 如果没有初始化,抛出异常,只有初始化了才能添加同步回调
        Set<TransactionSynchronization> synchs = synchronizations.get();
        if (synchs == null) {
            throw new IllegalStateException("Transaction synchronization is not active");
        }
        synchs.add(synchronization);
    }

    // 获取所有注册到当前线程的同步回调
    public static List<TransactionSynchronization> getSynchronizations() throws IllegalStateException {
        Set<TransactionSynchronization> synchs = synchronizations.get();
        if (synchs == null) {
            throw new IllegalStateException("Transaction synchronization is not active");
        }
        if (synchs.isEmpty()) {
            return Collections.emptyList();
        }
        // 排序所有的回调并返回
        List<TransactionSynchronization> sortedSynchs = new ArrayList<>(synchs);
        AnnotationAwareOrderComparator.sort(sortedSynchs);
        return Collections.unmodifiableList(sortedSynchs);
    }

    // 清空所有的同步回调接口
    public static void clearSynchronization() throws IllegalStateException {
        // 如果没有被初始胡,抛出异常
        if (!isSynchronizationActive()) {
            throw new IllegalStateException("Cannot deactivate transaction synchronization - not active");
        }
        // 清空回调接口
        synchronizations.remove();
    }

    // 设置当前线程名称
    public static void setCurrentTransactionName(@Nullable String name) {
        currentTransactionName.set(name);
    }

    // 获取当前线程名称
    public static String getCurrentTransactionName() {
        return currentTransactionName.get();
    }

    // 设置当前事务是否只读
    public static void setCurrentTransactionReadOnly(boolean readOnly) {
        currentTransactionReadOnly.set(readOnly ? Boolean.TRUE : null);
    }

    // 获取当前事务是否只读
    public static boolean isCurrentTransactionReadOnly() {
        return (currentTransactionReadOnly.get() != null);
    }

    // 设置当前事务的隔离级别
    public static void setCurrentTransactionIsolationLevel(@Nullable Integer isolationLevel) {
        currentTransactionIsolationLevel.set(isolationLevel);
    }

    // 获取当前事务的隔离级别
    public static Integer getCurrentTransactionIsolationLevel() {
        return currentTransactionIsolationLevel.get();
    }

    // 设置当前实际事务的活跃状态
    public static void setActualTransactionActive(boolean active) {
        actualTransactionActive.set(active ? Boolean.TRUE : null);
    }

    // 获取实际事务的活跃状态
    public static boolean isActualTransactionActive() {
        return (actualTransactionActive.get() != null);
    }

    // 清空所有的配置
    public static void clear() {
        synchronizations.remove();
        currentTransactionName.remove();
        currentTransactionReadOnly.remove();
        currentTransactionIsolationLevel.remove();
        actualTransactionActive.remove();
    }

}

// 如果需要获取当前事务的状态
public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
    // 保存了当前线程的事务信息
    private static final ThreadLocal<TransactionInfo> transactionInfoHolder = new NamedThreadLocal<>("Current aspect-driven transaction");
    // 获取当前线程的事务信息
    protected static TransactionInfo currentTransactionInfo() throws NoTransactionException {
        return transactionInfoHolder.get();
    }
    // 获取当前线程的事务状态
    public static TransactionStatus currentTransactionStatus() throws NoTransactionException {
        TransactionInfo info = currentTransactionInfo();
        if (info == null || info.transactionStatus == null) {
            throw new NoTransactionException("No transaction aspect-managed TransactionStatus in scope");
        }
        return info.transactionStatus;
    }
}