数据库中间件 MyCAT 源码分析 —— XA分布式事务

最新推荐文章于 2024-02-24 21:54:13 发布
最新推荐文章于 2024-02-24 21:54:13 发布
阅读量206 收藏
点赞数
文章标签： 数据库 java json
原文链接：https://juejin.im/post/596b28ab6fb9a06bb01953e6
版权

wechat_mp

???关注微信公众号有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。

1. 概述

数据库拆分后，业务上会碰到需要分布式事务的场景。MyCAT 基于 XA 实现分布式事务。国内目前另外一款很火的数据库中间件 Sharding-JDBC 准备基于 TCC 实现分布式事务。

本文内容分成三部分：

  1. XA 概念简述
  2. MyCAT 代码如何实现 XA
  3. MyCAT 在实现 XA 存在的一些缺陷

2. XA 概念

>
X/Open 组织（即现在的 Open Group ）定义了分布式事务处理模型。 X/Open DTP 模型（ 1994 ）包括：

  1. 应用程序（ AP ）
  2. 事务管理器（ TM ）
  3. 资源管理器（ RM ）
  4. 通信资源管理器（ CRM ）
    一般，常见的事务管理器（ TM ）是交易中间件，常见的资源管理器（ RM ）是数据库，常见的通信资源管理器（ CRM ）是消息中间件，下图是X/Open DTP模型：

一般的编程方式是这样的：

  1. 配置 TM ，通过 TM 或者 RM 提供的方式，把 RM 注册到 TM。可以理解为给 TM 注册 RM 作为数据源。一个 TM 可以注册多个 RM。
  2. AP 从 TM 获取资源管理器的代理（例如：使用JTA接口，从TM管理的上下文中，获取出这个TM所管理的RM的JDBC连接或JMS连接）
    AP 向 TM 发起一个全局事务。这时，TM 会通知各个 RM。XID（全局事务ID）会通知到各个RM。
  3. AP 通过 TM 中获取的连接，间接操作 RM 进行业务操作。这时，TM 在每次 AP 操作时把 XID(包括所属分支的信息)传递给 RM，RM 正是通过这个 XID 关联来操作和事务的关系的。
  4. AP 结束全局事务时，TM 会通知 RM 全局事务结束。开始二段提交，也就是prepare - commit的过程。

XA协议指的是TM（事务管理器）和RM（资源管理器）之间的接口。目前主流的关系型数据库产品都是实现了XA接口的。JTA(Java Transaction API)是符合X/Open DTP模型的，事务管理器和资源管理器之间也使用了XA协议。 本质上也是借助两阶段提交协议来实现分布式事务的，下面分别来看看XA事务成功和失败的模型图：

成功

失败

? 看到这里是不是有种黑人问号的感觉？淡定！我们接下来看 MyCAT 代码层面是如何实现 XA 的。另外，有兴趣对概念了解更多的，可以参看如下文章：

  1. 《XA事务处理》
  2. 《XA Transaction SQL Syntax》
  3. 《MySQL XA 事务支持调研》

3. MyCAT 代码实现

  • MyCAT ：TM，协调者。
  • 数据节点 ：RM，参与者。

3.1 JDBC Demo 代码

public class MyCATXAClientDemo {

    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 1. 获得数据库连接
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:8066/dbtest", "root", "123456");
        conn.setAutoCommit(false);

        // 2. 开启 MyCAT XA 事务
        conn.prepareStatement("set xa=on").execute();

        // 3. 插入 SQL
        // 3.1 SQL1 A库
        long uid = Math.abs(new Random().nextLong());
        String username = UUID.randomUUID().toString();
        String password = UUID.randomUUID().toString();
        String sql1 = String.format("insert into t_user(id, username, password) VALUES (%d, '%s', '%s')",
                uid, username, password);
        conn.prepareStatement(sql1).execute();
        // 3.2 SQL2 B库
        long orderId = Math.abs(new Random().nextLong());
        String nickname = UUID.randomUUID().toString();
        String sql2 = String.format("insert into t_order(id, uid, nickname) VALUES(%d, %s, '%s')", orderId, uid, nickname);
        conn.prepareStatement(sql2).execute();

