Spring+Mybatis+Atomikos多数据源事务一致性

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量392 收藏
点赞数
文章标签： java 数据库 python
原文链接：https://my.oschina.net/TonyTaotao/blog/2980521
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1、背景

由于应用多数据源的写操作，一定会涉及到数据的一致性问题，由于mybatis-plus 的局限性，采用spring+mybatis+atomikos+druid实现分布式事务一致性。

2、实现

pom.xml

<?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>

    <groupId>com.tonytaotao</groupId>
    <artifactId>dtsc-job</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>dtsc-job</name>

    <properties>

        <!-- 文件拷贝时的编码 -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

        <!-- 编译时的编码 -->
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>

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

        <maven-compiler-plugin.version>3.8.0</maven-compiler-plugin.version>
        <maven-resources-plugin.version>3.1.0</maven-resources-plugin.version>
        <maven-jar-plugin.version>3.1.0</maven-jar-plugin.version>

        <!-- quartz -->
        <quartz.version>2.3.0</quartz.version>

        <!-- spring -->
        <spring.version>5.1.2.RELEASE</spring.version>
        <aspectjweaver.version>1.9.2</aspectjweaver.version>

        <!-- distribute transaction -->
        <jta.version>1.1</jta.version>
        <transactions-jdbc.version>4.0.6</transactions-jdbc.version>


        <!-- datasource -->
        <spring-redis.version>2.1.2.RELEASE</spring-redis.version>
        <mysql.version>6.0.6</mysql.version>
        <druid.version>1.1.12</druid.version>
        <mybatis-plus.version>3.0.5</mybatis-plus.version>

        <!-- test -->
        <junit.version>4.12</junit.version>

        <!-- log4j2 -->
        <log4j2.version>2.11.1</log4j2.version>
        <slf4j.version>1.7.25</slf4j.version>
        <disruptor.version>3.4.2</disruptor.version>

        <!-- utils -->
        <lombok.version>1.18.4</lombok.version>
        <fastjson.version>1.2.51</fastjson.version>
        <joda-time.version>2.10.1</joda-time.version>
        <guava.version>27.0-jre</guava.version>
        <commons-lang3.version>3.8.1</commons-lang3.version>
        <velocity-engine-core.version>2.0</velocity-engine-core.version>

    </properties>

    <dependencies>

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>${quartz.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>jta</artifactId>
            <version>${jta.version}</version>
        </dependency>
        <dependency>
            <groupId>com.atomikos</groupId>
            <artifactId>transactions-jdbc</artifactId>
            <version>${transactions-jdbc.version}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>${spring-redis.version}</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>${log4j2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>${log4j2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>${log4j2.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
        <dependency>
            <groupId>com.lmax</groupId>
            <artifactId>disruptor</artifactId>
            <version>${disruptor.version}</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>${fastjson.version}</version>
        </dependency>
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>${joda-time.version}</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>${guava.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>${velocity-engine-core.version}</version>
        </dependency>

    </dependencies>

    <build>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>
                <directory>src/test/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${maven-compiler-plugin.version}</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <testSource>${java.version}</testSource>
                    <testTarget>${java.version}</testTarget>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>${maven-resources-plugin.version}</version>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>${maven-jar-plugin.version}</version>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy-dependencies</id>
                        <phase>test</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <outputDirectory>
                                target/classes/lib
                            </outputDirectory>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

2.1 JtaDatasourceConfig

package com.tonytaotao.dtsc.common.configuration.datasouce.jta; 

import com.alibaba.druid.pool.xa.DruidXADataSource; 
import com.atomikos.jdbc.AtomikosDataSourceBean; 
import com.tonytaotao.dtsc.common.configuration.datasouce.DBTypeEnum; 
import com.tonytaotao.dtsc.common.configuration.datasouce.DynamicDataSource; 
import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.Primary; 

import javax.sql.DataSource; 
import java.util.HashMap; 
import java.util.Map; 

@Configuration 
public class JtaDatasourceConfig { 

    @Bean("xaMultipleDataSource") 
    @Primary 
    public DynamicDataSource xaMultipleDataSource(@Qualifier("one") DataSource one, @Qualifier("two") DataSource two) { 
        DynamicDataSource dynamicDataSource = new DynamicDataSource(); 
        Map< Object, Object > targetDataSources = new HashMap<>(); 
        targetDataSources.put(DBTypeEnum.ONE.getCode(), one); 
        targetDataSources.put(DBTypeEnum.TWO.getCode(), two); 
        dynamicDataSource.setTargetDataSources(targetDataSources); 
        dynamicDataSource.setDefaultTargetDataSource(one); 
        return dynamicDataSource; 
    } 

    @Bean("one") 
    public DataSource createXADatasourOne() { 

        DruidXADataSource druidXADataSource = createDataSourceBase(); 
        druidXADataSource.setUrl("jdbc:mysql://localhost:3306/dtsc?useSSL=false&useUnicode=true&allowPublicKeyRetrieval=true&characterEncoding=UTF8&serverTimezone=GMT"); 
        druidXADataSource.setUsername("root"); 
        druidXADataSource.setPassword("123456"); 

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean(); 
        atomikosDataSourceBean.setXaDataSourceClassName("com.alibaba.druid.pool.xa.DruidXADataSource"); 
        atomikosDataSourceBean.setUniqueResourceName("one"); 
        atomikosDataSourceBean.setXaDataSource(druidXADataSource); 
        atomikosDataSourceBean.setMaintenanceInterval(30000); 
        atomikosDataSourceBean.setTestQuery("SELECT 1"); 

        return atomikosDataSourceBean; 
    } 

    @Bean("two") 
    public DataSource createXADatasourTwo() { 

        DruidXADataSource druidXADataSource = createDataSourceBase(); 
        druidXADataSource.setUrl("jdbc:mysql://localhost:3306/dtsc_1?useSSL=false&useUnicode=true&allowPublicKeyRetrieval=true&characterEncoding=UTF8&serverTimezone=GMT"); 
        druidXADataSource.setUsername("root"); 
        druidXADataSource.setPassword("123456"); 

        AtomikosDataSourceBean atomikosDataSourceBean = new AtomikosDataSourceBean(); 
        atomikosDataSourceBean.setXaDataSourceClassName("com.alibaba.druid.pool.xa.DruidXADataSource"); 
        atomikosDataSourceBean.setUniqueResourceName("two"); 
        atomikosDataSourceBean.setXaDataSource(druidXADataSource); 
        atomikosDataSourceBean.setMaintenanceInterval(30000); 
        atomikosDataSourceBean.setTestQuery("SELECT 1"); 

        return atomikosDataSourceBean; 
    } 


    private DruidXADataSource createDataSourceBase() { 

        DruidXADataSource druidDataSource = new DruidXADataSource(); 

        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver"); 
        druidDataSource.setInitialSize(50); 
        druidDataSource.setMaxActive(100); 
        druidDataSource.setMinIdle(5); 
        druidDataSource.setMaxWait(1000); 
        druidDataSource.setPoolPreparedStatements(false); 
        druidDataSource.setMaxPoolPreparedStatementPerConnectionSize(-1); 
        druidDataSource.setValidationQuery("SELECT 1"); 
        druidDataSource.setValidationQueryTimeout(1); 
        druidDataSource.setTestOnBorrow(false); 
        druidDataSource.setTestOnReturn(false); 
        druidDataSource.setTestWhileIdle(true); 
        druidDataSource.setTimeBetweenEvictionRunsMillis(60000); 
        druidDataSource.setMinEvictableIdleTimeMillis(30000); 

        return druidDataSource; 
    } 

}

2.2 JtaTransationConfig

package com.tonytaotao.dtsc.common.configuration.datasouce.jta; 

import com.atomikos.icatch.jta.UserTransactionImp; 
import com.atomikos.icatch.jta.UserTransactionManager; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.context.annotation.EnableAspectJAutoProxy; 
import org.springframework.transaction.annotation.EnableTransactionManagement; 
import org.springframework.transaction.jta.JtaTransactionManager; 

import javax.transaction.SystemException; 

/** 
* @author wujintao 
* 
* Configuration 类似于spring 配置文件，负责注册bean 
* ComponentScan 注解类查找规则定义 <context:component-scan/> 
* EnableAspectJAutoProxy 激活Aspect 自动代理 <aop:aspectj-autoproxy/> 
* proxy-target-class : 默认为false 表示使用JDK 动态代理。如果实现了至少一个接口，Spring 会优先选择使用JDK 动态代理，若果没有实现任何接口，则spring 会选择CGLIB 动态代理，强制使用CGLIB 动态代理，使用以下配置 
* exposeProxy : springAOP 只会拦截public 方法，不会拦截provided 和private 方法，并且不会拦截public 方法内部调用的其他方法，也就是说只会拦截代理对象的方法，即增强的是代理对象，而不是原对象, 设置就可以暴露出代理对象，拦截器会获取代理对象，并且将代理对象转换成原对象。从而对内部调用的方法进行增强 
* EnableTransactionManagement 启用注解式事务管理 <tx:annotation-driven /> 
*/ 
@Configuration 
@EnableTransactionManagement 
@EnableAspectJAutoProxy(exposeProxy = true) 
public class JtaTransationConfig { 

    @Bean("jtaTransactionManager") 
    public JtaTransactionManager jtaTransactionManager() { 

        UserTransactionManager userTransactionManager = new UserTransactionManager(); 
        userTransactionManager.setForceShutdown(true); 

        UserTransactionImp userTransactionImp = new UserTransactionImp(); 
        try { 
            userTransactionImp.setTransactionTimeout(90000); 
        } catch (SystemException e) { 
            e.printStackTrace(); 
        } 

        JtaTransactionManager jtaTransactionManager = new JtaTransactionManager(); 
        jtaTransactionManager.setTransactionManager(userTransactionManager); 
        jtaTransactionManager.setUserTransaction(userTransactionImp); 
        jtaTransactionManager.setAllowCustomIsolationLevels(true); 

        return jtaTransactionManager; 
    } 
}

2.3 MTAspect

package com.tonytaotao.dtsc.common.configuration.datasouce.jta; 

import com.tonytaotao.dtsc.common.utils.SpringContextUtil; 
import lombok.extern.slf4j.Slf4j; 
import org.aspectj.lang.ProceedingJoinPoint; 
import org.aspectj.lang.annotation.Around; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.reflect.MethodSignature; 
import org.springframework.stereotype.Component; 
import org.springframework.transaction.jta.JtaTransactionManager; 

import javax.transaction.UserTransaction; 
import java.lang.reflect.Method; 
import java.util.Arrays; 

@Component 
@Aspect 
@Slf4j 
public class MTAspect { 

    @Around(value = "@annotation(com.tonytaotao.dtsc.common.configuration.datasouce.jta.MultiTransactional)") 
    public Object transactional(ProceedingJoinPoint point) throws Exception { 
        String methodName = point.getSignature().getName(); 
        Class[] parameterTypes = ((MethodSignature)point.getSignature()).getMethod().getParameterTypes(); 
        UserTransaction userTransaction = null; 
        Object result = null; 
        MultiTransactional multiTransactional = null; 
        try { 
            Method method = point.getTarget().getClass().getMethod(methodName, parameterTypes); 

            if (method.isAnnotationPresent(MultiTransactional.class)) { 
                multiTransactional = method.getAnnotation(MultiTransactional.class); 
                JtaTransactionManager transactionManager = SpringContextUtil.getBean(JtaTransactionManager.class); 
                userTransaction = transactionManager.getUserTransaction(); 
                userTransaction.begin(); 
                log.warn(methodName + ", transaction begin"); 
                result = point.proceed(); 
                userTransaction.commit(); 
                log.warn(methodName + ", transaction commit"); 
            } 

        } catch (Throwable e) { 
            log.error(e.getMessage(), e); 

            if (userTransaction != null) { 
                Class<? extends Throwable>[] rollbackExcptions = multiTransactional.rollbackFor(); 
                Class<? extends Throwable>[] noRollbackExcptions = multiTransactional.noRollbackFor(); 
                boolean rollback = isPresent(e, rollbackExcptions); 
                boolean noRollback = isPresent(e, noRollbackExcptions); 

                if (rollback || !noRollback) { 
                    userTransaction.rollback(); 
                    log.warn(methodName + ", transaction rollback"); 
                } else { 
                    userTransaction.commit(); 
                    log.warn(methodName + ", transaction commit"); 
                } 
            } 
        } 

        return result; 
    } 

    private boolean isPresent(Throwable e, Class<? extends Throwable>[] excptions) { 
        return Arrays.stream(excptions) .filter(exception -> e.getClass().isAssignableFrom(exception) || e.getClass().equals(exception)).findAny().isPresent(); 
    } 
}
2.4 MultiTransactional
package com.tonytaotao.dtsc.common.configuration.datasouce.jta; 

import org.springframework.core.annotation.AliasFor; 

import java.lang.annotation.*; 

@Target({ElementType.METHOD}) 
@Retention(RetentionPolicy.RUNTIME) 
@Inherited 
@Documented 
public @interface MultiTransactional { 

    @AliasFor("transactionManager") 
    String value() default ""; 

    @AliasFor("value") 
    String transactionManager() default ""; 

    Class<? extends Throwable>[] rollbackFor() default {}; 

    Class<? extends Throwable>[] noRollbackFor() default {}; 

}

2.5 MybatisConfig

package com.tonytaotao.dtsc.common.configuration.datasouce.jta; 

import com.tonytaotao.dtsc.common.configuration.datasouce.CustomSqlSessionTemplate; 
import com.tonytaotao.dtsc.common.configuration.datasouce.DBTypeEnum; 
import org.apache.ibatis.session.SqlSessionFactory; 
import org.mybatis.spring.SqlSessionFactoryBean; 
import org.mybatis.spring.annotation.MapperScan; 
import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.context.annotation.Bean; 
import org.springframework.context.annotation.Configuration; 
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; 

import javax.sql.DataSource; 
import java.util.HashMap; 
import java.util.Map; 

@Configuration 
@MapperScan(basePackages = {"com.tonytaotao.dtsc.*.mapper"}, sqlSessionTemplateRef = "sqlSessionTemplate") 
public class MybatisConfig { 

    @Bean("sqlSessionTemplate") 
    public CustomSqlSessionTemplate sqlSessionTemplate(@Qualifier("xaSqlSessionFactoryOne") SqlSessionFactory xaSqlSessionFactoryOne, @Qualifier("xaSqlSessionFactoryTwo") SqlSessionFactory xaSqlSessionFactoryTwo) { 

        CustomSqlSessionTemplate customSqlSessionTemplate = new CustomSqlSessionTemplate(xaSqlSessionFactoryOne); 

        Map<Object, SqlSessionFactory> targetSqlSessionFactorys = new HashMap<>(); 
        targetSqlSessionFactorys.put(DBTypeEnum.ONE.getCode(), xaSqlSessionFactoryOne); 
        targetSqlSessionFactorys.put(DBTypeEnum.TWO.getCode(), xaSqlSessionFactoryTwo); 

        customSqlSessionTemplate.setTargetSqlSessionFactorys(targetSqlSessionFactorys); 

        return customSqlSessionTemplate; 
    } 

    @Bean("xaSqlSessionFactoryOne") 
    public SqlSessionFactory xaSqlSessionFactoryOne(@Qualifier("one") DataSource one) { 

        try { 
            return createSqlSessionFactory(one); 
        } catch (Exception e) { 
            e.printStackTrace(); 
            return null; 
        } 
    } 

    @Bean("xaSqlSessionFactoryTwo") 
    public SqlSessionFactory xaSqlSessionFactoryTwo(@Qualifier("two") DataSource two) { 

        try { 
            return createSqlSessionFactory(two); 
        } catch (Exception e) { 
            e.printStackTrace(); 
            return null; 
        } 
    } 

    private SqlSessionFactory createSqlSessionFactory(DataSource dataSource) throws Exception{ 

        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); 
        sqlSessionFactoryBean.setDataSource(dataSource); 
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:com/tonytaotao/dtsc/*/mapper/xml/*Mapper.xml")); 
        sqlSessionFactoryBean.setTypeAliasesPackage("com.tonytaotao.dtsc.*.entity"); 

        return sqlSessionFactoryBean.getObject(); 
    } 



}

2.6 CustomSqlSessionTemplate

package com.tonytaotao.dtsc.common.configuration.datasouce; 

import org.apache.ibatis.exceptions.PersistenceException; 
import org.apache.ibatis.executor.BatchResult; 
import org.apache.ibatis.reflection.ExceptionUtil; 
import org.apache.ibatis.session.*; 
import org.mybatis.spring.MyBatisExceptionTranslator; 
import org.mybatis.spring.SqlSessionTemplate; 
import org.mybatis.spring.SqlSessionUtils; 
import org.springframework.dao.support.PersistenceExceptionTranslator; 
import org.springframework.util.Assert; 

import java.lang.reflect.InvocationHandler; 
import java.lang.reflect.Method; 
import java.lang.reflect.Proxy; 
import java.sql.Connection; 
import java.util.List; 
import java.util.Map; 

public class CustomSqlSessionTemplate extends SqlSessionTemplate { 
    private final SqlSessionFactory sqlSessionFactory; 
    private final ExecutorType executorType; 
    private final SqlSession sqlSessionProxy; 
    private final PersistenceExceptionTranslator exceptionTranslator; 
    private Map<Object, SqlSessionFactory> targetSqlSessionFactorys; 
    private SqlSessionFactory defaultTargetSqlSessionFactory; 

    public void setTargetSqlSessionFactorys(Map<Object, SqlSessionFactory> targetSqlSessionFactorys) { 
        this.targetSqlSessionFactorys = targetSqlSessionFactorys; 
    } 

    public Map<Object, SqlSessionFactory> getTargetSqlSessionFactorys() { 
        return targetSqlSessionFactorys; 
    } 

    public void setDefaultTargetSqlSessionFactory(SqlSessionFactory defaultTargetSqlSessionFactory) { 
        this.defaultTargetSqlSessionFactory = defaultTargetSqlSessionFactory; 
    } 

    public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) { 
        this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType()); 
    } 

    public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) { 
        this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator( 
        sqlSessionFactory.getConfiguration().getEnvironment().getDataSource(), true)); 
    } 

    public CustomSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) { 
        super(sqlSessionFactory, executorType, exceptionTranslator); 
        this.sqlSessionFactory = sqlSessionFactory; 
        this.executorType = executorType; 
        this.exceptionTranslator = exceptionTranslator; 
        this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[] { SqlSession.class }, new SqlSessionInterceptor()); 
        this.defaultTargetSqlSessionFactory = sqlSessionFactory; 
    } 

    @Override 
    public SqlSessionFactory getSqlSessionFactory() { 
        SqlSessionFactory targetSqlSessionFactory = targetSqlSessionFactorys.get(DBContextHolder.getDbType()); 
        if (targetSqlSessionFactory != null) { 
            return targetSqlSessionFactory; 
        } else if (defaultTargetSqlSessionFactory != null) { 
            return defaultTargetSqlSessionFactory; 
        } else { 
            Assert.notNull(targetSqlSessionFactorys,  "Property 'targetSqlSessionFactorys' or 'defaultTargetSqlSessionFactory' are required"); 
            Assert.notNull(defaultTargetSqlSessionFactory, "Property 'defaultTargetSqlSessionFactory' or 'targetSqlSessionFactorys' are required"); 
        } 
        return this.sqlSessionFactory; 
    } 

    @Override 
    public Configuration getConfiguration() { 
        return this.getSqlSessionFactory().getConfiguration(); 
    } 

    public ExecutorType getExecutorType() { 
        return this.executorType; 
    } 

    public PersistenceExceptionTranslator getPersistenceExceptionTranslator() { 
        return this.exceptionTranslator; 
    } 

 
    public <T> T selectOne(String statement) { 
        return this.sqlSessionProxy.<T> selectOne(statement); 
    } 


    public <T> T selectOne(String statement, Object parameter) { 
        return this.sqlSessionProxy.<T> selectOne(statement, parameter); 
    } 

    public <K, V> Map<K, V> selectMap(String statement, String mapKey) { 
        return this.sqlSessionProxy.<K, V> selectMap(statement, mapKey); 
    } 


    public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) { 
        return this.sqlSessionProxy.<K, V> selectMap(statement, parameter, mapKey); 
    } 
 
    public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) { 
        return this.sqlSessionProxy.<K, V> selectMap(statement, parameter, mapKey, rowBounds); 
    } 


    public <E> List<E> selectList(String statement) { 
        return this.sqlSessionProxy.<E> selectList(statement); 
    } 


    public <E> List<E> selectList(String statement, Object parameter) { 
        return this.sqlSessionProxy.<E> selectList(statement, parameter); 
    } 


    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 
        return this.sqlSessionProxy.<E> selectList(statement, parameter, rowBounds); 
    } 


    public void select(String statement, ResultHandler handler) { 
        this.sqlSessionProxy.select(statement, handler); 
    } 

    public void select(String statement, Object parameter, ResultHandler handler) { 
        this.sqlSessionProxy.select(statement, parameter, handler); 
    } 


    public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) { 
        this.sqlSessionProxy.select(statement, parameter, rowBounds, handler); 
    } 


    public int insert(String statement) { 
        return this.sqlSessionProxy.insert(statement); 
    } 

 
    public int insert(String statement, Object parameter) { 
        return this.sqlSessionProxy.insert(statement, parameter); 
    } 
 
    public int update(String statement) { 
        return this.sqlSessionProxy.update(statement); 
    } 

 
    public int update(String statement, Object parameter) { 
        return this.sqlSessionProxy.update(statement, parameter); 
    } 

 
    public int delete(String statement) { 
        return this.sqlSessionProxy.delete(statement); 
    } 


    public int delete(String statement, Object parameter) { 
        return this.sqlSessionProxy.delete(statement, parameter); 
    } 


    public <T> T getMapper(Class<T> type) { 
        return getConfiguration().getMapper(type, this); 
    } 


    public void commit() { 
        throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession"); 
    } 


    public void commit(boolean force) { 
        throw new UnsupportedOperationException("Manual commit is not allowed over a Spring managed SqlSession"); 
    } 


    public void rollback() { 
        throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession"); 
    } 


    public void rollback(boolean force) { 
        throw new UnsupportedOperationException("Manual rollback is not allowed over a Spring managed SqlSession"); 
    } 


    public void close() { 
        throw new UnsupportedOperationException("Manual close is not allowed over a Spring managed SqlSession"); 
    } 

 
    public void clearCache() { 
        this.sqlSessionProxy.clearCache(); 
    } 


    public Connection getConnection() { 
        return this.sqlSessionProxy.getConnection(); 
    } 


    public List<BatchResult> flushStatements() { 
        return this.sqlSessionProxy.flushStatements(); 
    } 


    private class SqlSessionInterceptor implements InvocationHandler { 
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            final SqlSession sqlSession = SqlSessionUtils.getSqlSession(CustomSqlSessionTemplate.this.getSqlSessionFactory(), 
            CustomSqlSessionTemplate.this.executorType, CustomSqlSessionTemplate.this.exceptionTranslator); 
            try { 
                Object result = method.invoke(sqlSession, args); 
                if (!SqlSessionUtils.isSqlSessionTransactional(sqlSession, CustomSqlSessionTemplate.this.getSqlSessionFactory())) { 
                    sqlSession.commit(true); 
                } 
                return result; 
            } catch (Throwable t) { 
                Throwable unwrapped = ExceptionUtil.unwrapThrowable(t); 
                if (CustomSqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) { 
                    Throwable translated = CustomSqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped); 
                    if (translated != null) { 
                        unwrapped = translated; 
                    } 
                } 
                throw unwrapped; 
            } finally { 
                SqlSessionUtils.closeSqlSession(sqlSession, CustomSqlSessionTemplate.this.getSqlSessionFactory()); 
            } 
        } 
    } 
}

2.7  复制  https://my.oschina.net/TonyTaotao/blog/2980518  中的DBTypeEnum 、DBAnnotation 、DBAspect 、DBContextHolder 、DynamicDataSource 的配置。

2.8 jta.properties

com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory

2.9 SpringContextUtil

package com.tonytaotao.dtsc.common.utils;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.*;

@Component
public class SpringContextUtil implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextUtil.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static <T> T getBean(String name) throws BeansException {
        return (T)applicationContext.getBean(name);
    }

    public static <T> T getBean(String name, Class<?> requiredType) throws BeansException {
        return applicationContext.getBean(name, (Class<T>)requiredType);
    }

    public static <T> T getBean(Class<?> requiredType) throws BeansException {
        String[] names = applicationContext.getBeanNamesForType(requiredType);
        if (names == null || names.length == 0) {
            throw new IllegalArgumentException("没有找到Bean，类型：" + requiredType.getName());
        }
        return (T)applicationContext.getBean(names[0]);
    }

    public static <T> Collection<T> getBeans(String... names) throws BeansException {
        Collection<T> beans = new ArrayList<>();
        for (String name : names) {
            beans.add((T)applicationContext.getBean(name));
        }
        return beans;
    }

    public static <T> Map<Object, T> getBeans(Class<?> requiredType) throws BeansException {
        Map<Object, T> beans = new HashMap<>();
        String[] names = applicationContext.getBeanNamesForType(requiredType);
        for (String name : names) {
            beans.put(name, (T)applicationContext.getBean(name));
        }
        return beans;
    }

    public static <T> Map<Object, T> getBeans(Class<?> requiredType, Class<?>... excludeTypes) throws BeansException {
        Map<Object, T> beans = new HashMap<>();
        String[] names = applicationContext.getBeanNamesForType(requiredType);
        for (String name : names) {
            Class type = applicationContext.getType(name);
            if (excludeTypes != null) {
                boolean flag = Arrays.stream(excludeTypes)
                        .filter(excludeType -> excludeType.equals(type))
                        .findAny()
                        .isPresent();

                if (flag) {
                    continue;
                }
            }
            beans.put(name, (T)applicationContext.getBean(name));
        }
        return beans;
    }

    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }

    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.isSingleton(name);
    }

    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.getType(name);
    }

    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.getAliases(name);
    }
}

3、使用方法

在需要跨库写操作的方法上加上 @MultiTransactional 注解，即可保证分布式事务的一致性

11181648_Yj6i.png

转载于:https://my.oschina.net/TonyTaotao/blog/2980521

weixin_34248849
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring事务隔离级别、传播行为以及spring+mybatis+atomikos实现分布式事务管理
半山闲人的专栏
04-10 2万+
1.事务的定义：事务是指多个操作单元组成的合集，多个单元操作是整体不可分割的，要么都操作不成功，要么都成功。其必须遵循四个原则（ACID）。 2.事务隔离级别：spring有五大隔离级别，其在TransactionDefinition中定义 3.事务传播行为：七大传播行为
Spring Boot + Druid + Mybatis + Atomikos 配置多数据源 并支持分布式事务
01-23
总结，通过Spring Boot、Druid、Mybatis和Atomikos的组合，我们可以实现多数据源环境下的分布式事务，提高系统的可扩展性和事务一致性。这个示例项目（springboot-druid-mybatis-multi）应该包含了相关的配置文件和...
spring boot + druid + mybatis + atomikos 多数据源配置 并支持分布式事务
黑白影的博客
01-28 7996
文章目录一、综述1.1 项目说明1.2 项目结构二、配置多数据源并支持分布式事务2.1 导入基本依赖2.2 在yml中配置多数据源信息2.3 进行多数据源的配置1. 在启动类关闭springboot对数据源的自动化配置，由我们手动进行多数据源的配置2. 创建多数据源配置类`DataSourceFactory.java`, 手动配置多数据源3. 自定义sqlSessionTemplate的...
SpringBoot+Mybatis配置多数据源并且实现事务一致性
热门推荐
周先生丶的博客
10-28 1万+
最近博客写得少，不知道怎么说开场白了。呃，本文一共分三部分：SpringBoot+Mybatis环境搭建、两种方式配置多数据源、两种方式实现跨数据源事务，您可以直接跳到喜欢的部分，不过按顺序看完也不会花很多时间。。。 一、搭建SpringBoot+Mybatis框架环境 看标题就知道，这部分不是重点，所以简单说一下（如果你是小白那对不起了~）。 1、引入依赖 Mybatis整合包和jdbc...
Atomikos + MybatisPlus解决多数据源事务一致性问题
who_I_am__的博客
10-15 655
Atomikos + MybatisPlus解决多数据源事务一致性问题
SpringBoot+Mybatis+druid多数据源和分布式事务
goodyuedandan的博客
08-27 970
原 3分钟搞定SpringBoot+Mybatis+druid多数据源和分布式事务 ...
springboot2.6+Mybatis静态多数据源(集成JTA(Atomikos案例)实现分布式事务控制)
qq_34246965的博客
03-27 2755
多数据源系列 1、springboot2.6+Mybatis静态多数据源(集成JTA(Atomikos案例)实现分布式事务控制) 2、springboot2.6+Mybatis动态多数据源AOP切换 3、springboot2.6+Mybatis注解多数据源使用dynamic-datasource-spring-boot-starter为依赖 说明 随着应用用户数量的增加，相应的并发请求的数量也会跟着不断增加，慢慢地，单个数据库已经没有办法满足我们频繁的数据库操作请求了。 在某些场景下，我们可能会需要配置多
springmvc atomikos mysql数据源_Spring+Mybatis+SpringMVC+Atomikos多数据源共存+不同数据库事物一致性处理...
weixin_36165398的博客
01-18 66
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spri...
SpringBoot+Mybatis+atomikos实现动态切换数据源+分布式事务
weixin_42324471的博客
05-21 1657
SpringBoot+Mybatis+atomikos实现动态切换数据源+分布式事务 实现以上功能需要按照步骤一步步执行： 1、自定义数据切换的注解 2、继承Spring中AbstractRoutingDataSource，重写方法和构造函数 3、生成不同的数据库实例（bean） 4、利用AOP实现注解拦截，切换数据源 1、自定义数据切换的注解 ...
Spring+Mybatis+SpringMVC+Atomikos多数据源共存+不同数据库事物一致性处理
05-23 133
项目结构说明： 1.dao层的admin、website包中包含的Mapper.xml文件分别操作不同的数据库 2.举例：192.168.1.1下有个mysql数据库叫 odao_admin 　　　　192.168.1.2下有个sqlserver数据库叫 odao_mobile 　...
springboot+mybatis+druid+atomikos 多数据源，分布式事务，集成websocket，redis，swagger2
11-12
在Spring Boot中，Atomikos可以协调多个数据源的事务，确保在分布式环境下的数据一致性。 5. **WebSocket**：WebSocket是一种在单个TCP连接上进行全双工通信的协议，为实时通信提供了基础。在Spring Boot应用中，...
Spring+MyBatis+Atomikos实现JTA分布式事务
08-13
2. `applicationContext.xml`或对应的Java配置类：配置Spring的事务管理器和数据源，以及Atomikos相关的bean。 3. MyBatis的配置：定义SqlSessionFactory，并与Spring集成。 4. 示例代码：展示了如何在方法上使用`@...
springboot + mybatis + atomikos 多数据源分布式事物管理
05-18
总之，通过 Spring Boot、MyBatis 和 Atomikos 的结合，我们可以有效地管理分布式环境中的多数据源事务，确保系统的稳定性和数据的一致性。在实际开发中，理解并熟练掌握这些技术的整合和配置是至关重要的。
Spring+Mybatis+Atomikos实现JAVA初始化并控制多个数据源+分布式事务
07-27
总的来说，这个DEMO旨在帮助开发者理解如何在Java应用中实现多数据源和分布式事务，涉及到的核心技术包括Spring的多数据源支持、Mybatis的持久层操作以及Atomikos的事务协调。通过实践这个DEMO，开发者可以深入掌握...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 273
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1075
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 122
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 585
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
spring + mybatis 双数据源事务
09-06
这样，在执行相关操作时，Spring就会根据指定的数据源来管理事务，保证数据的一致性。 总结一下，Spring和MyBatis提供了完善的支持来实现双数据源事务。我们可以通过合理的配置和注解来实现多个数据源的管理，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值