devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

使用JTA解决多数据源事务问题_transaction 192.168.8.146.tm169672573297900013 has

作者：菜鸟追梦旅行 | 2024-04-01 01:57:22

赞

踩

transaction 192.168.8.146.tm169672573297900013 has timed out and will rollba

分享知识 传递快乐

 

在一些复杂的应用开发中，一个应用可能会涉及到连接多个数据源，所谓多数据源可以简单理解为至少连接两个及以上的数据库。在动手之前最好先了解对JTA有个了解，可参考：浅谈 JTA 事务

 

项目环境

  • springboot  2.3.1
  • mybatis plus
  • jta

项目依赖

pom.xml中关键依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <!--JTA组件核心依赖-->
  6. <dependency>
  7.     <groupId>org.springframework.boot</groupId>
  8.     <artifactId>spring-boot-starter-jta-atomikos</artifactId>
  9. </dependency>
  10.  
  11. <!-- mysql -->
  12. <dependency>
  13.     <groupId>mysql</groupId>
  14.     <artifactId>mysql-connector-java</artifactId>
  15.     <version>8.0.19</version>
  16. </dependency>
  17.  
  18. <!-- Druid 数据源 -->
  19. <dependency>
  20.     <groupId>com.alibaba</groupId>
  21.     <artifactId>druid-spring-boot-starter</artifactId>
  22.     <version>1.1.22</version>
  23. </dependency>
  24.  
  25. <!-- mybatis plus -->
  26. <dependency>
  27.     <groupId>com.baomidou</groupId>
  28.     <artifactId>mybatis-plus-boot-starter</artifactId>
  29.     <version>3.3.2</version>
  30. </dependency>

 

配置多数据源

application.yml 

  1. spring:
  2.   profiles:
  3.     active: local
  4.   application:
  5.     name: jta-center
  6.   datasource:
  7.     type: com.alibaba.druid.pool.DruidDataSource
  8.     test-query: SELECT 1
  9.     min-pool-size: 5
  10.     max-pool-size: 20
  11.     max-life-time: 0
  12.     dynamic:
  13.       datasource:
  14.         one:
  15.           driver-class-name: com.mysql.cj.jdbc.Driver # 3.2.0开始支持SPI可省略此配置
  16.           url: jdbc:mysql://127.0.0.1:3306/one?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true&serverTimezone=Asia/Shanghai
  17.           username: root
  18.           password: root
  19.         tow:
  20.           driver-class-name: com.mysql.cj.jdbc.Driver 
  21.           url: jdbc:mysql://127.0.0.1:3306/tow?characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&autoReconnect=true&serverTimezone=Asia/Shanghai
  22.           username: root
  23.           password: root

配置 DataSource

