public interface PlatformTransactionManager {
    
    TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException
        
	void commit(TransactionStatus status) throws TransactionException;	       
    
    void rollback(TransactionStatus status) throws TransactionException
    
}

@Transactional
public void xx() {

}

public void yy() {

	xx();

}

@Service
public class UserServiceImpl extends GenericServiceImpl<User, Integer, UserMapper> implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public UserMapper getGenericMapper() {
        return userMapper;
    }
    
    // 根据Mybatis-generator生成的模板方法
    @Override
    @Transactional
    public User selectByPrimaryKey(Integer id) {
        return super.selectByPrimaryKey(id);
    }

}

@RequestMapping("/user")
@RestController
public class UserController {
    
    private final UserService userService;
    
    @Override
    public WebApiResponse<User> detail(Integer id) {
        
        
        User user = userService.selectByPrimaryKey(id);
     
    }
    
}

public interface PlatformTransactionManager {

	/**
		获取当前事务的状态
	*/
	TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;

	/**
		基于当前事务状态提交事务
	*/
	void commit(TransactionStatus status) throws TransactionException;
	
	/**
		基于当前事务状态回滚事务
	*/
	void rollback(TransactionStatus status) throws TransactionException;
}

DataSourceTransactionManager [http-nio-9314-exec-3] :370 Creating new transaction with name [xxxMethod]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT

DataSourceTransactionManager [http-nio-9314-exec-3] :265 Acquired Connection [com.mysql.cj.jdbc.ConnectionImpl@57abfce5] for JDBC transaction

DataSourceTransactionManager [http-nio-9314-exec-3] :283 Switching JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@57abfce5] to manual commit

// mapper sql

DataSourceTransactionManager [http-nio-9314-exec-3] :741 Initiating transaction commit

// 底层JDBC事务提交
DataSourceTransactionManager [http-nio-9314-exec-3] :328 Committing JDBC transaction on Connection [com.mysql.cj.jdbc.ConnectionImpl@57abfce5]

// 释放JDBC连接，归还给连接池
DataSourceTransactionManager [http-nio-9314-exec-3] :387 Releasing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@57abfce5] after transaction

[2022-01-22T20:22:57] TRACE o.s.t.s.TransactionSynchronizationManager [http-nio-8083-exec-2] :196 Bound value [org.springframework.jdbc.datasource.ConnectionHolder@7650106] for key [{
	CreateTime:"2022-01-22 20:22:13",
	ActiveCount:1,
	PoolingCount:0,
	CreateCount:1,
	DestroyCount:0,
	CloseCount:3,
	ConnectCount:4,
	Connections:[
	]
}] to thread [http-nio-8083-exec-2]

@Override
@Transactional(timeout = 3)
public User selectByPrimaryKey(Integer id) {
	try {
		TimeUnit.SECONDS.sleep(5);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	return super.selectByPrimaryKey(id);
}

@Override
@Transactional(timeout = 3)
public User selectByPrimaryKey(Integer id) {
	// selectByPrimaryKey --> mapper中配置的 select sleep(5);
    return super.selectByPrimaryKey(id);
}

// com.mysql.jdbc.StatementImpl

public class StatementImpl implements Statement {

	 /**
     * Thread used to implement query timeouts...Eventually we could be more
     * efficient and have one thread with timers, but this is a straightforward
     * and simple way to implement a feature that isn't used all that often.
     */
    class CancelTask extends TimerTask {

    }
    
    private boolean executeInternal(String sql, boolean returnGeneratedKeys) throws SQLException {
        
        if (locallyScopedConn.getEnableQueryTimeouts() && this.timeoutInMillis != 0 && locallyScopedConn.versionMeetsMinimum(5, 0, 0)) {
            timeoutTask = new CancelTask(this);
            locallyScopedConn.getCancelTimer().schedule(timeoutTask, this.timeoutInMillis);
        }
        
    }
}

@Override
public int insert(User model) {
    int affected = super.insert(model);

    // ! 在当前事务中 注册同步处理器, 事务提交之后，向消息队列发送消息
    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {

        @Override
        public void afterCommit() {
            TransactionSynchronization.super.afterCommit();
            // kafkaProducer.send
        }

    });

    return affected;
}

public abstract class TransactionSynchronizationManager {
 
    /**
     * ! 因为事务和 线程绑定， 所以同步操作正好可以利用ThreadLocal
     * ! 一个事务 可以注册多个 同步逻辑
     */
	private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations = new NamedThreadLocal<>("Transaction synchronizations");

    public static void registerSynchronization(TransactionSynchronization synchronization) {
		synchronizations.get().add(synchronization);          
    }

}

// AbstractPlatformTransactionManager
private void processCommit(DefaultTransactionStatus status) throws TransactionException {
 
    // ! 事务管理器在提交之后, 暴露的回调，其中事务同步机制就是在该逻辑中出来的
	// Trigger afterCommit callbacks, with an exception thrown there
	// propagated to callers but the transaction still considered as committed.
    try {
    	triggerAfterCommit(status);
    }

}

// AbstractPlatformTransactionManager
/**
 * Clean up after completion, clearing synchronization if necessary,
 * 
 * and invoking doCleanupAfterCompletion.
 * 
 * @param status object representing the transaction
 * @see #doCleanupAfterCompletion
 */
private void cleanupAfterCompletion(DefaultTransactionStatus status) {

    if (status.isNewSynchronization()) {
        TransactionSynchronizationManager.clear();
    }

}

// TransactionSynchronizationManager

/**
 * ! 清除当前线程的 相关的事务同步结构
 * Clear the entire transaction synchronization state for the current thread:
 * registered synchronizations as well as the various transaction characteristics.
 *
 */
public static void clear() {
    synchronizations.remove();
    ...
}

// @Service
@Transactional
public class UserService {

	public void insert() {}

}

class AnnotationTransactionAttributeSource {
    
    public AnnotationTransactionAttributeSource() {
		this(true);
	}

    /**
       Create a custom AnnotationTransactionAttributeSource, supporting
	   public methods that carry the {@code Transactional} annotation
	   or the EJB3 {@link javax.ejb.TransactionAttribute} annotation.
	 */
    public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {

    }
         
}

// @Service
@Transactional
public class UserService {

	public void insert() {}

}

@Transactional(rollbackFor = {Exception.class})
public void insert(User user) {
	try {
	
	} catch (Exception ex) {
	
	}
}

@Transactional(rollbackFor = {BusinessException.class})
public void insert(User user) {
	
	// 实际抛出 -- SQLException
	// throw new SQLException
	
}