Java 分布式事务（多数据源）

最近这几天一直在整 怎么实现分布式事务。找了很多资料，不过大都相近类同。对Oracle、SQL Server、Mysql数已做过测试，其中Mysql5.0以上的才支持分布式事务。
对于这些，主要是之前根本没有接触过分布式事务，还错找了一些分布式事数据库的资料，呵呵，结果不是我目前所需要的。
测试过程中出现了很多错误，一直都通不过，以为是用户权限还有数据库服务的问题，但一切都配置良好的情况下还一直都通不过。结果发现，我导入的都是一些普通的JDBC连接包，于是狂搜实现XA事务的jar包。
Mysql:            mysql-connector-java-5.1.6-bin.jar
SQL Server:       sqljdbc.jar
Oracle:           ojdbc14.jar
用的是这些包才顺利通过运行。后面会附上这几个jar包。
好了，把源代码也附上：

import com.microsoft.sqlserver.jdbc.SQLServerXADataSource;
import com.mysql.jdbc.jdbc2.optional.MysqlXADataSource;
import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.sql.*;
import javax.transaction.xa.*;
import oracle.jdbc.xa.client.OracleXADataSource;

public class Mutil_DataSource_Test {
    public static void main(String[] args){
        Mutil_DataSource_Test mdt = new Mutil_DataSource_Test();
        try {
            mdt.test1();
        } catch (Exception ex) {
            System.out.println("除SQLException、XAException之外的异常: \n");
            Logger.getLogger(Mutil_DataSource_Test.class.getName()).log(Level.SEVERE, null, ex);
         }
    }

    class MyXid implements Xid{
        int formatId;
        byte globalTransactionId[];
        byte branchQualifier[];
        public MyXid(){

        }
        public MyXid(int formatId,byte[] globalTransactionId,byte[] branchQualifier){
             this.formatId = formatId;
            this.globalTransactionId = globalTransactionId;
            this.branchQualifier = branchQualifier;
        }

        public int getFormatId() {
            return this.formatId;
        }
        public void setFormatId(int formatId){
            this.formatId = formatId;
        }
        public byte[] getGlobalTransactionId() {
            return this.globalTransactionId;
        }
        public void setGlobalTransactionId(byte[] globalTransactionId){
            this.globalTransactionId = globalTransactionId;
        }
        public byte[] getBranchQualifier() {
            return this.branchQualifier;
        }
        public void setBranchQualifier(byte[] branchQualifier){
            this.branchQualifier = branchQualifier;
        }
    }