创建事务数据源

  1. package com.jta.demo.common.dynamic;
  2.  
  3. import com.baomidou.mybatisplus.core.MybatisConfiguration;
  4. import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean;
  5. import com.mysql.cj.jdbc.MysqlXADataSource;
  6. import org.apache.ibatis.session.SqlSessionFactory;
  7. import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
  8. import org.springframework.core.env.Environment;
  9.  
  10. import javax.sql.DataSource;
  11.  
  12. /**
  13.  * Title: 事务数据源
  14.  * Description:
  15.  *
  16.  */
  17. public class AtomikosDataSourceCreator {
  18.  
  19.     public static final String DATA_SOURCE_PREFIX = "spring.datasource.";
  20.  
  21.     /**
  22.      * 创建数据源
  23.      * <p>
  24.      * 创建AtomikosDataSourceBean是使用Atomikos连接池的首选类
  25.      *
  26.      * @param environment
  27.      * @param uniqueResourceName
  28.      * @param dataBase
  29.      * @return
  30.      */
  31.     public static AtomikosDataSourceBean createAtomikosDataSourceBean(Environment environment, String uniqueResourceName, String dataBase) {
  32.         // 设置数据库连
  33.         MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
  34.  
  35.         mysqlXaDataSource.setDatabaseName(environment.getProperty(dataBase + "name"));
  36.         mysqlXaDataSource.setURL(environment.getProperty(dataBase + "url"));
  37.         mysqlXaDataSource.setUser(environment.getProperty(dataBase + "username"));
  38.         mysqlXaDataSource.setPassword(environment.getProperty(dataBase + "password"));
  39.  
  40.         // 事务管理器
  41.         AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
  42.  
  43.         // 数据源唯一标识
  44.         xaDataSource.setUniqueResourceName(uniqueResourceName);
  45.         // XADataSource实现类，使用DruidXADataSource
  46.         xaDataSource.setXaDataSourceClassName(environment.getProperty(DATA_SOURCE_PREFIX + "type"));
  47.         // 最小连接数，默认1
  48.         xaDataSource.setMinPoolSize(environment.getProperty(DATA_SOURCE_PREFIX + "min-pool-size", Integer.class));
  49.         // 最大连接数，默认1
  50.         xaDataSource.setMaxPoolSize(environment.getProperty(DATA_SOURCE_PREFIX + "max-pool-size", Integer.class));
  51.         // 设置连接在池中被自动销毁之前保留的最大秒数。 可选，默认为0（无限制）。
  52.         xaDataSource.setMaxLifetime(environment.getProperty(DATA_SOURCE_PREFIX + "max-life-time", Integer.class));
  53.         // 返回连接前用于测试连接的SQL查询
  54.         xaDataSource.setTestQuery(environment.getProperty(DATA_SOURCE_PREFIX + "test-query"));
  55.         xaDataSource.setBorrowConnectionTimeout(60);
  56.         xaDataSource.setXaDataSource(mysqlXaDataSource);
  57.  
  58.         return xaDataSource;
  59.     }
  60.  
  61.  
  62.     /**
  63.      * 创建SqlSessionFactory实例
  64.      */
  65.     public static SqlSessionFactory createSqlSessionFactory(DataSource dataSource) throws Exception {
  66.         /**
  67.          * 必须使用MybatisSqlSessionFactoryBean，
  68.          * 不能使用SqlSessionFactoryBean，不然会报invalid bound statement (not found)
  69.          *
  70.          * com.baomidou.mybatisplus.autoconfigure.MybatisPlusAutoConfiguration#sqlSessionFactory(javax.sql.DataSource)
  71.          * 源码中也是使用MybatisSqlSessionFactoryBean
  72.          * 并且源码中使用了@ConditionalOnMissingBean，即IOC中如果存在了SqlSessionFactory实例，mybatis-plus就不创建SqlSessionFactory实例了
  73.          */
  74.         MybatisSqlSessionFactoryBean sessionFactoryBean = new MybatisSqlSessionFactoryBean();
  75.         sessionFactoryBean.setDataSource(dataSource);
  76.  
  77.         MybatisConfiguration configuration = new MybatisConfiguration();
  78.         sessionFactoryBean.setConfiguration(configuration);
  79.  
  80.         return sessionFactoryBean.getObject();
  81.     }
  82. }

创建 one 数据源

  1.  
  2. package com.jta.demo.common.dynamic.datasource;
  3.  
  4. import com.jta.demo.common.dynamic.AtomikosDataSourceCreator;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.apache.ibatis.session.SqlSessionFactory;
  7. import org.mybatis.spring.annotation.MapperScan;
  8. import org.springframework.beans.factory.annotation.Qualifier;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.context.annotation.Primary;
  12. import org.springframework.core.env.Environment;
  13.  
  14. import javax.sql.DataSource;
  15.  
  16.  
  17. @Slf4j
  18. @Configuration
  19. @MapperScan(basePackages = "com.jta.demo.mappers.one.mapper", sqlSessionFactoryRef = OneDataSourcesConfiguration.SQL_SESSION_FACTORY)
  20. public class OneDataSourcesConfiguration {
  21.  
  22.     public static final String DATABASE_PREFIX = "spring.datasource.dynamic.datasource.one.";
  23.  
  24.     public static final String DATA_SOURCE_NAME = "oneDataSource";
  25.     public static final String SQL_SESSION_FACTORY = "oneSqlSessionFactory";
  26.  
  27.  
  28.     /**
  29.      * 通过配置文件创建DataSource，一个数据库对应一个DataSource
  30.      *
  31.      * @param environment 环境变量，spring-boot会自动将IOC中的environment实例设置给本参数值
  32.      *                    由于IOC中有多个DataSource实例，必须给其中一个实例加上@Primary
  33.      */
  34.     @Primary
  35.     @Bean(DATA_SOURCE_NAME)
  36.     public DataSource dataSource(Environment environment) {
  37.         log.info("initialize the one database...");
  38.         return AtomikosDataSourceCreator.createAtomikosDataSourceBean(environment, DATA_SOURCE_NAME, DATABASE_PREFIX);
  39.     }
  40.  
  41.     /**
  42.      * 通过dataSource创建SqlSessionFactory
  43.      * 由于IOC中有多个DataSource实例，必须给其中一个实例加上@Primary
  44.      */
  45.     @Primary
  46.     @Bean(name = SQL_SESSION_FACTORY)
  47.     public SqlSessionFactory sqlSessionFactory(@Qualifier(DATA_SOURCE_NAME) DataSource dataSource) throws Exception {
  48.         return AtomikosDataSourceCreator.createSqlSessionFactory(dataSource);
  49.     }
  50.  
  51. }

 

