Jdbc怎么实现分布式事务数据源动态切换

本篇内容介绍了“Jdbc怎么实现分布式事务数据源动态切换”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

一：依赖的jar包  Maven配置

<dependency>

1.             <groupId>com.atomikos</groupId>
   

2.             <artifactId>transactions</artifactId>
   

3.             <version>4.0.4</version>
   

4.         </dependency>
   

5.         <dependency>
   

6.             <groupId>com.atomikos</groupId>
   

7.             <artifactId>transactions-api</artifactId>
   

8.             <version>4.0.4</version>
   

9.         </dependency>
   

10.         <dependency>
    

11.             <groupId>com.atomikos</groupId>
    

12.             <artifactId>atomikos-util</artifactId>
    

13.             <version>4.0.4</version>
    

14.         </dependency>
    

15.         <dependency>
    

16.             <groupId>com.atomikos</groupId>
    

17.             <artifactId>transactions-jdbc-deprecated</artifactId>
    

18.             <version>3.8.0</version>
    

19.         </dependency>
    

20.         <dependency>
    

21.             <groupId>com.atomikos</groupId>
    

22.             <artifactId>transactions-jta</artifactId>
    

23.             <version>4.0.4</version>
    

24.         </dependency>
    

25.         <dependency>
    

26.             <groupId>com.atomikos</groupId>
    

27.             <artifactId>transactions-jdbc</artifactId>
    

28.             <version>4.0.4</version>
    

29.         </dependency>
    

31.         <dependency>
    

32.             <groupId>cglib</groupId>
    

33.             <artifactId>cglib-nodep</artifactId>
    

34.             <version>3.2.5</version>
    

35.         </dependency>
    

37.         <dependency>
    

38.             <groupId>javax.transaction</groupId>
    

39.             <artifactId>jta</artifactId>
    

40.             <version>1.1</version>
    

41.         </dependency>

二：配置

dataSource.properties

点击(此处)折叠或打开

1. workDesk.jdbc.driverclass=com.mysql.jdbc.Driver
   

2. workDesk.jdbc.url=jdbc:Mysql://10.243.3.18:3306/system?userUnicode=true&characterEncoding=UTF-8
   

3. workDesk.jdbc.username=root
   

4. workDesk.jdbc.passWord=$Fortune2015
   

5. workDesk.jdbc.poolsize.max=3
   

6. workDesk.jdbc.poolsize.min=3
   

7. workDesk.jdbc.poolsize.initial=2
   

8. workDesk.jdbc.idletime.max=25000
   

9. workDesk.jdbc.idleConnectionTestPeriod=18000
   

11. #-------workDesk jdbc--------
    

12. workDesk.read.jdbc.driverclass=com.mysql.jdbc.Driver
    

13. workDesk.read.jdbc.url=jdbc:mysql://112.74.53.213:3306/gmc?userUnicode=true&characterEncoding=UTF-8
    

14. workDesk.read.jdbc.username=root
    

15. workDesk.read.jdbc.password=Wanmide@123
    

16. workDesk.read.jdbc.poolsize.max=3
    

17. workDesk.read.jdbc.poolsize.min=3
    

18. workDesk.read.jdbc.poolsize.initial=2
    

19. workDesk.read.jdbc.idletime.max=25000
    

20. workDesk.read.jdbc.idleConnectionTestPeriod=18000
    

22. jdbc.xaDataSourceClassName=com.mysql.jdbc.jdbc2.optional.MysqlXADataSource

transactions.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;
   

5. # Required: factory implementation class of the transaction core.
   

6. # NOTE: there is no default for this, so it MUST be
   

7. #
   

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

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
    

16. # Size limit (in bytes) for the console file;
    

17. # negative means unlimited.
    

18. #
    

19. # com.atomikos.icatch.console_file_limit=-1
    

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
    

27. # Set the number of log writes between checkpoints
    

28. #
    

29. # com.atomikos.icatch.checkpoint_interval=500
    

31. # Set output directory where console file and other files are to be put
    

32. # make sure this directory
    

33. #
    

34. # com.atomikos.icatch.output_dir = ./
    

36. # Set directory of log files; make sure this directory
    

37. #
    

38.  com.atomikos.icatch.log_base_dir = ./
    

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
    

46. # Set the max number of active local transactions
    

47. # or -1 for unlimited.
    

48. #
    

49. # com.atomikos.icatch.max_actives = 50
    

