spring.datasource.type=com.alibaba.druid.pool.DruidDataSource  
spring.datasource.driverClassName=com.mysql.jdbc.Driver  
# 主數(shù)據(jù)源  
spring.datasource.druid.master.url=jdbcUrl  
spring.datasource.druid.master.username=***  
spring.datasource.druid.master.password=***  
# 其他數(shù)據(jù)源  
spring.datasource.druid.second.url=jdbcUrl  
spring.datasource.druid.second.username=***  
spring.datasource.druid.second.password=***  

@Configuration  
public class DynamicDataSourceConfig {  
    @Bean  
    @ConfigurationProperties("spring.datasource.druid.master")  
    public DataSource firstDataSource(){  
        return DruidDataSourceBuilder.create().build();  
    }  
   
    @Bean  
    @ConfigurationProperties("spring.datasource.druid.second")  
    public DataSource secondDataSource(){  
        return DruidDataSourceBuilder.create().build();  
    }  
   
    @Bean  
    @Primary  
    public DynamicDataSource dataSource(DataSource firstDataSource, DataSource secondDataSource) {  
        Map<Object, Object> targetDataSources = new HashMap<>(5);  
        targetDataSources.put(DataSourceNames.FIRST, firstDataSource);  
        targetDataSources.put(DataSourceNames.SECOND, secondDataSource);  
        return new DynamicDataSource(firstDataSource, targetDataSources);  
    }  
}  

@Documented  
@Retention(RetentionPolicy.RUNTIME)  
@Target({ElementType.METHOD})  
public @interface SwitchDataSource {  
    String value();  
}  

public interface DataSourceManager {  
    void put(String var1, DataSource var2);  
   
    DataSource get(String var1);  
   
    Boolean hasDataSource(String var1);  
   
    void remove(String var1);  
   
    void closeDataSource(String var1);  
   
    Collection<DataSource> all();  
}  

public DataSource determineTargetDataSource() {  
        String lookupKey = DataSourceContextHolder.getKey();  
        DataSource dataSource = Optional.ofNullable(lookupKey)  
                .map(dataSources::get)  
                .orElse(defaultDataSource);  
        if (dataSource == null) {  
            throw new IllegalStateException("Cannot determine DataSource for lookup key [" + lookupKey + "]");  
        }  
        return dataSource;  
    }  

@SwitchDataSource      
@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)  

@Target({ElementType.METHOD})  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
public @interface MultiTransaction {  
    String transactionManager() default "multiTransactionManager";  
    // 默認數(shù)據(jù)隔離級別，隨數(shù)據(jù)庫本身默認值  
    IsolationLevel isolationLevel() default IsolationLevel.DEFAULT;  
    // 默認為主庫數(shù)據(jù)源  
    String datasourceId() default "default";  
    // 只讀事務，若有更新操作會拋出異常  
    boolean readOnly() default false;  

public class ConnectionProxy implements Connection {  
   
    private final Connection connection;  
   
    public ConnectionProxy(Connection connection) {  
        this.connection = connection;  
    }  
   
    @Override  
    public void commit() throws SQLException {  
        // connection.commit();  
    }  
   
    public void realCommit() throws SQLException {  
        connection.commit();  
    }  
   
    @Override  
    public void close() throws SQLException {  
        //connection.close();  
    }  
   
    public void realClose() throws SQLException {  
        if (!connection.getAutoCommit()) {  
            connection.setAutoCommit(true);  
        }  
        connection.close();  
    }  
   
    @Override  
    public void rollback() throws SQLException {  
        if(!connection.isClosed())  
            connection.rollback();  
    }  
    ...  
}  

public class TransactionHolder {  
    // 是否開啟了一個MultiTransaction  
    private boolean isOpen;  
    // 是否只讀事務  
    private boolean readOnly;  
    // 事務隔離級別  
    private IsolationLevel isolationLevel;  
    // 維護當前線程事務ID和連接關(guān)系  
    private ConcurrentHashMap<String, ConnectionProxy> connectionMap;  
    // 事務執(zhí)行棧  
    private Stack<String> executeStack;  
    // 數(shù)據(jù)源切換棧  
    private Stack<String> datasourceKeyStack;  
    // 主事務ID  
    private String mainTransactionId;  
    // 執(zhí)行次數(shù)  
    private AtomicInteger transCount;  
   
    // 事務和數(shù)據(jù)源key關(guān)系  
    private ConcurrentHashMap<String, String> executeIdDatasourceKeyMap;  
   
} 

@Override  
public Connection getConnection() throws SQLException {  
    TransactionHolder transactionHolder = MultiTransactionManager.TRANSACTION_HOLDER_THREAD_LOCAL.get();  
    if (Objects.isNull(transactionHolder)) {  
        return determineTargetDataSource().getConnection();  
    }  
    ConnectionProxy ConnectionProxy = transactionHolder.getConnectionMap()  
            .get(transactionHolder.getExecuteStack().peek());  
    if (ConnectionProxy == null) {  
        // 沒開跨庫事務，直接返回  
        return determineTargetDataSource().getConnection();  
    } else {  
        transactionHolder.addCount();  
        // 開了跨庫事務，從當前線程中拿包裝過的Connection  
        return ConnectionProxy;  
    }  
}  

package com.github.mtxn.transaction.aop;  
@Aspect  
@Component  
@Slf4j  
@Order(99999)  
public class MultiTransactionAop {  
   
    @Pointcut("@annotation(com.github.mtxn.transaction.annotation.MultiTransaction)")  
    public void pointcut() {  
        if (log.isDebugEnabled()) {  
            log.debug("start in transaction pointcut...");  
        }  
    }  
   
   
    @Around("pointcut()")  
    public Object aroundTransaction(ProceedingJoinPoint point) throws Throwable {  
        MethodSignature signature = (MethodSignature) point.getSignature();  
        // 從切面中獲取當前方法  
        Method method = signature.getMethod();  
        MultiTransaction multiTransaction = method.getAnnotation(MultiTransaction.class);  
        if (multiTransaction == null) {  
            return point.proceed();  
        }  
        IsolationLevel isolationLevel = multiTransaction.isolationLevel();  
        boolean readOnly = multiTransaction.readOnly();  
        String prevKey = DataSourceContextHolder.getKey();  
        MultiTransactionManager multiTransactionManager = Application.resolve(multiTransaction.transactionManager());  
        // 切數(shù)據(jù)源，如果失敗使用默認庫  
        if (multiTransactionManager.switchDataSource(point, signature, multiTransaction)) return point.proceed();  
        // 開啟事務棧  
        TransactionHolder transactionHolder = multiTransactionManager.startTransaction(prevKey, isolationLevel, readOnly, multiTransactionManager);  
        Object proceed;  
   
        try {  
            proceed = point.proceed();  
            multiTransactionManager.commit();  
        } catch (Throwable ex) {  
            log.error("execute method:{}#{},err:", method.getDeclaringClass(), method.getName(), ex);  
            multiTransactionManager.rollback();  
            throw ExceptionUtils.api(ex, "系統(tǒng)異常：%s", ex.getMessage());  
        } finally {  
            // 當前事務結(jié)束出棧  
            String transId = multiTransactionManager.getTrans().getExecuteStack().pop();  
            transactionHolder.getDatasourceKeyStack().pop();  
            // 恢復上一層事務  
            DataSourceContextHolder.setKey(transactionHolder.getDatasourceKeyStack().peek());  
            // 最后回到主事務，關(guān)閉此次事務  
            multiTransactionManager.close(transId);  
        }  
        return proceed;  
   
    }  
   
   
}