        // 4. 提交 XA 事务
        conn.commit();
    }

}复制代码
  • set xa=on MyCAT 开启 XA 事务。
  • conn.commit 提交 XA 事务。

3.2 MyCAT 开启 XA 事务

当 MyCAT 接收到 set xa = on 命令时，开启 XA 事务，并生成 XA 事务编号。XA 事务编号生成算法为 UUID。核心代码如下：

// SetHandler.java
public static void handle(String stmt, ServerConnection c, int offset) {
        int rs = ServerParseSet.parse(stmt, offset);
        switch (rs & 0xff) {
        // ... 省略代码
        case XA_FLAG_ON: {
            if (c.isAutocommit()) {
                c.writeErrMessage(ErrorCode.ERR_WRONG_USED, "set xa cmd on can't used in autocommit connection ");
                return;
            }
            c.getSession2().setXATXEnabled(true);
            c.write(c.writeToBuffer(OkPacket.OK, c.allocate()));
            break;
        }
        case XA_FLAG_OFF: {
            c.writeErrMessage(ErrorCode.ERR_WRONG_USED,
                    "set xa cmd off not for external use ");
            return;
        }
        // ... 省略代码
    }
}
// NonBlockingSession.java
public void setXATXEnabled(boolean xaTXEnabled) {
   if (xaTXEnabled) {
       if (this.xaTXID == null) {
           xaTXID = genXATXID(); // ??��获得 XA 事务编号
       }
   } else {
       this.xaTXID = null;
   }
}
private String genXATXID() {
   return MycatServer.getInstance().getXATXIDGLOBAL();
}
// MycatServer.java
public String getXATXIDGLOBAL() {
   return "'" + getUUID() + "'";
}
public static String getUUID() { // ???
   String s = UUID.randomUUID().toString();
   return s.substring(0, 8) + s.substring(9, 13) + s.substring(14, 18) + s.substring(19, 23) + s.substring(24);
}复制代码

3.3 MyCAT 接收 SQL

此处 SQL 指的是 insert、update、delete 操作。

当向某个数据节点第一次发起 SQL 时，会在 SQL 前面附加 XA START 'xaTranId'，并设置该数据节点连接事务状态为 TxState.TX_STARTED_STATE（分布式事务状态，下文会专门整理）。核心代码如下：

// MySQLConnection.java
private void synAndDoExecute(String xaTxID, RouteResultsetNode rrn,
                                 int clientCharSetIndex, int clientTxIsoLation,
                                 boolean clientAutoCommit) {
   String xaCmd = null;
   boolean conAutoComit = this.autocommit;
   String conSchema = this.schema;
   // never executed modify sql,so auto commit
   boolean expectAutocommit = !modifiedSQLExecuted || isFromSlaveDB() || clientAutoCommit;
   if (expectAutocommit == false && xaTxID != null && xaStatus == TxState.TX_INITIALIZE_STATE) { // ???
       xaCmd = "XA START " + xaTxID + ';';
       this.xaStatus = TxState.TX_STARTED_STATE;
   }
   // .... 省略代码
   StringBuilder sb = new StringBuilder();
   // .... 省略代码
   if (xaCmd != null) {
       sb.append(xaCmd);
   }
   // and our query sql to multi command at last
   sb.append(rrn.getStatement() + ";");
   // syn and execute others
   this.sendQueryCmd(sb.toString());
}复制代码

举个 变量sb 的例子：

SET names utf8;SET autocommit=0;XA START '1f2da7353e8846e5833b8d8dd041cfb1','db2';insert into t_user(id, username, password) VALUES (3400, 'b7c5ec1f-11cc-4599-851c-06ad617fec42', 'd2694679-f6a2-4623-a339-48d4a868be90');复制代码

3.4 MySQL 接收 COMMIT

3.4.1 单节点事务 or 多节点事务

COMMIT 执行时，MyCAT 会判断 XA 事务里，涉及到的数据库节点数量。

  • 如果节点数量为 1，单节点事务，使用 CommitNodeHandler 处理。
  • 如果节点数量 > 1，多节点事务，使用 MultiNodeCoordinator 处理。