51. # Set the default timeout (in milliseconds) for local transactions
    

52. #
    

53. # com.atomikos.icatch.default_jta_timeout = 10000
    

55. # Set the max timeout (in milliseconds) for local transactions
    

56. #
    

57. # com.atomikos.icatch.max_timeout = 300000
    

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
    

64. # Do we want to use parallel subtransactions? JTA

点击(此处)折叠或打开

1. 
   

2.     @Bean(name="dataSourceA",initMethod="init",destroyMethod="close")
   

3.     public AtomikosDataSourceBean dataSourceA()
   

4.     {
   

5.         AtomikosDataSourceBean dataSourceA=new AtomikosDataSourceBean();
   

6.         dataSourceA.setUniqueResourceName("dataSourceA");
   

7.         dataSourceA.setXaDataSourceClassName(xaDataSourceClassName);
   

8.         Properties xaProperties = new Properties();
   

9.         xaProperties.put("user", user);
   

10.         xaProperties.put("password", password);
    

11.         xaProperties.put("url", jdbcUrl);
    

12.         xaProperties.put("pinGlobalTxToPhysicalConnection", true);
    

13.         dataSourceA.setXaProperties(xaProperties);
    

14.         dataSourceA.setMaxPoolSize(maxPoolSize);
    

15.         dataSourceA.setMinPoolSize(minPoolSize);
    

16.         dataSourceA.setMaxIdleTime(maxIdleTime);
    

17.         dataSourceA.setTestQuery("SELECT 1");
    

18.         return dataSourceA;
    

19.     }
    

20.     
    

21.     
    

22.     
    

23.     @Bean(name="dataSourceB",initMethod="init",destroyMethod="close")
    

24.     public AtomikosDataSourceBean dataSourceB()
    

25.     {
    

26.         AtomikosDataSourceBean dataSourceA=new AtomikosDataSourceBean();
    

27.         dataSourceA.setUniqueResourceName("dataSourceB");
    

28.         dataSourceA.setXaDataSourceClassName(xaDataSourceClassName);
    

29.         Properties xaProperties = new Properties();
    

30.         xaProperties.put("user", readUser);
    

31.         xaProperties.put("password", readPassword);
    

32.         xaProperties.put("url", readJdbcUrl);
    

33.         xaProperties.put("pinGlobalTxToPhysicalConnection", true);
    

34.         dataSourceA.setXaProperties(xaProperties);
    

35.         dataSourceA.setMaxPoolSize(readMaxPoolSize);
    

36.         dataSourceA.setMinPoolSize(readMinPoolSize);
    

37.         dataSourceA.setMaxIdleTime(readMaxIdleTime);
    

38.         dataSourceA.setTestQuery("SELECT 1");
    

39.         return dataSourceA;
    

40.     }

点击(此处)折叠或打开

1. @Configuration
   

