通过代码理解分布式事务：XA模式

什么是XA?

看百科：XA协议由Tuxedo首先提出的，并交给X/Open组织，作为资源管理器（数据库）与事务管理器的接口标准。Oracle、Informix、DB2和Sybase等各大数据库厂家都提供对XA的支持。XA协议采用两阶段提交方式来管理分布式事务。XA接口提供资源管理器与事务管理器之间进行通信的标准接口。

• 资源管理器（RM）：就是一种存储数据的服务，例如Mysql和Oracle。
• 事务管理器（TM）：在分布式系统中，每个系统的有自己单独的本地事务，如何让这些事务组成一个完整的事务？这就是事务管理器要干的事情，保证所有事务要么全部成功，要么全部失败。

XA就定义了资源管理器和事务管理器通信的规范：

1. prepare：预提交，当各个资源管理器执行完数据操作后，事务管理器会发起预提交，询问每个资源管理器是否能提交数据。
2. commit/rollback：提交/回滚。事务管理器会收集所有的资源管理器的响应，如果有全部成功则通知所有的RM提交，有失败的则通知所有RM回滚。
   

怎么使用XA？

以Java Mysql操作为例。Mysql的mysql-connector-java已经实现了XA接口。
看下下面例子：

public class MysqlXADemo {
    
    public static void main(String[] args) throws SQLException {
        //true表示打印XA语句,，用于调试
        boolean logXaCommands = true;
        // 获得资源管理器操作接口实例 RM1
        Connection conn1 = DriverManager.getConnection
                ("jdbc:mysql://localhost:3306/db_user", "root", "root");
        XAConnection xaConn1 = new MysqlXAConnection(
                (com.mysql.jdbc.Connection) conn1, logXaCommands);
        XAResource rm1 = xaConn1.getXAResource();
        
        // 获得资源管理器操作接口实例 RM2
        Connection conn2 = DriverManager.getConnection
                ("jdbc:mysql://localhost:3306/db_account", "root", "root");
        XAConnection xaConn2 = new MysqlXAConnection(
                (com.mysql.jdbc.Connection) conn2, logXaCommands);
        XAResource rm2 = xaConn2.getXAResource();
        
        // AP请求TM执行一个分布式事务，TM生成全局事务id
        byte[] gtrid = "g12345".getBytes();
        int formatId = 1;
        try {
            
            // ==============分别执行RM1和RM2上的事务分支====================
            // TM生成rm1上的事务分支id
            byte[] bqual1 = "b00001".getBytes();
            Xid xid1 = new MysqlXid(gtrid, bqual1, formatId);
            // 执行rm1上的事务分支
            rm1.start(xid1, XAResource.TMNOFLAGS);//One of TMNOFLAGS, TMJOIN, or TMRESUME.
            PreparedStatement ps1 = conn1.prepareStatement(
                    "INSERT into user(name) VALUES ('Fox')");
            ps1.execute();
            rm1.end(xid1, XAResource.TMSUCCESS);
            
            // TM生成rm2上的事务分支id
            byte[] bqual2 = "b00002".getBytes();
            Xid xid2 = new MysqlXid(gtrid, bqual2, formatId);
            // 执行rm2上的事务分支
            rm2.start(xid2, XAResource.TMNOFLAGS);
            PreparedStatement ps2 = conn2.prepareStatement(
                    "INSERT into account(user_id,money) VALUES (1,10000000)");
            ps2.execute();
            rm2.end(xid2, XAResource.TMSUCCESS);
            
            // ===================两阶段提交================================
            // phase1：询问所有的RM 准备提交事务分支
            int rm1_prepare = rm1.prepare(xid1);
            int rm2_prepare = rm2.prepare(xid2);
            // phase2：提交所有事务分支
            boolean onePhase = false;
            //TM判断有2个事务分支，所以不能优化为一阶段提交
            if (rm1_prepare == XAResource.XA_OK
                    && rm2_prepare == XAResource.XA_OK) {
                //所有事务分支都prepare成功，提交所有事务分支
                rm1.commit(xid1, onePhase);
                rm2.commit(xid2, onePhase);
            } else {
                //如果有事务分支没有成功，则回滚
                rm1.rollback(xid1);
                rm2.rollback(xid2);
            }
        } catch (XAException e) {
            // 如果出现异常，也要进行回滚
            e.printStackTrace();
        }
    }
}

在上面代码中，MysqlXADemo充当了TM角色，rm1和rm2都执行成功则全部提交，否则则回滚。

XA模式框架：Atomikos

Atomikos是一款开源类事务管理器，提供XA模式分布式事务管理功能。其具体实现也是对mysql jdbc的XA实现的封装，使其使用更加简单便捷。

public class AtomikosDemo {
 
   private static AtomikosDataSourceBean createAtomikosDataSourceBean(String dbName) {
      // 连接池基本属性
      Properties p = new Properties();
      p.setProperty("url", "jdbc:mysql://localhost:3306/" + dbName);
      p.setProperty("user", "root");
      p.setProperty("password", "root");
 
      // 使用AtomikosDataSourceBean封装com.mysql.jdbc.jdbc2.optional.MysqlXADataSource
      AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
      //设置resourceName 唯一
      ds.setUniqueResourceName(dbName);
      ds.setXaDataSourceClassName("com.mysql.jdbc.jdbc2.optional.MysqlXADataSource");
      ds.setXaProperties(p);
      return ds;
   }
 
   public static void main(String[] args) {
 
      AtomikosDataSourceBean ds1 = createAtomikosDataSourceBean("db_user");
      AtomikosDataSourceBean ds2 = createAtomikosDataSourceBean("db_account");
 
      Connection conn1 = null;
      Connection conn2 = null;
      PreparedStatement ps1 = null;
      PreparedStatement ps2 = null;
 
      UserTransaction userTransaction = new UserTransactionImp();
      try {
         // 开启事务
         userTransaction.begin();
 
         // 执行db1上的sql
         conn1 = ds1.getConnection();
         ps1 = conn1.prepareStatement("INSERT into user(name) VALUES (?)", Statement.RETURN_GENERATED_KEYS);
         ps1.setString(1, "Fox");
         ps1.executeUpdate();
         ResultSet generatedKeys = ps1.getGeneratedKeys();
         int userId = -1;
         while (generatedKeys.next()) {
            // 获得自动生成的userId
            userId = generatedKeys.getInt(1);
         }
 
         // 模拟异常 ，直接进入catch代码块，2个都不会提交
        //int i=1/0;
 
         // 执行db2上的sql
         conn2 = ds2.getConnection();
         ps2 = conn2.prepareStatement("INSERT into account(user_id,money) VALUES (?,?)");
         ps2.setInt(1, userId);
         ps2.setDouble(2, 10000000);
         ps2.executeUpdate();
 
         // 两阶段提交
         userTransaction.commit();
      } catch (Exception e) {
         try {
            e.printStackTrace();
            userTransaction.rollback();
         } catch (SystemException e1) {
            e1.printStackTrace();
         }
      } finally {
         try {
            ps1.close();
            ps2.close();
            conn1.close();
            conn2.close();
            ds1.close();
            ds2.close();
         } catch (Exception ignore) {
         }
      }
   }
}