Springboot+Atomikos+Jpa+Mysql实现JTA分布式事务

1 前言

之前整理了一个spring+jotm实现的分布式事务实现，但是听说spring3.X后不再支持jotm了，jotm也有好几年没更新了，所以今天整理springboot+Atomikos+jpa+mysql的JTA分布式事务实现。

Atomikos网上的资料确实比jotm多，另外我发现STS工具里集成了Atomikos，那spring对Atomikos的支持毋庸置疑肯定会在相当长的时间内会是友好的。

2 开发环境

Springboot 1.0.1 + Atomikos 3.9.3 + JPA （Hibernate 4.3.5） + Mysql 5.1.73 + Mysql Connector 5.1.31 + Junit + Maven

3 代码

这套代码的基础我是从网上下载的，作了些修改，因为它原来用的是H2数据库，我改成了Mysql，另外，其实spring官网的例子也是这样写的，http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/

3.1 数据库sql

 DROP DATABASE IF EXISTS `datasource1`;
 CREATE DATABASE `datasource1` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; 

 use datasource1;

 DROP TABLE IF EXISTS `orders`;
 CREATE TABLE `orders` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `code` int(11) DEFAULT NULL,
   `quantity` int(11) DEFAULT NULL,
   PRIMARY KEY (`id`)
 ) ENGINE=MyISAM DEFAULT CHARSET=utf8;

 DROP DATABASE IF EXISTS `datasource2`;
 CREATE DATABASE `datasource2` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci; 

 use datasource2;

 DROP TABLE IF EXISTS `customer`;
 CREATE TABLE `customer` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `name` varchar(45) DEFAULT NULL,
   `age` int(11) DEFAULT NULL,
   PRIMARY KEY (`id`)
 ) ENGINE=MyISAM AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

3.2 部分重要代码

　　pom.xml

 <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-data-jpa</artifactId>
         </dependency>

         <!-- <dependency>
             <groupId>com.h2database</groupId>
             <artifactId>h2</artifactId>
         </dependency> -->

         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
             <version>1.12.4</version>
         </dependency>

         <dependency>
             <groupId>com.atomikos</groupId>
             <artifactId>transactions</artifactId>
             <version>3.9.3</version>
         </dependency>

         <dependency>
             <groupId>com.atomikos</groupId>
             <artifactId>transactions-jta</artifactId>
             <version>3.9.3</version>
         </dependency>

         <dependency>
             <groupId>com.atomikos</groupId>
             <artifactId>transactions-hibernate3</artifactId>
             <version>3.9.3</version>
             <exclusions>
                 <exclusion>
                     <artifactId>hibernate</artifactId>
                     <groupId>org.hibernate</groupId>
                 </exclusion>
             </exclusions>
         </dependency>

         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
         </dependency>

         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
             <scope>test</scope>
         </dependency>

         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
         <dependency>
             <groupId>mysql</groupId>
             <artifactId>mysql-connector-java</artifactId>
             <version>5.1.31</version>
         </dependency>

     </dependencies>