2. public class DynamicTransactionManagerElConfig {
   

4.     // @Autowired
   

5.     // @Qualifier("platfORMTomcat")
   

6.     // private DataSource platformTomcat;
   

7.     //
   

8.     // @Autowired
   

9.     // @Qualifier("platformReadTomcat")
   

10.     // private DataSource platformReadTomcat;
    

12.     @Autowired
    

13.     @Qualifier("dataSourceA")
    

14.     private DataSource dataSourceA;
    

16.     @Autowired
    

17.     @Qualifier("dataSourceB")
    

18.     private DataSource dataSourceB;
    

20.     @Bean(name = "dataSource")
    

21.     public DynamicDataSource dataSource() {
    

22.         DynamicDataSource dataSource = new DynamicDataSource();
    

23.         Map<Object, Object> targetDataSources = new HashMap<>();
    

24.         targetDataSources.put("master", dataSourceA);
    

25.         targetDataSources.put("slave", dataSourceB);
    

26.         dataSource.setTargetDataSources(targetDataSources);
    

27.         dataSource.setDefaultTargetDataSource(dataSourceA);
    

28.         return dataSource;
    

29.     }
    

31.     @Bean(name = "jdbcTemplate")
    

32.     public JdbcTemplate jdbcTemplate(DynamicDataSource dataSource) {
    

33.         JdbcTemplate jdbcTemplate = new JdbcTemplate();
    

34.         jdbcTemplate.setDataSource(dataSource);
    

35.         return jdbcTemplate;
    

36.     }
    

38.     @Bean(name = "jdbcReadTemplate")
    

39.     public JdbcTemplate jdbcReadTemplate(DynamicDataSource dataSource) {
    

40.         JdbcTemplate jdbcReadTemplate = new JdbcTemplate();
    

41.         jdbcReadTemplate.setDataSource(dataSource);
    

42.         return jdbcReadTemplate;
    

43.     }
    

45.     @Bean(name = "atomikosTransactionManager", initMethod = "init", destroyMethod = "close")
    

46.     public UserTransactionManager atomikosTransactionManager() {
    

47.         UserTransactionManager atomikosTransactionManager = new UserTransactionManager();
    

48.         atomikosTransactionManager.setForceShutdown(true);
    

49.         return atomikosTransactionManager;
    

50.     }
    

52.     @Bean(name = "atomikosUserTransaction")
    

53.     public UserTransactionImp atomikosUserTransaction() {
    

54.         UserTransactionImp atomikosUserTransaction = new UserTransactionImp();
    

55.         try {
    

56.             atomikosUserTransaction.setTransactionTimeout(300);
    

57.         }
    

58.         catch (SystemException e) {
    

59.             e.printStackTrace();
    

60.         }
    

61.         return atomikosUserTransaction;
    

62.     }
    

64.     // @Bean(name = "transactionManager")
    

65.     // public DataSourceTransactionManager transactionManager(DynamicDataSource
    

66.     // dataSource) {
    

67.     // DataSourceTransactionManager transactionManager = new
    

68.     // DataSourceTransactionManager();
    

69.     // transactionManager.setDataSource(dataSource);
    

70.     // return transactionManager;
    

71.     // }
    

73.     @Bean(name = "transactionManager")
    

74.     public JtaTransactionManager transactionManager(UserTransactionManager atomikosTransactionManager,
    

75.             UserTransactionImp atomikosUserTransaction) {
    

76.         JtaTransactionManager transactionManager = new JtaTransactionManager();
    

77.         transactionManager.setTransactionManager(atomikosTransactionManager);
    

78.         transactionManager.setUserTransaction(atomikosUserTransaction);
    

79.         transactionManager.setAllowCustomIsolationLevels(true);
    

80.         return transactionManager;
    

81.     }
    

83. }

三：aop 注解方式数据源动态切换

点击(此处)折叠或打开

1. @Retention(RetentionPolicy.RUNTIME)
   

2. @Target(ElementType.METHOD)
   

3. @Documented
   

4. public @interface DataSource {
   

5.     String value();
   

6. }

点击(此处)折叠或打开

1. public class DynamicDataSource extends AbstractRoutingDataSource {
   

3.     @Override
   

4.     protected Object determineCurrentLookupKey() {
   

5.         return DataSourceContextHolder.getDataSource();
   

6.     }
   

8. }

点击(此处)折叠或打开

1. public class DataSourceContextHolder {
   

3.     private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
   

5.     public static void setDataSource(String dataSource) {
   

6.         contextHolder.set(dataSource);
   

7.     }
   

9.     public static String getDataSource() {
   

10.         return contextHolder.get();
    

11.     }
    

13.     public static void removeDataSource() {
    

14.         contextHolder.remove();
    

15.     }
    

17. }

点击(此处)折叠或打开

1. @Aspect
   

2. @Order(1)
   

3. @Component
   

4. public class DataSourceAspect {
   

6.     @Pointcut("@annotation(com.gemdale.ghome.business.async.deal.center.demo.datasource.DataSource)")
   

7.     public void dataSourcePointCut() {
   

8.     };
   

10.     @Before("dataSourcePointCut()")
    

11.     public void before(JoinPoint joinPoint) {
    

13.         System.out.println("=============dataSourcePointCut:before=============");
    

14.         Object target = joinPoint.getTarget();
    

15.         String method = joinPoint.getSignature().getName();
    

17.         // Class[] classz = target.getClass().getInterfaces();
    

18.         Class<?> classz = target.getClass();
    

19.         Class<?>[] parameterTypes = ((MethodSignature) joinPoint.getSignature()).getMethod().getParameterTypes();
    

21.         try {
    

22.             // Method m = classz[0].getMethod(method, parameterTypes);
    

23.             Method m = classz.getMethod(method, parameterTypes);
    

24.             if (null != m && m.isAnnotationPresent(DataSource.class)) {
    

25.                 DataSource dataSource = m.getAnnotation(DataSource.class);
    

26.                 DataSourceContextHolder.setDataSource(dataSource.value());
    

28.                 System.out.println("=============dataSource:" + dataSource.value());
    

29.             }
    

30.         }
    

31.         catch (Exception e) {
    

32.             e.printStackTrace();
    

33.         }
    

34.     }
    

36. }