CommitNodeHandler 相比 MultiNodeCoordinator 来说，只有一个数据节点，不需要进行多节点协调，逻辑会相对简单，有兴趣的同学可以另外看。我们主要分析 MultiNodeCoordinator。

3.4.2 协调日志

协调日志，记录协调过程中各数据节点 XA 事务状态，处理MyCAT异常奔溃或者数据节点部分XA COMMIT，另外部分 XA PREPARE下的状态恢复。

XA 事务共有种：

  1. TX_INITIALIZE_STATE ：事务初始化
  2. TX_STARTED_STATE ：事务开始完成
  3. TX_PREPARED_STATE ：事务准备完成
  4. TX_COMMITED_STATE ：事务提交完成
  5. TX_ROLLBACKED_STATE ：事务回滚完成

状态变更流 ：TX_INITIALIZE_STATE => TX_STARTED_STATE => TX_PREPARED_STATE => TX_COMMITED_STATE / TX_ROLLBACKED_STATE 。

协调日志包含两个部分：

  1. CoordinatorLogEntry ：协调者日志
  2. ParticipantLogEntry ：参与者日志。此处，数据节点扮演参与者的角色。下文中，可能会出现参与者与数据节点混用的情况，望见谅。

一次 XA 事务，对应一条 CoordinatorLogEntry。一条CoordinatorLogEntry 包含 N条ParticipantLogEntry。 核心代码如下：

// CoordinatorLogEntry ：协调者日志
public class CoordinatorLogEntry implements Serializable {

    /**
     * XA 事务编号
     */
    public final String id;
    /**
     * 参与者日志数组
     */
    public final ParticipantLogEntry[] participants;
}
// ParticipantLogEntry ：参与者日志
public class ParticipantLogEntry implements Serializable {

    /**
     * XA 事务编号
     */
    public String coordinatorId;
    /**
     * 数据库 uri
     */
    public String uri;
    /**
     * 过期描述
     */
    public long expires;
    /**
     * XA 事务状态
     */
    public int txState;
    /**
     * 参与者名字
     */
    public String resourceName;
}复制代码

MyCAT 记录协调日志以 JSON格式 到文件。每行包含一条CoordinatorLogEntry。举个例子：

{"id":"'e827b3fe666c4d968961350d19adda31'","participants":[{"uri":"127.0.0.1","state":"3","expires":0,"resourceName":"db3"},{"uri":"127.0.0.1","state":"3","expires":0,"resourceName":"db1"}]}
{"id":"'f00b61fa17cb4ec5b8264a6d82f847d0'","participants":[{"uri":"127.0.0.1","state":"3","expires":0,"resourceName":"db2"},{"uri":"127.0.0.1","state":"3","expires":0,"resourceName":"db1"}]}复制代码

实现类为：

// XA 协调者日志 存储接口：https://github.com/YunaiV/Mycat-Server/blob/1.6/src/main/java/io/mycat/backend/mysql/xa/recovery/Repository.java
public interface Repository {}
// XA 协调者日志 文件存储：https://github.com/YunaiV/Mycat-Server/blob/1.6/src/main/java/io/mycat/backend/mysql/xa/recovery/impl/FileSystemRepository.java
public class FileSystemRepository implements Repository {}
// XA 协调者日志 文件存储：https://github.com/YunaiV/Mycat-Server/blob/1.6/src/main/java/io/mycat/backend/mysql/xa/recovery/impl/InMemoryRepository.java
public class InMemoryRepository implements Repository {}复制代码

目前日志文件写入的方式性能较差，这里我们不做分析，在【4. MyCAT 实现缺陷】里一起讲。

3.4.3 MultiNodeCoordinator

敲敲敲，这里是本文的重点之一噢。?

第一阶段：发起 PREPARE。

