spring事务

spring事物传播机制

类型	描述
REQUIRED	支持当前事务，如果当前没有事务，就新建一个事物。这是最常见，默认的选择。
SUPPORTS	支持当前事务，如果当前没有事务，就以非事物方式执行。
MANDATORY	支持当前事务，如果当前没有事务，就跑出异常。
REQUIRES_NEW	新建事务，如果当前存在事务，就把当前事务挂起，开始新建事务。
NOT_SUPPORTED	以非事务方式执行， 如果当前存在事务，就把当前事务挂起。
NEVER	以非事务方式运行，如果当前存在事务，就跑出异常。
NESTED	如果当前存在事务，就嵌套在事务类执行，如果没有事务，就执行与REQUIRED类似的操作。

上面的描述都很清晰，除了NESTED，经过自己写代码测试，个人理解，NESTED在当前存在事务的时候，会在当前事务里面新建一个子事务，子事务回滚，父事务不一定会回滚（catch 了相应异常）；但是父事务回滚，NESTED新建的子事务也会回滚。

⚠️

spring 事务是通过动态代理（切面）来实现的。所以在对象间调用方法时，Spring会将动态代理增强后的对象-代理类 注入到调用方，调用的方法是spring动态代理增强的具有事务管理功能的对象的方法，而在对象内部调用，spring 事务不会生效，因为调用的是没有被aop增强的原对象方法。

spring事务隔离级别

隔离级别	含义
DEFAULT	使用数据库默认的隔离级别
READ_UNCOMMITTED	允许读取尚未提交的更改。可能导致脏读、幻影读或不可重复读。
READ_COMMITTED	允许从已经提交的并发事务读取。可防止脏读，但幻影读和不可重复读仍可能会发生。
REPEATABLE_READ	可重复读，在事务里，每次读取数据的结果都一样，不管其他事务的结果有没有提交。可能会造成幻读。MySQL默认的隔离级别
SERIALIZABLE	串行化，一个事务提交前，其他事物将被挂起。就是说，在同一时间只有一个事务操作表。

分布式事务

分布式事务是指操作多个数据库之间的事务，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事务支持。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>distributed-transcation</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>distributed-transcation</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>1.2.4</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

数据库及事务配置

@EnableTransactionManagement(proxyTargetClass = true)
@Configuration
@Slf4j
@MapperScan(basePackages = "com.example.distributedtranscation.db2mapper",sqlSessionFactoryRef = "SqlSessionFactory2")
public class DataSourceAndSqlSessionConfig {
    @Bean("db1")
    public DataSource dataSourceOne(DatabaseProperties.DatabaseOneProperties databaseOneProperties) throws Exception {
        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();

        MysqlXADataSource mysqlXADataSource = new MysqlXADataSource();
        mysqlXADataSource.setUrl(databaseOneProperties.getUrl());
        mysqlXADataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXADataSource.setUser(databaseOneProperties.getUsername());
        mysqlXADataSource.setPassword(databaseOneProperties.getPassword());

        atomikosDataSourceBean.setXaDataSource(mysqlXADataSource);
        atomikosDataSourceBean.setUniqueResourceName("one");
        atomikosDataSourceBean.setMinPoolSize(databaseOneProperties.getMinPoolSize());
        atomikosDataSourceBean.setMaxPoolSize(databaseOneProperties.getMaxPoolSize());
        atomikosDataSourceBean.setBorrowConnectionTimeout(databaseOneProperties.getBorrowConnectionTimeout());
        atomikosDataSourceBean.setLoginTimeout(databaseOneProperties.getLoginTimeout());
        atomikosDataSourceBean.setMaintenanceInterval(databaseOneProperties.getMaintenanceInterval());
        atomikosDataSourceBean.setMaxIdleTime(databaseOneProperties.getMaxIdleTime());
        atomikosDataSourceBean.setTestQuery(databaseOneProperties.getTestQuery());

        return atomikosDataSourceBean;
    }
    @Bean(name = "db2")
    public DataSource dataSourceTwo(DatabaseProperties.DatabaseTwoProperties databaseTwoProperties) throws Exception {
        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean();

        MysqlXADataSource mysqlXADataSource = new MysqlXADataSource();
        mysqlXADataSource.setUrl(databaseTwoProperties.getUrl());
        mysqlXADataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXADataSource.setUser(databaseTwoProperties.getUsername());
        mysqlXADataSource.setPassword(databaseTwoProperties.getPassword());

        atomikosDataSourceBean.setXaDataSource(mysqlXADataSource);
        atomikosDataSourceBean.setUniqueResourceName("two");
        atomikosDataSourceBean.setMinPoolSize(databaseTwoProperties.getMinPoolSize());
        atomikosDataSourceBean.setMaxPoolSize(databaseTwoProperties.getMaxPoolSize());
        atomikosDataSourceBean.setBorrowConnectionTimeout(databaseTwoProperties.getBorrowConnectionTimeout());
        atomikosDataSourceBean.setLoginTimeout(databaseTwoProperties.getLoginTimeout());
        atomikosDataSourceBean.setMaintenanceInterval(databaseTwoProperties.getMaintenanceInterval());
        atomikosDataSourceBean.setMaxIdleTime(databaseTwoProperties.getMaxIdleTime());
        atomikosDataSourceBean.setTestQuery(databaseTwoProperties.getTestQuery());
        return atomikosDataSourceBean;

    }


    @Bean("db1Manager")
    public DataSourceTransactionManager db1Manager(@Qualifier("db1") DataSource db) {
        return new DataSourceTransactionManager(db);
    }

    @Bean("db2Manager")
    public DataSourceTransactionManager db2Manager(@Qualifier("db2") DataSource db) {
        return new DataSourceTransactionManager(db);
    }


    @Bean("userTransaction")
    public UserTransaction userTransaction() throws Exception {
        UserTransactionImp userTransactionImp = new UserTransactionImp();
        userTransactionImp.setTransactionTimeout(1000);
        return userTransactionImp;
    }

    @Bean(value = "userTransactionManager", initMethod = "init", destroyMethod = "close")
    public UserTransactionManager userTransactionManager() throws Exception {
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        userTransactionManager.setForceShutdown(false);
        return userTransactionManager;
    }

    @Bean("jtaManager")
    public JtaTransactionManager jtaTransactionManager(@Autowired UserTransactionManager userTransactionManager,
                                                       @Autowired UserTransaction userTransaction) {
        return new JtaTransactionManager(userTransaction, userTransactionManager);
    }

    @Bean("SqlSessionFactory1")
    public SqlSessionFactory db1Sql(@Qualifier("db1") DataSource db) throws Exception {
        return createSqlSession(db, "classpath:/db1xml/*.xml");
    }

    @Bean("SqlSessionFactory2")
    public SqlSessionFactory db2Sql(@Qualifier("db2") DataSource db) throws Exception {
        return createSqlSession(db, "classpath:/db2xml/*.xml");

    }

    @Bean
    public SqlSessionTemplate createSqlTemplate1(@Qualifier("SqlSessionFactory1") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    public SqlSessionTemplate createSqlTemplate2(@Qualifier("SqlSessionFactory2") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    private static SqlSessionFactory createSqlSession(DataSource db, String path) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(db);
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        configuration.setMapUnderscoreToCamelCase(true);
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        factoryBean.setMapperLocations(resolver.getResources(path));
        factoryBean.setConfiguration(configuration);
        return factoryBean.getObject();
    }
}

demo