<bean id = "xxx" class = "...DataSourceTransactionManager"/>

#transaction setting###############################################
spring.transaction.aop.aop-pointcut-expression=execution(* com...*ServiceImpl.*(..))
spring.transaction.aop.tx-method-timeout=3600
spring.transaction.aop.require-rule=insert*,update*,delete*,do*
spring.transaction.aop.read-only-rule=query*
spring.transaction.aop.indep-transaction-rule=indep*

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.Advisor;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
import org.springframework.transaction.interceptor.RollbackRuleAttribute;
import org.springframework.transaction.interceptor.RuleBasedTransactionAttribute;
import org.springframework.transaction.interceptor.TransactionAttribute;
import org.springframework.transaction.interceptor.TransactionInterceptor;

@Configuration
public class SpringBootDatasourceConfig {
    private Logger LOGGER = LoggerFactory.getLogger(SpringBootDatasourceConfig.class);
    @Value("${spring.transaction.aop.tx-method-timeout}")
    private int TX_METHOD_TIMEOUT = 60;
    @Value("${spring.transaction.aop.aop-pointcut-expression}")
    private String AOP_POINTCUT_EXPRESSION;
    @Value("#{'${spring.transaction.aop.require-rule}'.split(',')}")
    private List<String> requireRuleList;
    @Value("#{'${spring.transaction.aop.read-only-rule}'.split(',')}")
    private List<String> readOnlyRuleList;
    @Value("#{'${spring.transaction.aop.indep-transaction-rule}'.split(',')}")
    private List<String> indepTransactionRuleList;
    @Value("${mybatis.mapper-locations}")
    private String MYBATIS_MAPPER_LOCATIONS;
    @Value("${mybatis.config-location}")
    private String MYBATIS_CONFIG_LOCATION;
    @Value("${mybatis.jdbc.dialect.type}")
    private String MYBATIS_JDBC_DIALECT_TYPE;

    public SpringBootDatasourceConfig() {
    }

    @Primary
    @Bean({"db1DataSourceProperties"})
    @ConfigurationProperties(
        prefix = "spring.datasource.db1"
    )
    public DataSourceProperties dataSourceProperties() {
        DataSourceProperties dataSourceProperties = new DataSourceProperties();
        return dataSourceProperties;
    }

    @Primary
    @Bean({"db1DataSource"})
    @ConfigurationProperties(
        prefix = "spring.datasource.db1.tomcat"
    )
    public DataSource db1DataSource(@Qualifier("db1DataSourceProperties") DataSourceProperties dataSourceProperties) {
        DataSource dataSource = dataSourceProperties.initializeDataSourceBuilder().build();
        return dataSource;
    }

    @Primary
    @Bean(
        name = {"db1SqlSessionFactory"}
    )
    public SqlSessionFactory db1SqlSessionFactory(@Qualifier("db1DataSource") DataSource datasource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations((new PathMatchingResourcePatternResolver()).getResources(this.MYBATIS_MAPPER_LOCATIONS));
        bean.setConfigLocation((new PathMatchingResourcePatternResolver()).getResource(this.MYBATIS_CONFIG_LOCATION));
        PageInterceptor pageInterceptor = new PageInterceptor();
        Properties properties = new Properties();
        properties.setProperty("dialect", this.MYBATIS_JDBC_DIALECT_TYPE);
        pageInterceptor.setProperties(properties);
        Interceptor[] plugins = new Interceptor[]{pageInterceptor};
        bean.setPlugins(plugins);
        return bean.getObject();
    }

    @Bean({"sqlSessionTemplate"})
    public SqlSessionTemplate db1SqlsessionTemplate(@Qualifier("db1SqlSessionFactory") SqlSessionFactory sessionfactory) {
        SqlSessionTemplate sqlSessionTemplate = new SqlSessionTemplate(sessionfactory);
        if (sqlSessionTemplate != null) {
            Connection connection = null;

            try {
                connection = sqlSessionTemplate.getConnection();
            } catch (Exception var13) {
                this.LOGGER.error("SqlSessionTemplate初始化連接池失敗", var13);
            } finally {
                if (connection != null) {
                    try {
                        connection.close();
                    } catch (SQLException var12) {
                        this.LOGGER.error("關(guān)閉連接失敗", var12);
                    }
                }

            }
        }

        return sqlSessionTemplate;
    }

    @Bean({"txmanager"})
    public DataSourceTransactionManager txManager(@Qualifier("db1DataSource") DataSource dataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }

    @Bean({"txAdvice"})
    public TransactionInterceptor txAdvice(@Qualifier("txmanager") DataSourceTransactionManager dataSourceTransactionManager) {
        RuleBasedTransactionAttribute readOnlyRule = new RuleBasedTransactionAttribute();
        readOnlyRule.setReadOnly(true);
        readOnlyRule.setPropagationBehavior(4);
        RuleBasedTransactionAttribute requireRule = new RuleBasedTransactionAttribute();
        requireRule.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(RuntimeException.class)));
        requireRule.setPropagationBehavior(0);
        requireRule.setIsolationLevel(2);
        requireRule.setTimeout(this.TX_METHOD_TIMEOUT);
        RuleBasedTransactionAttribute indepTransactionRule = new RuleBasedTransactionAttribute();
        indepTransactionRule.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(RuntimeException.class)));
        indepTransactionRule.setPropagationBehavior(3);
        indepTransactionRule.setIsolationLevel(2);
        indepTransactionRule.setTimeout(this.TX_METHOD_TIMEOUT);
        Map<String, TransactionAttribute> txMap = new HashMap();

        int i;
        String indepTransacdtionAopRule;
        for(i = 0; i < this.requireRuleList.size(); ++i) {
            indepTransacdtionAopRule = (String)this.requireRuleList.get(i);
            txMap.put(indepTransacdtionAopRule.trim(), requireRule);
        }

        for(i = 0; i < this.readOnlyRuleList.size(); ++i) {
            indepTransacdtionAopRule = (String)this.readOnlyRuleList.get(i);
            txMap.put(indepTransacdtionAopRule.trim(), readOnlyRule);
        }

        for(i = 0; i < this.indepTransactionRuleList.size(); ++i) {
            indepTransacdtionAopRule = (String)this.indepTransactionRuleList.get(i);
            txMap.put(indepTransacdtionAopRule.trim(), indepTransactionRule);
        }

        NameMatchTransactionAttributeSource nameMatchTransactionAttributeSource = new NameMatchTransactionAttributeSource();
        nameMatchTransactionAttributeSource.setNameMap(txMap);
        TransactionInterceptor txAdvice = new TransactionInterceptor(dataSourceTransactionManager, nameMatchTransactionAttributeSource);
        return txAdvice;
    }

    @Bean
    public Advisor txAdviceAdvisor(@Qualifier("txAdvice") TransactionInterceptor transactionInterceptor) {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression(this.AOP_POINTCUT_EXPRESSION);
        return new DefaultPointcutAdvisor(pointcut, transactionInterceptor);
    }
}