public void executeBatchNodeCmd(SQLCtrlCommand cmdHandler) {
   this.cmdHandler = cmdHandler;
   final int initCount = session.getTargetCount();
   runningCount.set(initCount);
   nodeCount = initCount;
   failed.set(false);
   faileCount.set(0);
   //recovery nodes log
   ParticipantLogEntry[] participantLogEntry = new ParticipantLogEntry[initCount];
   // 执行
   int started = 0;
   for (RouteResultsetNode rrn : session.getTargetKeys()) {
       if (rrn == null) {
           continue;
       }
       final BackendConnection conn = session.getTarget(rrn);
       if (conn != null) {
           conn.setResponseHandler(this);
           //process the XA_END XA_PREPARE Command
           MySQLConnection mysqlCon = (MySQLConnection) conn;
           String xaTxId = null;
           if (session.getXaTXID() != null) {
               xaTxId = session.getXaTXID() + ",'" + mysqlCon.getSchema() + "'";
           }
           if (mysqlCon.getXaStatus() == TxState.TX_STARTED_STATE) { // XA 事务
               //recovery Log
               participantLogEntry[started] = new ParticipantLogEntry(xaTxId, conn.getHost(), 0, conn.getSchema(), ((MySQLConnection) conn).getXaStatus());
               String[] cmds = new String[]{"XA END " + xaTxId, // XA END 命令
                       "XA PREPARE " + xaTxId}; // XA PREPARE 命令
               mysqlCon.execBatchCmd(cmds);
           } else { // 非 XA 事务
               // recovery Log
               participantLogEntry[started] = new ParticipantLogEntry(xaTxId, conn.getHost(), 0, conn.getSchema(), ((MySQLConnection) conn).getXaStatus());
               cmdHandler.sendCommand(session, conn);
           }
           ++started;
       }
   }
   // xa recovery log
   if (session.getXaTXID() != null) {
       CoordinatorLogEntry coordinatorLogEntry = new CoordinatorLogEntry(session.getXaTXID(), false, participantLogEntry);
       inMemoryRepository.put(session.getXaTXID(), coordinatorLogEntry);
       fileRepository.writeCheckpoint(inMemoryRepository.getAllCoordinatorLogEntries());
   }
   if (started < nodeCount) { // TODO 疑问：如何触发
       runningCount.set(started);
       LOGGER.warn("some connection failed to execute " + (nodeCount - started));
       /**
        * assumption: only caused by front-end connection close. <br/>
        * Otherwise, packet must be returned to front-end
        */
       failed.set(true);
   }
}复制代码
  • 向各数据节点发送 XA END + XA PREPARE 指令。举个 变量cmds 例子：
XA END '4cbb18214d0b47adbdb0658598666677','db3';XA PREPARE '4cbb18214d0b47adbdb0658598666677','db3';复制代码
  • 记录协调日志。每条参与者日志状态为 TxState.TX_STARTED_STATE。

第二阶段：发起 COMMIT。