创建 two 数据源

  1. package com.jta.demo.common.dynamic.datasource;
  2.  
  3. import com.jta.demo.common.dynamic.AtomikosDataSourceCreator;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.ibatis.session.SqlSessionFactory;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.springframework.beans.factory.annotation.Qualifier;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.core.env.Environment;
  11.  
  12. import javax.sql.DataSource;
  13.  
  14.  
  15. @Slf4j
  16. @Configuration
  17. @MapperScan(basePackages = "com.jta.demo.mappers.two.mapper", sqlSessionFactoryRef = TwoDataSourcesConfiguration.SQL_SESSION_FACTORY)
  18. public class TwoDataSourcesConfiguration {
  19.  
  20.     public static final String DATABASE_PREFIX = "spring.datasource.dynamic.datasource.two.";
  21.     public static final String DATA_SOURCE_NAME = "twoDataSource";
  22.     public static final String SQL_SESSION_FACTORY = "twoSqlSessionFactory";
  23.  
  24.     @Bean(DATA_SOURCE_NAME)
  25.     public DataSource dataSource(Environment environment) {
  26.         log.info("initialize the two database...");
  27.         return AtomikosDataSourceCreator.createAtomikosDataSourceBean(environment, DATA_SOURCE_NAME, DATABASE_PREFIX);
  28.     }
  29.  
  30.     @Bean(name = SQL_SESSION_FACTORY)
  31.     public SqlSessionFactory sqlSessionFactory(@Qualifier(DATA_SOURCE_NAME) DataSource dataSource) throws Exception {
  32.         return AtomikosDataSourceCreator.createSqlSessionFactory(dataSource);
  33.     }
  34. }

分布式事务配置

  1. package com.jta.demo.common.dynamic;
  2.  
  3. import com.atomikos.icatch.jta.UserTransactionImp;
  4. import com.atomikos.icatch.jta.UserTransactionManager;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.transaction.PlatformTransactionManager;
  9. import org.springframework.transaction.annotation.EnableTransactionManagement;
  10. import org.springframework.transaction.jta.JtaTransactionManager;
  11.  
  12. import javax.transaction.TransactionManager;
  13. import javax.transaction.UserTransaction;
  14.  
  15. /**
  16.  * Title: 分布式事务配置
  17.  * Description:
  18.  */
  19. @Configuration
  20. @EnableTransactionManagement
  21. public class TransactionManagerConfiguration {
  22.     /**
  23.      * 初始化JTA事务管理器
  24.      */
  25.     @Bean(name = "userTransaction")
  26.     // TODO 知识点，有兴趣可以了解以下 @SneakyThrows(Exception.class)
  27. //    @SneakyThrows(Exception.class)
  28.     public UserTransaction userTransaction() throws Throwable {
  29.         UserTransactionImp userTransactionImp = new UserTransactionImp();
  30.         userTransactionImp.setTransactionTimeout(10000);
  31.         return userTransactionImp;
  32.     }
  33.  
  34.     /**
  35.      * 初始化Atomikos事务管理器
  36.      */
  37.     @Bean(name = "atomikosTransactionManager")
  38.     public TransactionManager atomikosTransactionManager() throws Throwable {
  39.         UserTransactionManager userTransactionManager = new UserTransactionManager();
  40.         userTransactionManager.setForceShutdown(false);
  41.         userTransactionManager.setTransactionTimeout(999999999);
  42.         return userTransactionManager;
  43.     }
  44.  
  45.     /**
  46.      * 加载事务管理
  47.      */
  48.     @Bean(name = "transactionManager")
  49.     public PlatformTransactionManager transactionManager(@Qualifier("atomikosTransactionManager") TransactionManager atomikosTransactionManager, @Qualifier("userTransaction") UserTransaction userTransaction) throws Throwable {
  50.         return new JtaTransactionManager(userTransaction(), atomikosTransactionManager());
  51.     }
  52. }

到此多数据源事务已经配置完成，接下来需要完成业务代码即可。

 

注意

在使用JTA处理多数据源事务时，在执行业务逻辑时间较长时会出现事务超时的问题。

常见下异常如下：

  1. Transaction 127.0.0.1.tm151796505627700002 has timed out and will rollback.
  2. 或
  3. nested exception is javax.transaction.RollbackException: Prepare: NO vote

由于JTA事务默认超时时间是100000毫秒，超过这个时间，提交事务就会抛出异常。此时需要增加一个 jta.properties 配置文件。