application.properties

 spring.main.show_banner=false

 order.datasource.url=jdbc:mysql://192.168.0.12:3306/datasource1?serverTimezone=UTC
 order.datasource.user=root
 order.datasource.password=123456
 #jdbc:h2:order

 customer.datasource.url=jdbc:mysql://127.0.0.1:3312/datasource2?serverTimezone=UTC
 customer.datasource.user=root
 customer.datasource.password=123456

 import java.util.HashMap;

 import javax.sql.DataSource;

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.DependsOn;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.orm.jpa.JpaVendorAdapter;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;

 import com.at.mul.repository.customer.CustomerDatasourceProperties;
 import com.atomikos.jdbc.AtomikosDataSourceBean;
 import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;

 @Configuration
 @DependsOn("transactionManager")
 @EnableJpaRepositories(basePackages = "com.at.mul.repository.customer", entityManagerFactoryRef = "customerEntityManager", transactionManagerRef = "transactionManager")
 @EnableConfigurationProperties(CustomerDatasourceProperties.class)
 public class CustomerConfig {

     @Autowired
     private JpaVendorAdapter jpaVendorAdapter;

     @Autowired
     private CustomerDatasourceProperties customerDatasourceProperties;

     @Bean(name = "customerDataSource", initMethod = "init", destroyMethod = "close")
     public DataSource customerDataSource() {
         MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
         mysqlXaDataSource.setURL(customerDatasourceProperties.getUrl());
         mysqlXaDataSource.setUser(customerDatasourceProperties.getUser());
         mysqlXaDataSource.setPassword(customerDatasourceProperties.getPassword());
         mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

         AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
         xaDataSource.setXaDataSource(mysqlXaDataSource);
         xaDataSource.setUniqueResourceName("datasource2");
 //        xaDataSource.setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
         return xaDataSource;
     }

     @Bean(name = "customerEntityManager")
     @DependsOn("transactionManager")
     public LocalContainerEntityManagerFactoryBean customerEntityManager() throws Throwable {

         HashMap<String, Object> properties = new HashMap<String, Object>();
         properties.put("hibernate.transaction.jta.platform", AtomikosJtaPlatform.class.getName());
         properties.put("javax.persistence.transactionType", "JTA");

         LocalContainerEntityManagerFactoryBean entityManager = new LocalContainerEntityManagerFactoryBean();
         entityManager.setJtaDataSource(customerDataSource());
         entityManager.setJpaVendorAdapter(jpaVendorAdapter);
         entityManager.setPackagesToScan("com.at.mul.domain.customer");
         entityManager.setPersistenceUnitName("customerPersistenceUnit");
         entityManager.setJpaPropertyMap(properties);
         return entityManager;
     }

 }

 @Configuration
 @DependsOn("transactionManager")
 @EnableJpaRepositories(basePackages = "com.at.mul.repository.order", entityManagerFactoryRef = "orderEntityManager", transactionManagerRef = "transactionManager")
 @EnableConfigurationProperties(OrderDatasourceProperties.class)
 public class OrderConfig {

     @Autowired
     private JpaVendorAdapter jpaVendorAdapter;

     @Autowired
     private OrderDatasourceProperties orderDatasourceProperties;

     @Bean(name = "orderDataSource", initMethod = "init", destroyMethod = "close")
     public DataSource orderDataSource() {
         MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
         mysqlXaDataSource.setURL(orderDatasourceProperties.getUrl());
         mysqlXaDataSource.setUser(orderDatasourceProperties.getUser());
         mysqlXaDataSource.setPassword(orderDatasourceProperties.getPassword());
 //        mysqlXaDataSource.setAllowMultiQueries(true);
 //        mysqlXaDataSource.setLogXaCommands(true);
         mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

         AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
         xaDataSource.setXaDataSource(mysqlXaDataSource);
         xaDataSource.setUniqueResourceName("datasource1");
 //        xaDataSource.setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
         return xaDataSource;
     }

     @Bean(name = "orderEntityManager")
     public LocalContainerEntityManagerFactoryBean orderEntityManager() throws Throwable {

         HashMap<String, Object> properties = new HashMap<String, Object>();
         properties.put("hibernate.transaction.jta.platform", AtomikosJtaPlatform.class.getName());
         properties.put("javax.persistence.transactionType", "JTA");

         LocalContainerEntityManagerFactoryBean entityManager = new LocalContainerEntityManagerFactoryBean();
         entityManager.setJtaDataSource(orderDataSource());
         entityManager.setJpaVendorAdapter(jpaVendorAdapter);
         entityManager.setPackagesToScan("com.at.mul.domain.order");
         entityManager.setPersistenceUnitName("orderPersistenceUnit");
         entityManager.setJpaPropertyMap(properties);
         return entityManager;
     }

 }

 import com.at.mul.domain.customer.Customer;
 import com.at.mul.domain.order.Order;
 import com.at.mul.exception.NoRollbackException;
 import com.at.mul.exception.StoreException;

 public interface StoreService {

     void store(Customer customer, Order order) throws Exception;

     void storeWithStoreException(Customer customer, Order order) throws StoreException;

     void storeWithNoRollbackException(Customer customer, Order order) throws NoRollbackException;

 }

 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

 import com.at.mul.domain.customer.Customer;
 import com.at.mul.domain.order.Order;
 import com.at.mul.exception.NoRollbackException;
 import com.at.mul.exception.StoreException;
 import com.at.mul.repository.customer.CustomerRepository;
 import com.at.mul.repository.order.OrderRepository;

 @Service
 public class StoreServiceImpl implements StoreService {

     @Autowired
     private CustomerRepository customerRepository;

     @Autowired
     private OrderRepository orderRepository;

     @Transactional
     public void store(Customer customer, Order order) {
         customerRepository.save(customer);
         orderRepository.save(order);
     }

     @Transactional(rollbackFor = StoreException.class)
     public void storeWithStoreException(Customer customer, Order order) throws StoreException {
         customerRepository.save(customer);
         orderRepository.save(order);
         throw new StoreException();
     }

     @Transactional(noRollbackFor = NoRollbackException.class, rollbackFor = StoreException.class)
     public void storeWithNoRollbackException(Customer customer, Order order) throws NoRollbackException {
         customerRepository.save(customer);
         orderRepository.save(order);
         throw new NoRollbackException();
     }

 }

完整代码下载：http://download.csdn.net/download/u013081610/9927514

4 遇到的坑

4.1 bug: The server time zone value '�й���׼ʱ��' is unrecognized or represents more than one time zone.

http://blog.csdn.net/sunlggggg/article/details/54564114

4.2 com.mysql.jdbc.jdbc2.optional.MysqlXAException: XAER_INVAL: Invalid arguments (or unsupported command)
WARNING: XA resource 'jdbc/mysqlDs': resume for XID '3139322E3136382E31342E3131372E746D30303030323030303831:3139322E3136382E31342E3131372E746D32' raised -5: invalid arguments were given for the XA operation

这个错误是我运行StoreServiceTest里的testStore()方法时出现的，就是把数据分别插入两个库的表里，之前用H2的时候都很正常，但是换成Mysql就是不行，操作第二个库的时候就报这个错，第一个不会报错。

猜测可能是以下原因吧
a.这可能是MySQL服务器对XA支持的限制，也就是可能是MySQL的一个bug,可以看Mysql官方文档的解释https://dev.mysql.com/doc/refman/5.5/en/xa-statements.html
b.也可能是atomikos里的问题，具体看https://www.atomikos.com/Documentation/KnownProblems#ActiveMQ_error:_34Transaction_39XID:..._39_has_not_been_started_34
找到下面的段落

MySQL XA bug
Some users have reported problems with MySQL XA (related to this MySQL bug: http://bugs.mysql.com/bug.php?id=27832external). This problem only happens if you access the same MySQL database more than once in the same transaction. A workaround can be setting the following property in jta.properties:
com.atomikos.icatch.serial_jta_transactions=false
Also, make sure to set the following property on the MySQL datasource:
pinGlobalTxToPhysicalConnection="true"
MariaDB's java driver also supports this workaround since v.1.1.8

看来atomikos已经针对mysql的这个bug作了处理了，根据提示我加了mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true)就可以了。

4.3 貌似对mysql的InnoDB引擎没用

具体什么原因我还没研究，暂时测试只是使用的MyISAM