@Override
public void okResponse(byte[] ok, BackendConnection conn) {
   // process the XA Transatcion 2pc commit
   if (conn instanceof MySQLConnection) {
       MySQLConnection mysqlCon = (MySQLConnection) conn;
       switch (mysqlCon.getXaStatus()) {
           case TxState.TX_STARTED_STATE:
               //if there have many SQL execute wait the okResponse,will come to here one by one
               //should be wait all nodes ready ,then send xa commit to all nodes.
               if (mysqlCon.batchCmdFinished()) {
                   String xaTxId = session.getXaTXID();
                   String cmd = "XA COMMIT " + xaTxId + ",'" + mysqlCon.getSchema() + "'";
                   if (LOGGER.isDebugEnabled()) {
                       LOGGER.debug("Start execute the cmd :" + cmd + ",current host:" + mysqlCon.getHost() + ":" + mysqlCon.getPort());
                   }
                   // recovery log
                   CoordinatorLogEntry coordinatorLogEntry = inMemoryRepository.get(xaTxId);
                   for (int i = 0; i < coordinatorLogEntry.participants.length; i++) {
                       LOGGER.debug("[In Memory CoordinatorLogEntry]" + coordinatorLogEntry.participants[i]);
                       if (coordinatorLogEntry.participants[i].resourceName.equals(conn.getSchema())) {
                           coordinatorLogEntry.participants[i].txState = TxState.TX_PREPARED_STATE;
                       }
                   }
                   inMemoryRepository.put(xaTxId, coordinatorLogEntry);
                   fileRepository.writeCheckpoint(inMemoryRepository.getAllCoordinatorLogEntries());
                   // send commit
                   mysqlCon.setXaStatus(TxState.TX_PREPARED_STATE);
                   mysqlCon.execCmd(cmd);
               }
               return;
           case TxState.TX_PREPARED_STATE: {
               // recovery log
               String xaTxId = session.getXaTXID();
               CoordinatorLogEntry coordinatorLogEntry = inMemoryRepository.get(xaTxId);
               for (int i = 0; i < coordinatorLogEntry.participants.length; i++) {
                   if (coordinatorLogEntry.participants[i].resourceName.equals(conn.getSchema())) {
                       coordinatorLogEntry.participants[i].txState = TxState.TX_COMMITED_STATE;
                   }
               }
               inMemoryRepository.put(xaTxId, coordinatorLogEntry);
               fileRepository.writeCheckpoint(inMemoryRepository.getAllCoordinatorLogEntries());
               // XA reset status now
               mysqlCon.setXaStatus(TxState.TX_INITIALIZE_STATE);
               break;
           }
           default:
       }
   }
   // 释放连接
   if (this.cmdHandler.relaseConOnOK()) {
       session.releaseConnection(conn);
   } else {
       session.releaseConnectionIfSafe(conn, LOGGER.isDebugEnabled(), false);
   }
   // 是否所有节点都完成commit，如果是，则返回Client 成功
   if (this.finished()) {
       cmdHandler.okResponse(session, ok);
       if (cmdHandler.isAutoClearSessionCons()) {
           session.clearResources(false);
       }
       /* 1.  事务提交后,xa 事务结束   */
       if (session.getXaTXID() != null) {
           session.setXATXEnabled(false);
       }
       /* 2. preAcStates 为true,事务结束后,需要设置为true。preAcStates 为ac上一个状态    */
       if (session.getSource().isPreAcStates()) {
           session.getSource().setAutocommit(true);
       }
   }
}复制代码
  • mysqlCon.batchCmdFinished() 每个数据节点，第一次返回的是 XA END 成功，第二次返回的是 XA PREPARE。在 XA PREPARE 成功后，记录该数据节点的参与者日志状态为 TxState.TX_PREPARED_STATE。之后，向该数据节点发起 XA COMMIT 命令。
  • XA COMMIT 返回成功后，记录该数据节点的事务参与者日志状态为 TxState.TX_COMMITED_STATE。
  • 当所有数据节点（参与者）都执行完成 XA COMMIT 返回，即 this.finished() == true，返回 MySQL Client XA 事务提交成功。

[x] XA PREPARE 和 XA COMMIT，数据节点可能返回失败，目前暂时没模拟出来，对应方法为 #errorResponse(....)。

3.5 MyCAT 启动回滚 XA事务

MyCAT 启动时，会回滚处于TxState.TX_PREPARED_STATE的 ParticipantLogEntry 对应的数据节点的 XA 事务。代码如下：