    //多数据库测试
    public void test1() {
        //定义所需用到的变量
         Connection mysqlCn = null;
        Connection sqlCn = null;
        Connection mysqlCn2 = null;
        Connection oraCn = null;

        MysqlXADataSource mysqlDs = null;
        SQLServerXADataSource sqlDs = null;
        MysqlXADataSource mysqlDs2 = null;
        OracleXADataSource oraDs = null;

        XAConnection xamysqlCn = null;
        XAConnection xasqlCn = null;
        XAConnection xamysqlCn2 = null;
        XAConnection xaoraCn = null;

        XAResource xamysqlRes = null;
        XAResource xasqlRes = null;
        XAResource xamysqlRes2 = null;
        XAResource xaoraRes = null;

        Xid mysqlXid = null;
        Xid sqlXid = null;
        Xid mysqlXid2 = null;
        Xid oraXid = null;

        Statement mysqlpst = null;
        Statement sqlpst = null;
        Statement mysqlpst2 = null;
        Statement orapst = null;
    try{
        //获得数据源
        mysqlDs = new MysqlXADataSource();
        mysqlDs.setURL("jdbc:mysql://localhost:3306/test");
        mysqlDs2 = new MysqlXADataSource();
        mysqlDs2.setURL("jdbc:mysql://10.10.10.119:3306/test");
        sqlDs = new SQLServerXADataSource();
        sqlDs.setURL("jdbc:sqlserver://10.10.10.119:1433;DatabaseName=RTC;loginTimeout=20;user=sa;password=chgpwd122105");
//        sqlDs.setUser("sa");
//        sqlDs.setPassword("chgpwd122105");
//        sqlDs.setServerName("10.10.10.119");
//        sqlDs.setPortNumber(1433);
//        sqlDs.setDatabaseName("RTC");
        oraDs = new OracleXADataSource();
        oraDs.setURL("jdbc:oracle:thin:@10.10.10.119:1521:WMS");
        //获得连接
        xamysqlCn = mysqlDs.getXAConnection("root", "9999");
System.out.println("xamysqlCn: "+xamysqlCn);
        xasqlCn = sqlDs.getXAConnection();
System.out.println("xasqlCn: "+xasqlCn);
        xamysqlCn2 = mysqlDs2.getXAConnection("root", "9999");
System.out.println("xamysqlCn2: "+xamysqlCn2);
        xaoraCn = oraDs.getXAConnection("tiger", "tiger");
System.out.println("xaoraCn: "+xaoraCn);

        mysqlCn = xamysqlCn.getConnection();
        sqlCn = xasqlCn.getConnection();
        mysqlCn2 = xamysqlCn2.getConnection();
        oraCn = xaoraCn.getConnection();

        mysqlpst = mysqlCn.createStatement();
        sqlpst = sqlCn.createStatement();
        mysqlpst2 = mysqlCn2.createStatement();
        orapst = oraCn.createStatement();
        //定义XAResource
        xamysqlRes = xamysqlCn.getXAResource();
        xasqlRes = xasqlCn.getXAResource();
        xamysqlRes2 = xamysqlCn2.getXAResource();
        xaoraRes = xaoraCn.getXAResource();
        //定义Xid
        mysqlXid = new MyXid(0, new byte[]{0x01}, new byte[]{0x02});
        sqlXid = new MyXid(0, new byte[]{0x01}, new byte[]{0x03});
        mysqlXid2 = new MyXid(0, new byte[]{0x01}, new byte[]{0x04});
        oraXid = new MyXid(0, new byte[]{0x01}, new byte[]{0x05});
        //执行Mysql
        xamysqlRes.start(mysqlXid, XAResource.TMNOFLAGS);       
        mysqlpst.executeUpdate("insert into test values(4,'XA','F','Class4')");
        xamysqlRes.end(mysqlXid, XAResource.TMSUCCESS);
        //执行SQLServer
        xasqlRes.start(sqlXid, XAResource.TMNOFLAGS);
        sqlpst.executeUpdate("insert into test values('444')");
        xasqlRes.end(sqlXid, XAResource.TMSUCCESS);
        //执行Mysql
        xamysqlRes2.start(mysqlXid2, XAResource.TMNOFLAGS);
        mysqlpst2.executeUpdate("insert into test values(4,'XA','F','Class4')");
        xamysqlRes2.end(mysqlXid2, XAResource.TMSUCCESS);
        //执行Oracle
        System.out.println("xaoraRes: "+xaoraRes);
        xaoraRes.start(oraXid, XAResource.TMNOFLAGS);
        orapst.executeUpdate("insert into test123 values('4','44','444')");
        System.out.println("oraXid: "+oraXid);
        xaoraRes.end(oraXid, XAResource.TMSUCCESS);
        //准备
        int mysqlRea = xamysqlRes.prepare(mysqlXid);
        int sqlRea = xasqlRes.prepare(sqlXid);
        int mysqlRea2 = xamysqlRes2.prepare(mysqlXid2);
        int oraRea = xaoraRes.prepare(oraXid);
        //判断准备就绪与否  提交或回滚
        if(mysqlRea == xamysqlRes.XA_OK && mysqlRea2 == xamysqlRes.XA_OK && oraRea == xaoraRes.XA_OK && sqlRea == xasqlRes.XA_OK){
//        if(mysqlRea == xamysqlRes.XA_OK && mysqlRea2 == xamysqlRes.XA_OK && oraRea == xaoraRes.XA_OK){
//        if(mysqlRea == xamysqlRes.XA_OK && sqlRea == xasqlRes.XA_OK && mysqlRea2 == xamysqlRes.XA_OK){
//        if(mysqlRea == xamysqlRes.XA_OK && mysqlRea2 == xamysqlRes.XA_OK){
            xamysqlRes.commit(mysqlXid, false);
System.out.println("Mysql 事务提交成功！");
            xasqlRes.commit(sqlXid, false);
System.out.println("SQLServer 事务提交成功！");
            xamysqlRes2.commit(mysqlXid2, false);
System.out.println("Mysql2 事务提交成功！");
            xaoraRes.commit(oraXid, false);
System.out.println("Oracle 事务提交成功！");
        }else{
            xamysqlRes.rollback(mysqlXid);
            xasqlRes.rollback(sqlXid);
            xamysqlRes2.rollback(mysqlXid2);
            xaoraRes.rollback(oraXid);
System.out.println("事务回滚成功！");
        }
    }catch(SQLException ex){
        Logger.getLogger(Mutil_DataSource_Test.class.getName()).log(Level.SEVERE, null, ex);
         try{
            xamysqlRes.rollback(mysqlXid);
            xasqlRes.rollback(sqlXid);
            xamysqlRes2.rollback(mysqlXid2);
            xaoraRes.rollback(oraXid);
        }catch(XAException e){
            System.out.println("回滚也出错咯！~");
            e.printStackTrace();
        }
    }catch(XAException ex){
        Logger.getLogger(Mutil_DataSource_Test.class.getName()).log(Level.SEVERE, null, ex);
     }finally{
        try {
        //关闭
        mysqlpst.close();
        mysqlCn.close();
        xamysqlCn.close();
        sqlpst.close();
        sqlCn.close();
        xasqlCn.close();
        mysqlpst2.close();
        mysqlCn2.close();
        xamysqlCn2.close();
        orapst.close();
        oraCn.close();
        xaoraCn.close();
        } catch (SQLException ex) {
            Logger.getLogger(Mutil_DataSource_Test.class.getName()).log(Level.SEVERE, null, ex);
         }
    }
    }
}

分布式事务分为两个阶段，第一个阶段相当于是一个预提交，第二阶段才是正真的提交。
首先要实现的是Xid接口，formatId可以理解为一个全局事务的ID，不过我上面的代码没有去做一些异常的处理，还有正确的链接的关闭，只是自己做的一个小小的测试，以后项目中再去处理这些。第一阶段如果出错或是不顺利则不会提交，需要做一些回滚处理。如果顺利则准备提交，进入第二阶段，在第二阶段可能会出现问题，如果第一个分支事务提交成功了，而后有一个分支事务提交失败，这样则会造成数据不准确，目前还不知道有没有方法可以解决些问题，好像XAResource.recover()可以处理，但具体怎么解决，在项目中自己还是可以想到办法解决。
对XA分布式事务  我是初学者，而且也没有谁指点，只是在网上找些资料。我上面的理解可能也还有些不足或是错误。希望高手看到后能指点指点。

原文：http://blog.csdn.net/kangojian/article/details/6780305