修改事务默认超时时间。

  1. # SAMPLE PROPERTIES FILE FOR THE TRANSACTION SERVICE
  2. # THIS FILE ILLUSTRATES THE DIFFERENT SETTINGS FOR THE TRANSACTION MANAGER
  3. # UNCOMMENT THE ASSIGNMENTS TO OVERRIDE DEFAULT VALUES;
  4.  
  5. # Required: factory implementation class of the transaction core.
  6. # NOTE: there is no default for this, so it MUST be specified!
  7. #
  8. com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
  9. #com.atomikos.icatch.max_timeout=2000
  10.  
  11. # Set base name of file where messages are output
  12. # (also known as the 'console file').
  13. #
  14. # com.atomikos.icatch.console_file_name = tm.out
  15.  
  16. # Size limit (in bytes) for the console file;
  17. # negative means unlimited.
  18. #
  19. # com.atomikos.icatch.console_file_limit=-1
  20.  
  21. # For size-limited console files, this option
  22. # specifies a number of rotating files to
  23. # maintain.
  24. #
  25. # com.atomikos.icatch.console_file_count=1
  26.  
  27. # Set the number of log writes between checkpoints
  28. #
  29. # com.atomikos.icatch.checkpoint_interval=500
  30.  
  31. # Set output directory where console file and other files are to be put
  32. # make sure this directory exists!
  33. #
  34. # com.atomikos.icatch.output_dir = ./
  35.  
  36. # Set directory of log files; make sure this directory exists!
  37. #
  38. # com.atomikos.icatch.log_base_dir = ./
  39.  
  40. # Set base name of log file
  41. # this name will be  used as the first part of
  42. # the system-generated log file name
  43. #
  44. # com.atomikos.icatch.log_base_name = tmlog
  45.  
  46. # Set the max number of active local transactions
  47. # or -1 for unlimited.
  48. #
  49. # com.atomikos.icatch.max_actives = 50
  50.  
  51. # Set the default timeout (in milliseconds) for local transactions
  52. #
  53. # com.atomikos.icatch.default_jta_timeout = 10000
  54.  
  55. # Set the max timeout (in milliseconds) for local transactions
  56. #
  57. # com.atomikos.icatch.max_timeout = 300000
  58.  
  59. # The globally unique name of this transaction manager process
  60. # override this value with a globally unique name
  61. #
  62. # com.atomikos.icatch.tm_unique_name = tm
  63.  
  64. # Do we want to use parallel subtransactions? JTA's default
  65. # is NO for J2EE compatibility
  66. #
  67. #com.atomikos.icatch.serial_jta_transactions=false
  68.  
  69. # If you want to do explicit resource registration then
  70. # you need to set this value to false.
  71. #
  72. # com.atomikos.icatch.automatic_resource_registration=true
  73.  
  74. # Set this to WARN, INFO or DEBUG to control the granularity
  75. # of output to the console file.
  76. #
  77. # com.atomikos.icatch.console_log_level=WARN
  78.  
  79. # Do you want transaction logging to be enabled or not?
  80. # If set to false, then no logging overhead will be done
  81. # at the risk of losing data after restart or crash.
  82. #
  83. # com.atomikos.icatch.enable_logging=true
  84.  
  85. # Should two-phase commit be done in (multi-)threaded mode or not?
  86. # Set this to false if you want commits to be ordered according
  87. # to the order in which resources are added to the transaction.
  88. #
  89. # NOTE: threads are reused on JDK 1.5 or higher.
  90. # For JDK 1.4, thread reuse is enabled as soon as the
  91. # concurrent backport is in the classpath - see
  92. # http://mirrors.ibiblio.org/pub/mirrors/maven2/backport-util-concurrent/backport-util-concurrent/
  93. #
  94. # com.atomikos.icatch.threaded_2pc=false
  95.  
  96. # Should shutdown of the VM trigger shutdown of the transaction core too?
  97. #
  98. # com.atomikos.icatch.force_shutdown_on_vm_exit=false
  99.  
  100. # 以上是完整的配置
  101. #
  102. # 配置最大的事务活动个数，-1代表无限制
  103. com.atomikos.icatch.max_actives = -1
  104.  
  105. # 默认超时时间，单位：毫秒
  106. com.atomikos.icatch.default_jta_timeout = 3000000
  107.  
  108. # 默认最大超时时间，单位：毫秒
  109. com.atomikos.icatch.max_timeout = 600000

 

 

 

 

 

 

 

 

—————————
如有不足请留言指正
相互学习，共同进步

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/346918
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号