// MycatServer.java
private void performXARecoveryLog() {
   // fetch the recovery log
   CoordinatorLogEntry[] coordinatorLogEntries = getCoordinatorLogEntries();
   for (int i = 0; i < coordinatorLogEntries.length; i++) {
       CoordinatorLogEntry coordinatorLogEntry = coordinatorLogEntries[i];
       boolean needRollback = false;
       for (int j = 0; j < coordinatorLogEntry.participants.length; j++) {
           ParticipantLogEntry participantLogEntry = coordinatorLogEntry.participants[j];
           if (participantLogEntry.txState == TxState.TX_PREPARED_STATE) {
               needRollback = true;
               break;
           }
       }
       if (needRollback) {
           for (int j = 0; j < coordinatorLogEntry.participants.length; j++) {
               ParticipantLogEntry participantLogEntry = coordinatorLogEntry.participants[j];
               //XA rollback
               String xacmd = "XA ROLLBACK " + coordinatorLogEntry.id + ';';
               OneRawSQLQueryResultHandler resultHandler = new OneRawSQLQueryResultHandler(new String[0], new XARollbackCallback());
               outloop:
               for (SchemaConfig schema : MycatServer.getInstance().getConfig().getSchemas().values()) {
                   for (TableConfig table : schema.getTables().values()) {
                       for (String dataNode : table.getDataNodes()) {
                           PhysicalDBNode dn = MycatServer.getInstance().getConfig().getDataNodes().get(dataNode);
                           if (dn.getDbPool().getSource().getConfig().getIp().equals(participantLogEntry.uri)
                                   && dn.getDatabase().equals(participantLogEntry.resourceName)) {
                               //XA STATE ROLLBACK
                               participantLogEntry.txState = TxState.TX_ROLLBACKED_STATE;
                               SQLJob sqlJob = new SQLJob(xacmd, dn.getDatabase(), resultHandler, dn.getDbPool().getSource());
                               sqlJob.run();
                               break outloop;
                           }
                       }
                   }
               }
           }
       }
   }
   // init into in memory cached
   for (int i = 0; i < coordinatorLogEntries.length; i++) {
  MultiNodeCoordinator.inMemoryRepository.put(coordinatorLogEntries[i].id, coordinatorLogEntries[i]);
   }
   // discard the recovery log
    MultiNodeCoordinator.fileRepository.writeCheckpoint(MultiNodeCoordinator.inMemoryRepository.getAllCoordinatorLogEntries());
}复制代码

4. MyCAT 实现缺陷

MyCAT 1.6.5 版本实现弱XA事务，相对来说，笔者认为距离实际生产使用存在一些差距。下面罗列可能存在的缺陷，如有错误，麻烦指出。?希望 MyCAT 在分布式事务的实现上，能够越来越给力。

4.1 协调日志写入性能

1、CoordinatorLogEntry、ParticipantLogEntry 在每次写入文件时，是将内存中所有的日志全部重新写入，导致写入性能随着 XA 事务次数的增加，性能会越来越糟糕，导致 XA 事务整体性能会非常差。另外，该方法是同步的，也加大了写入的延迟。

建议：先获得可写入文件的 OFFSET，写入协调日志到文件，内存维护好 XA事务编号 与 OFFSET 的映射关系，从而实现顺序写入 + 并行写入。

2、内存里维护了所有的协调日志，占用内存会越来越大，并且无释放机制。即使重启，协调日志也会重新加载到内存。

建议：已完全回滚或者提交的协调日志不放入内存。另外有文件存储好 XA事务编号 与 OFFSET 的映射关系。

3、协调日志只写入单个文件。

建议：分拆协调日志文件。

PS：有兴趣的同学可以看下 RocketMQ 对 CommitLog 的存储，性能上很赞！

4.2 数据节点未全部 PREPARE 就进行 COMMIT

XA 事务定义，需要等待所有参与者全部 XA PREPARE 成功完成后发起 XA COMMIT。目前 MyCAT 是某个数据节点 XA PREPARE 完成后立即进行 XA COMMIT。比如说：第一个数据节点提交了 XA END;XA PREPARE 时，第二个数据节在进行 XA END;XA PREAPRE; 前挂了，第一个节点依然会 XA COMMIT 成功。

建议：按照严格的 XA 事务定义。

4.3 MyCAT 启动回滚 PREPARE 的 XA事务

1、MyCAT 启动时，回滚所有的 PREPARE 的 XA 事务，可能某个 XA 事务，部分 COMMIT，部分 PREPARE。此时直接回滚，会导致数据不一致。

建议：当判断到某个 XA 事务存在 PREPARE 的参与者，同时判断该 XA 事务里其他参与者的事务状态以及数据节点里 XA 事务状态，比如参与者为 MySQL时，可以使用 XA RECOVER 查询处于 PREPARE 所有的 XA 事务。

2、回滚 PREPARE 是异步进行的，在未进行完成时已经设置文件里回滚成功。如果异步过程中失败，会导致 XA 事务状态不一致。

建议：回调成功后，更新该 XA 事务状态。

4.4 单节点事务未记录协调日志

该情况较为极端。发起 XA PREPARE完后，MyCAT 挂了。重启后，该 XA 事务在 MyCAT 里就“消失“了，参与者的该 XA 事务一直处于 PREPARE 状态。从理论上来说，需要回滚该 XA 事务。