四：数据源动态切换实例

点击(此处)折叠或打开

1. @Repository("gmcSmsInfoDaoImpl")
   

2. public class GmcSmsInfoDaoImpl extends BaseDaoSupport implements GmcSmsInfoDAO{
   

4.     
   

5.     @Override
   

6.     @DataSource("master")
   

7.     public Integer addMaster(GmcSmsInfo smsInfo) throws FrameworkDAOException {
   

8.         return save(smsInfo);
   

9.     }
   

11.     
    

12.     @Override
    

13.     @DataSource("slave")
    

14.     public Integer addSlave(GmcSmsInfo smsInfo) throws FrameworkDAOException {
    

15.         return save(smsInfo);
    

16.     }
    

19. }

五：分布式事务下的数据源动态切换
情况一：事务下唯一数据源切换

点击(此处)折叠或打开

1. @Transactional(rollbackFor={Exception.class,RuntimeException.class})
   

2. @DataSource("master")
   

3.     public GmcSmsInfo addMaster(GmcSmsInfo smsInfo) throws BusinessServiceException {
   

4.         try {
   

5.             smsInfo.setSmsId(gmcSmsInfoDaoImpl.save(smsInfo));
   

6.         }
   

7.         catch (FrameworkDAOException e) {
   

8.             throw new BusinessServiceException(e);
   

9.         }
   

10.         return smsInfo;
    

11.     }

@Transactional 通过数据库的connection来建立事务的，为了保证数据源能顺利切换，要保证@DataSource优先于@Transactional执行。   实现办法 在DataSourceAspect 切面上增加注解@Order(1).   此处需要了解切面的层次和执行顺序等相关知识。   @Transactionl,@DataSource 在service层的同一个方法上。

情况二：事务下多数据源切换

service类

点击(此处)折叠或打开

1. @Autowired
   

2.     private GmcSmsInfoDAO gmcSmsInfoDaoImpl;
   

4.     @Autowired
   

5.     @Qualifier("transactionManager")
   

6.     private JtaTransactionManager transactionManager;
   

9.     public void addMasterAndSlave(GmcSmsInfo smsInfo) throws BusinessServiceException {
   

10.         UserTransaction userTransaction = transactionManager.getUserTransaction();
    

11.         try {
    

12.             userTransaction.begin();
    

13.             gmcSmsInfoDaoImpl.addMaster(smsInfo);
    

14.             smsInfo = new GmcSmsInfo();
    

16.             smsInfo.setChannel("test2");
    

17.             smsInfo.setContent("test2");
    

18.             smsInfo.setStatus("001");
    

19.             smsInfo.setCreateDate(Calendar.getInstance().getTime());
    

20.             smsInfo.setMobile("88888888");
    

21.             gmcSmsInfoDaoImpl.addSlave(smsInfo);
    

22.             userTransaction.commit();
    

23.         }
    

24.         catch (Exception e) {
    

25.             try {
    

26.                 userTransaction.rollback();
    

27.             }
    

28.             catch (IllegalStateException e1) {
    

29.                 e1.printStackTrace();
    

30.             }
    

31.             catch (SecurityException e1) {
    

32.                 e1.printStackTrace();
    

33.             }
    

34.             catch (SystemException e1) {
    

35.                 e1.printStackTrace();
    

36.             }
    

37.             throw new BusinessServiceException(e);
    

38.         }
    

40.     }

dao实现类

点击(此处)折叠或打开

1. 
   

2.     @Override
   

3.     @DataSource("master")
   

4.     public Integer addMaster(GmcSmsInfo smsInfo) throws FrameworkDAOException {
   

5.         return save(smsInfo);
   

6.     }
   

8.     
   

9.     @Override
   

10.     @DataSource("slave")
    

11.     public Integer addSlave(GmcSmsInfo smsInfo) throws FrameworkDAOException {
    

12.         return save(smsInfo);
    

13.     }

注意，此处采用了编程式来实现事务，注解式暂时还没有好的解决方法，欢迎大家讨论分享。  此处的@DataSource 放在了dao的实现层。

“Jdbc怎么实现分布式事务数据源动态切换”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！