建议：记录协调日志。

4.5 XA COMMIT 部分节点挂了重新恢复后，未进一步处理

当一部分节点 XA COMMIT 完成，另外一部分此时挂了。在管理员重启挂掉的节点，其对应的 XA 事务未进一步处理，导致数据不一致。

建议：?木有建议。也很好奇，如果是这样的情况，如何处理较为合适。如有大大知道，烦请告知下。

5. 彩蛋

例行“彩蛋”？

weixin_34133829
关注
MyCat分布式事务支持
weixin_34185512的博客
05-21 802
社区&文档 官网 Mycat权威指南PDF 分布式事务支持 阅读 Mycat权威指南 的 高级进阶篇-高可用与集群 和 高级进阶篇-事务支持 、博文及对应源码可知： Mycat可集群部署支持高可用，且基于HAProxy做软负载（Mycat定义为无状态中间件，可轻松集群） 单例Mycat支持弱XA事务（一旦应用发起 comit 指令，无法保证所有分片都成 功），无Transaction ...
Java 源码解析最全合集
热门推荐
芋艿V
01-08 1万+
个人博客
Mycat 分布式事务的实现
01-11 579
引言：Mycat已经成为了一个强大的开源分布式数据库中间件产品。面对企业应用的海量数据事务处理，是目前最好的开源解决方案。但是如果想让多台机器中的数据保存一致，比较常规的解决方法是引入“协调者”来统一调度...
数据库中间件 MyCAT 源码分析：【单库单表】插入
weixin_33747129的博客
05-29 125
2019独角兽企业重金招聘Python工程师标准>>> ...
MyCAT XA分布式事务
weixin_34253539的博客
05-02 709
为什么80%的码农都做不了架构师？>>> ...
Mycat事务
小城我家
09-21 1709
Mycat事务 Mycat 数据库事务 Mycat 目前没有出来跨分片的事务强一致性支持，单库内部可以保证事务的完整性，如果跨库事务，在执行的时候任何分片出错，可以保证所有分片回滚，但是一旦应用发起 commit 指令，无法保证所有分片都成功，考虑到某个分片挂的可能性不大所以称为弱 XA XA 事务使用 Mycat 从 1.6.5 版本开始支持标准 XA 分布式事务，考虑到 MySQL 5.7 之前版本XA有bug，所以推荐最 佳搭配 XA 功能使用 MySQL 5.7 版本。 Mycat 实现 XA 标准
图灵最强诸葛老师最新分享：分布式服务框架原理与实践.pdf篇
m0_67322837的博客
04-02 1273
如何实现高容量大并发数据库服务 | 数据库分布式架构设计 ？ 一为什么要做分布式数据库架构改造？ 云计算大数据时代，传统的数据库架构已经无法支撑企业高容量的数据增长，满足高并发的业务需求。对企业数据库进行分布式架构设计，打破了数据库资源不够用的天花板的同时，还能根据企业业务发展状况，随时平滑扩容。 二分布式数据库架构改造，如何做？ 数据库分布式改造要遵循“循序渐进”的拆分原则 拆分方式有垂直拆分和水平拆分两种，选择拆分方式要根据企业自身业务发展需要。 一般来说，是先做垂直拆分，再...
Java学习专栏！全网最牛！
weixin_70730532的博客
08-12 2709
00254:《SpringCloud Alibaba微服务实战十四 - SpringCloud Gateway集成Oauth2.0》00242:《SpringCloud Alibaba微服务实战二十四 - SpringCloud Gateway的全局异常处理》00251:《SpringCloud Alibaba微服务实战十五 - SpringCloud 容器化部署》00248:《SpringCloud Alibaba微服务实战十八 - Oauth2.0 自定义授权模式》00184:《TCP网络那点破事！..
微服务架构设计
河湾
05-09 3542
一、微服务概述 1、什么是微服务？ 微服务就是一些可独立运行、可协同工作的小的服务。 从概念中我们可以提取三个关键词：可独立运行、可协同工作、小。这三个词高度概括了微服务的核心特性。下面我们就对这三个词作详细解释。 可独立运行 微服务是一个个可以独立开发、独立部署、独立运行的系统或者进程。 可协同工作 采用了微服务架构后，整个系统被拆分成多个微服务，这些服务之间往往不是完全独立的...
Java知识点概览
qq_48403611的博客
08-03 3493
java后端开发常见面试题总结
Mycat分布式事务的实现
01-29
随着并发量、数据量越来越大及业务已经细化到不能再按照业务划分，我们不得不使用分布式数据库提高系统的性能。在分布式系统中，各个节点在物理上都是相对独立的，每个节点上的数据操作都可以满足 ACID。但是，各独立节点之间无法知道其他节点事务的执行情况，如果想让多台机器中的数据保存一致，就必须保证所有节点上的数据操作要么全部执行成功，要么全部不执行，比较常规的解决方法是引入“协调者”来统一调度所有节点的执行。
MyCAT 源码分析 —— XA分布式事务
weixin_42073629的博客
06-11 376
1. 概述 数据库拆分后，业务上会碰到需要分布式事务的场景。MyCAT 基于 XA 实现分布式事务。国内目前另外一款很火的数据库中间件 Sharding-JDBC 准备基于 TCC 实现分布式事务。 本文内容分成三部分： XA 概念简述 MyCAT 代码如何实现 XA MyCAT 在实现 XA 存在的一些缺陷 2. XA 概念 X/Open 组织（即现在的 Open Group ）定义了分布式事务处理模型。 X/Open DTP 模型（ 1994 ）包括： 应用程序（AP） 事务管...
Mycat-序列和事务
qq_27685683的博客
03-16 387
111
MyCat的XA事务研究及字符集问题
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
08-28 153
MyCat的XA事务研究及字符集问题
mycat学习(一)
玛瑙小龙虾的博客
05-02 734
历史 Mycat是基于开源cobar演变而来，我们对cobar的代码进行了彻底的重构，使用NIO重构了网络模块，并且优化了Buffer内核，增强了聚合，Join等基本特性，同时兼容绝大多数数据库成为通用的数据库中间件。1.4 版本以后 完全的脱离基本cobar内核，结合Mycat集群管理、自动扩容、智能优化，成为高性能的中间件。我们致力于开发高性能数据库中间而努力。永不收费，永不闭源，持续推动开源社区的发展 特性 支持SQL92标准 遵守Mysql原生协议，跨语言，跨平台，跨数据库的通用中间件代理。
快速学习-Mycat事务支持
逍遥云恋
02-23 1377
第 3 章 事务支持 3.1 Mycat 里的数据库事务 Mycat 目前没有出来跨分片的事务强一致性支持，目前单库内部可以保证事务的完整性，如果跨库事务，在执行的时候任何分片出错，可以保证所有分片回滚，但是一旦应用发起 commit 指令，无法保证所有分片都成功考虑到某个分片挂的可能性不大所以称为弱 xa。 3.2 XA 事务原理 分布式事务处理（ Distributed Transaction Processing ， DTP ）指一个程序或程序段，在一个或多个资源如数据库或文件上为完成某些功能的执行过
XA和MyCat分布式事务问题
Jaycrees的博客
04-01 769
1.XA的两阶段提交 第一阶段： 第二阶段： 2.特点 保证数据的强一致性 commit阶段出现问题，事务出现不一致，需人工处理 效率低下，性能与本地事务相差10倍 Mysql5.7及以上均支持XA协议 Mysql Connector/J 5.0以上支持XA协议 Java系统中，数据源采用Atomikos 2.mycat分布式事务 1.将mycat的配置文件server.xml修改： 分布...
【分布式事务 XA模式】MySQL XA模式详解
最新发布
面向生活编程
02-24 1847
MySQL 的 5.0.3 版本开始支持XA分布式事务，并且只有innoDB存储引擎支持XA事务。
Mycat数据库中间件深度解析：分布式事务与集群配置
Mycat是一个开源的分布式数据库中间件，主要用于解决大数据量场景下的数据库扩展问题。它支持MySQL协议，能够实现数据库的分库分表，同时处理分布式事务，是构建大规模数据库集群的重要工具。 在《Mycat权威指南》...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值