阿里开源分布式事务中间件fescar源码分析

最新推荐文章于 2024-08-06 02:13:14 发布
最新推荐文章于 2024-08-06 02:13:14 发布
阅读量662 收藏
点赞数
分类专栏： 分布式事务
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43322587/article/details/86721032
版权

阿里开源分布式事务中间件fescar源码分析

fescar架构及原理

fescar开源后，网络上有不少讲解其原理的文章，这里就引入其中一篇，个人认为也建的比较透彻。文章地址：
《阿里巴巴开源分布式事务解决方案 Fescar》

这里引入上面文章的部分图片及内容， 架构及说明：
架构组成

  • Transaction Coordinator (TC)： 事务协调器，维护全局事务的运行状态，负责协调并驱动全局事务的提交或回滚。
  • Transaction Manager ™： 控制全局事务的边界，负责开启一个全局事务，并最终发起全局提交或全局回滚的决议。
  • Resource Manager (RM)：
    控制分支事务，负责分支注册、状态汇报，并接收事务协调器的指令，驱动分支（本地）事务的提交和回滚。

一个典型的分布式事务过程：

  1. TM 向 TC 申请开启一个全局事务，全局事务创建成功并生成一个全局唯一的 XID。
  2. XID 在微服务调用链路的上下文中传播。
  3. RM 向 TC 注册分支事务，将其纳入 XID 对应全局事务的管辖。
  4. TM 向 TC 发起针对 XID 的全局提交或回滚决议。
  5. TC 调度 XID 下管辖的全部分支事务完成提交或回滚请求。

好，具体架构及过程可以详细读原文， 这里对应架构组成，分析源码。
源码主要组成
三个系统，fescar server， 主事务的server， 子事务的server， 系统之间通过netty 完成rpc调用

主事务的server：

这里的代码实现跟本地的事务的事项非常匹配， 通过是 transaction来开启事务，通过transactionManager真正实现事务的逻辑。而使用模板transactionTemplate方便事务的使用。
GlobalTransactiona注解来设置一个接口需要开启分布式事务， 通过AOP， 对注解方法做切面，切入事务代码，加入事务处理。 GlobalTransactionalInterceptor 主要实现：

@Override
    public Object invoke(final MethodInvocation methodInvocation) throws Throwable {
        final GlobalTransactional anno = getAnnotation(methodInvocation.getMethod());
        if (anno != null) {
            try {
                return transactionalTemplate.execute(new TransactionalExecutor() {
                    @Override
                    public Object execute() throws Throwable {
                        return methodInvocation.proceed();
                    }

                    @Override
                    public int timeout() {
                        return anno.timeoutMills();
                    }

                    @Override
                    public String name() {
                        if (anno.name() != null) {
                            return anno.name();
                        }
                        return formatMethod(methodInvocation.getMethod());
                    }
                });
            } catch (TransactionalExecutor.ExecutionException e) {
                TransactionalExecutor.Code code = e.getCode();
                switch (code) {
                    case RollbackDone:
                        throw e.getOriginalException();
                    case BeginFailure:
                        failureHandler.onBeginFailure(e.getTransaction(), e.getCause());
                        throw e.getCause();
                    case CommitFailure:
                        failureHandler.onCommitFailure(e.getTransaction(), e.getCause());
                        throw e.getCause();
                    case RollbackFailure:
                        failureHandler.onRollbackFailure(e.getTransaction(), e.getCause());
                        throw e.getCause();
                    default:
                        throw new ShouldNeverHappenException("Unknown TransactionalExecutor.Code: " + code);

                }
            }

        }
        return methodInvocation.proceed();
    }

可以看到Interceptor主要通过template来加入事务， 而template的代码：

// 1. get or create a transaction
        GlobalTransaction tx = GlobalTransactionContext.getCurrentOrCreate();

        // 2. begin transaction
        try {
            tx.begin(business.timeout(), business.name());

        } catch (TransactionException txe) {
            throw new TransactionalExecutor.ExecutionException(tx, txe,
                TransactionalExecutor.Code.BeginFailure);

        }

        Object rs = null;
        try {

            // Do Your Business
            rs = business.execute();

        } catch (Throwable ex) {

            // 3. any business exception, rollback.
            try {
                tx.rollback();

                // 3.1 Successfully rolled back
                throw new TransactionalExecutor.ExecutionException(tx, TransactionalExecutor.Code.RollbackDone, ex);

            } catch (TransactionException txe) {
                // 3.2 Failed to rollback
                throw new TransactionalExecutor.ExecutionException(tx, txe,
                    TransactionalExecutor.Code.RollbackFailure, ex);

            }

        }

        // 4. everything is fine, commit.
        try {
            tx.commit();

        } catch (TransactionException txe) {
            // 4.1 Failed to commit
            throw new TransactionalExecutor.ExecutionException(tx, txe,
                TransactionalExecutor.Code.CommitFailure);

        }
        return rs;
    }

TransactionalTemplate跟本地事务模板几乎没什么区别， 而差别就是GlobalTransaction引用的TransactionManager上， 默认的实现 DefaultTransactionManager：

@Override
    public String begin(String applicationId, String transactionServiceGroup, String name, int timeout) throws TransactionException {
        GlobalBeginRequest request = new GlobalBeginRequest();
        request.setTransactionName(name);
        request.setTimeout(timeout);
        GlobalBeginResponse response = (GlobalBeginResponse) syncCall(request);
        return response.getXid();
    }

    @Override
    public GlobalStatus commit(String xid) throws TransactionException {
        long txId = XID.getTransactionId(xid);
        GlobalCommitRequest globalCommit = new GlobalCommitRequest();
        globalCommit.setTransactionId(txId);
        GlobalCommitResponse response = (GlobalCommitResponse) syncCall(globalCommit);
        return response.getGlobalStatus();
    }

    @Override
    public GlobalStatus rollback(String xid) throws TransactionException {
        long txId = XID.getTransactionId(xid);
        GlobalRollbackRequest globalRollback = new GlobalRollbackRequest();
        globalRollback.setTransactionId(txId);
        GlobalRollbackResponse response = (GlobalRollbackResponse) syncCall(globalRollback);
        return response.getGlobalStatus();
    }

可以看到，所有实现都是一个rpc的请求， 而这个请求都是发送给fescar server。

fescar server

fescar server主要实现
分布事务协调的服务里面，最主要就两个类DefaultCoordinator， DefaultCore， 而Coordinator依赖Core来实现真正的业务逻辑， DefaultCoordinator处理来自主事务和子事务的协调处理。

@Override
    public String begin(String applicationId, String transactionServiceGroup, String name, int timeout) throws TransactionException {
        GlobalSession session = GlobalSession.createGlobalSession(
                applicationId, transactionServiceGroup, name, timeout);
        session.addSessionLifecycleListener(SessionHolder.getRootSessionManager());

        session.begin();

        return XID.generateXID(session.getTransactionId());
    }
    
@Override
    protected void doGlobalBegin(GlobalBeginRequest request, GlobalBeginResponse response, RpcContext rpcContext) throws TransactionException {
        response.setXid(core.begin(rpcContext.getApplicationId(), rpcContext.getTransactionServiceGroup(), request.getTransactionName(), request.getTimeout()));
    }

    @Override
    protected void doGlobalCommit(GlobalCommitRequest request, GlobalCommitResponse response, RpcContext rpcContext) throws TransactionException {
        response.setGlobalStatus(core.commit(XID.generateXID(request.getTransactionId())));

    }

    @Override
    protected void doGlobalRollback(GlobalRollbackRequest request, GlobalRollbackResponse response, RpcContext rpcContext) throws TransactionException {
        response.setGlobalStatus(core.rollback(XID.generateXID(request.getTransactionId())));

    }

    @Override
    protected void doGlobalStatus(GlobalStatusRequest request, GlobalStatusResponse response, RpcContext rpcContext) throws TransactionException {
        response.setGlobalStatus(core.getStatus(XID.generateXID(request.getTransactionId())));
    }

    @Override
    protected void doBranchRegister(BranchRegisterRequest request, BranchRegisterResponse response, RpcContext rpcContext) throws TransactionException {
        response.setTransactionId(request.getTransactionId());
        response.setBranchId(core.branchRegister(request.getBranchType(), request.getResourceId(), rpcContext.getClientId(),
                XID.generateXID(request.getTransactionId()), request.getLockKey()));

    }

可以看到实现都依赖Core。 这里再看DefaultCore的实现：

@Override
    public GlobalStatus commit(String xid) throws TransactionException {
        GlobalSession globalSession = SessionHolder.findGlobalSession(XID.getTransactionId(xid));
        if (globalSession == null) {
            return GlobalStatus.Finished;
        }
        GlobalStatus status = globalSession.getStatus();

        globalSession.closeAndClean(); // Highlight: Firstly, close the session, then no more branch can be registered.

        if (status == GlobalStatus.Begin) {
            if (globalSession.canBeCommittedAsync()) {
                asyncCommit(globalSession);
            } else {
                doGlobalCommit(globalSession, false);
            }

        }
        return globalSession.getStatus();
    }

    @Override
    public void doGlobalCommit(GlobalSession globalSession, boolean retrying) throws TransactionException {
        for (BranchSession branchSession : globalSession.getSortedBranches()) {
            BranchStatus currentStatus = branchSession.getStatus();
            if (currentStatus == BranchStatus.PhaseOne_Failed) {
                continue;
            }
            try {
                BranchStatus branchStatus = resourceManagerInbound.branchCommit(XID.generateXID(branchSession.getTransactionId()), branchSession.getBranchId(),
                        branchSession.getResourceId(), branchSession.getApplicationData());

                switch (branchStatus) {
                    case PhaseTwo_Committed:
                        globalSession.removeBranch(branchSession);
                        continue;
                    case PhaseTwo_CommitFailed_Unretriable:
                        if (globalSession.canBeCommittedAsync()) {
                            LOGGER.error("By [" + branchStatus + "], failed to commit branch " + branchSession);
                            continue;
                        } else {
                            globalSession.changeStatus(GlobalStatus.CommitFailed);
                            globalSession.end();
                            LOGGER.error("Finally, failed to commit global[" + globalSession.getTransactionId() + "] since branch[" + branchSession.getBranchId() + "] commit failed");
                            return;
                        }
                    default:
                        if (!retrying) {
                            queueToRetryCommit(globalSession);
                            return;
                        }
                        if (globalSession.canBeCommittedAsync()) {
                            LOGGER.error("By [" + branchStatus + "], failed to commit branch " + branchSession);
                            continue;
                        } else {
                            LOGGER.error("Failed to commit global[" + globalSession.getTransactionId() + "] since branch[" + branchSession.getBranchId() + "] commit failed, will retry later.");
                            return;
                        }

                }

            } catch (Exception ex) {
                LOGGER.info("Exception committing branch " + branchSession, ex);
                if (!retrying) {
                    queueToRetryCommit(globalSession);
                    if (ex instanceof TransactionException) {
                        throw (TransactionException) ex;
                    } else {
                        throw new TransactionException(ex);
                    }
                }

            }

        }
        if (globalSession.hasBranch()) {
            LOGGER.info("Global[" + globalSession.getTransactionId() + "] committing is NOT done.");
            return;
        }
        globalSession.changeStatus(GlobalStatus.Committed);
        globalSession.end();
        LOGGER.info("Global[" + globalSession.getTransactionId() + "] committing is successfully done.");
    }

@Override
    public GlobalStatus rollback(String xid) throws TransactionException {
        GlobalSession globalSession = SessionHolder.findGlobalSession(XID.getTransactionId(xid));
        if (globalSession == null) {
            return GlobalStatus.Finished;
        }
        GlobalStatus status = globalSession.getStatus();

        globalSession.close(); // Highlight: Firstly, close the session, then no more branch can be registered.

        if (status == GlobalStatus.Begin) {
            globalSession.changeStatus(GlobalStatus.Rollbacking);
            doGlobalRollback(globalSession, false);

        }
        return globalSession.getStatus();
    }

    @Override
    public void doGlobalRollback(GlobalSession globalSession, boolean retrying) throws TransactionException {
        for (BranchSession branchSession : globalSession.getReverseSortedBranches()) {
            BranchStatus currentBranchStatus = branchSession.getStatus();
            if (currentBranchStatus == BranchStatus.PhaseOne_Failed) {
                continue;
            }
            try {
                BranchStatus branchStatus = resourceManagerInbound.branchRollback(XID.generateXID(branchSession.getTransactionId()), branchSession.getBranchId(),
                        branchSession.getResourceId(), branchSession.getApplicationData());

                switch (branchStatus) {
                    case PhaseTwo_Rollbacked:
                        globalSession.removeBranch(branchSession);
                        LOGGER.error("Successfully rolled back branch " + branchSession);
                        continue;
                    case PhaseTwo_RollbackFailed_Unretriable:
                        GlobalStatus currentStatus = globalSession.getStatus();
                        if (currentStatus.name().startsWith("Timeout")) {
                            globalSession.changeStatus(GlobalStatus.TimeoutRollbackFailed);
                        } else {
                            globalSession.changeStatus(GlobalStatus.RollbackFailed);
                        }
                        globalSession.end();
                        LOGGER.error("Failed to rollback global[" + globalSession.getTransactionId() + "] since branch[" + branchSession.getBranchId() + "] rollback failed");
                        return;
                    default:
                        LOGGER.info("Failed to rollback branch " + branchSession);
                        if (!retrying) {
                            queueToRetryRollback(globalSession);
                        }
                        return;

                }
            } catch (Exception ex) {
                LOGGER.info("Exception rollbacking branch " + branchSession, ex);
                if (!retrying) {
                    queueToRetryRollback(globalSession);
                    if (ex instanceof TransactionException) {
                        throw (TransactionException) ex;
                    } else {
                        throw new TransactionException(ex);
                    }
                }

            }

        }
        GlobalStatus currentStatus = globalSession.getStatus();
        if (currentStatus.name().startsWith("Timeout")) {
            globalSession.changeStatus(GlobalStatus.TimeoutRollbacked);
        } else {
            globalSession.changeStatus(GlobalStatus.Rollbacked);
        }
        globalSession.end();
    }

可以看到开启一个事务，就是创建一个session，并返回xid， xid必须在分布式调用中传递。
而commit和rollback都需要遍历分支事务，通过netty的rpc messge通知子事务的提交或者回滚。

子事务的server

子事务的实现
在fescar原理讲解知道， fescar对XA的改进是，它的二段提交，子事务只有在第一段才锁库，只要是正常完成，第二段是不需要锁库，如果需要回滚，则根据记录的undo log来做回退处理。
这样基于DB做操作记录来完成DB回退，只需要在业务失败时候回退，减少锁库的时间，而比起实现正向和反向的幂等接口，这对开发来说更简单。

因此重点看看子事务DataSource的代理类如何实现日记记录，还有AbstractDMLBaseExecutor及UndoLogManager实现DB回滚，代码逻辑：

DataSourceProxy， ConnectionProxy：DataSourceProxy只是通过ConnectionProxy实现日志记录， 重点看ConnectionProxy里的实现逻辑

public void prepareUndoLog(SQLType sqlType, String tableName, TableRecords beforeImage, TableRecords afterImage) throws SQLException {
        TableRecords lockKeyRecords = afterImage;
        if (sqlType == SQLType.DELETE) {
            lockKeyRecords = beforeImage;
        }
        String lockKeys = buildLockKey(lockKeyRecords);
        context.appendLockKey(lockKeys);
        SQLUndoLog sqlUndoLog = buildUndoItem(sqlType, tableName, beforeImage, afterImage);
        context.appendUndoItem(sqlUndoLog);
    }

看到ConnectionProxy的undo日志只是被放入上下文，而在这之前undo日志已经整理并入库，这是在AbstractDMLBaseExecutor 实现：

protected T executeAutoCommitFalse(Object[] args) throws Throwable {
        TableRecords beforeImage = beforeImage();
        T result = statementCallback.execute(statementProxy.getTargetStatement(), args);
        TableRecords afterImage = afterImage(beforeImage);
        statementProxy.getConnectionProxy().prepareUndoLog(sqlRecognizer.getSQLType(), sqlRecognizer.getTableName(), beforeImage, afterImage);
        return result;
    }

    protected T executeAutoCommitTrue(Object[] args) throws Throwable {
        T result = null;
        AbstractConnectionProxy connectionProxy = statementProxy.getConnectionProxy();
        LockRetryController lockRetryController = new LockRetryController();
        try {
            connectionProxy.setAutoCommit(false);
            while (true) {
                try {
                    result = executeAutoCommitFalse(args);
                    connectionProxy.commit();
                    break;
                } catch (LockConflictException lockConflict) {
                    lockRetryController.sleep(lockConflict);
                }
            }

        } finally {
            connectionProxy.setAutoCommit(true);

        }
        return result;
    }

从executeAutoCommitFalse方法看到只是业务sql前先整理beforeImage，执行业务sql，在整理afterImage。而他是怎样整理before和after的镜像，居然可以看对应的实现类，这里就不详细贴上来了。
在这里插入图片描述
在正常情况提交不需要做额外的事情，本地事务已经提交了。 而如果回滚则找到undo日志执行回滚。
DataSourceManager

@Override
    public BranchStatus branchCommit(String xid, long branchId, String resourceId, String applicationData) throws TransactionException {
        return asyncWorker.branchCommit(xid, branchId, resourceId, applicationData);
    }

    @Override
    public BranchStatus branchRollback(String xid, long branchId, String resourceId, String applicationData) throws TransactionException {
        DataSourceProxy dataSourceProxy = get(resourceId);
        if (dataSourceProxy == null) {
            throw new ShouldNeverHappenException();
        }
        try {
            UndoLogManager.undo(dataSourceProxy, xid, branchId);
        } catch (TransactionException te) {
            if (te.getCode() == TransactionExceptionCode.BranchRollbackFailed_Unretriable) {
                return BranchStatus.PhaseTwo_RollbackFailed_Unretriable;
            } else {
                return BranchStatus.PhaseTwo_RollbackFailed_Retriable;
            }
        }
        return BranchStatus.PhaseTwo_Rollbacked;

    }

UndoLogManager的undo实现：

public static void undo(DataSourceProxy dataSourceProxy, String xid, long branchId) throws TransactionException {
        assertDbSupport(dataSourceProxy.getTargetDataSource().getDbType());

        Connection conn = null;
        ResultSet rs = null;
        PreparedStatement selectPST = null;
        try {
            conn = dataSourceProxy.getPlainConnection();

            // The entire undo process should run in a local transaction.
            conn.setAutoCommit(false);

            // Find UNDO LOG
            selectPST = conn.prepareStatement(SELECT_UNDO_LOG_SQL);
            selectPST.setLong(1, branchId);
            selectPST.setString(2, xid);
            rs = selectPST.executeQuery();

            while (rs.next()) {
                Blob b = rs.getBlob("rollback_info");
                String rollbackInfo = StringUtils.blob2string(b);
                BranchUndoLog branchUndoLog = UndoLogParserFactory.getInstance().decode(rollbackInfo);

                for (SQLUndoLog sqlUndoLog : branchUndoLog.getSqlUndoLogs()) {
                    TableMeta tableMeta = TableMetaCache.getTableMeta(dataSourceProxy, sqlUndoLog.getTableName());
                    sqlUndoLog.setTableMeta(tableMeta);
                    AbstractUndoExecutor undoExecutor = UndoExecutorFactory.getUndoExecutor(dataSourceProxy.getDbType(), sqlUndoLog);
                    undoExecutor.executeOn(conn);
                }

            }
            deleteUndoLog(xid, branchId, conn);

            conn.commit();

        } catch (Throwable e) {
            if (conn != null) {
                try {
                    conn.rollback();
                } catch (SQLException rollbackEx) {
                    LOGGER.warn("Failed to close JDBC resource while undo ... ", rollbackEx);
                }
            }
            throw new TransactionException(BranchRollbackFailed_Retriable, String.format("%s/%s", branchId, xid), e);

        } finally {
            try {
                if (rs != null) {
                    rs.close();
                }
                if (selectPST != null) {
                    selectPST.close();
                }
                if (conn != null) {
                    conn.close();
                }
            } catch (SQLException closeEx) {
                LOGGER.warn("Failed to close JDBC resource while undo ... ", closeEx);
            }
        }

    }

至此从全局事务到分支事务的begin，commit， rollback已经完成， 下面在看看其中涉及的一些公共部分，netty message rpc。

netty message rpc

虽然fescar是一套CS的request和response模式， 但也可以看做是一个基于message的rpc， 从rpc的几个方面来解析源码。 也可以从中了解rpc架构基本组成：

协议与网络

这通过netty做网络通信，基于socket， 而协议定义了一个rpcmessage，里面分成header和body， 代码如下：

public class RpcMessage {

    private static AtomicLong NEXT_ID = new AtomicLong(0);
    public static  long getNextMessageId() {
        return NEXT_ID.incrementAndGet();
    }
    private long id;
    private boolean isAsync;
    private boolean isRequest;
    private boolean isHeartbeat;
    private Object body;

而body则是不同接口的request对象， 从协调server通知分支事务提交的分析
分支提交的rpc消息发送
而sendSynRequest的代码处理：

private Object sendAsyncRequest(String address, Channel channel, Object msg, long timeout)
        throws TimeoutException {
        if (channel == null) {
            LOGGER.warn("sendAsyncRequestWithResponse nothing, caused by null channel.");
            return null;
        }
        final RpcMessage rpcMessage = new RpcMessage();
        rpcMessage.setId(RpcMessage.getNextMessageId());
        rpcMessage.setAsync(false);
        rpcMessage.setHeartbeat(false);
        rpcMessage.setRequest(true);
        rpcMessage.setBody(msg);

        final MessageFuture messageFuture = new MessageFuture();
        messageFuture.setRequestMessage(rpcMessage);
        messageFuture.setTimeout(timeout);
        futures.put(rpcMessage.getId(), messageFuture);

        if (address != null) {
            ConcurrentHashMap<String, BlockingQueue<RpcMessage>> map = basketMap;
            BlockingQueue<RpcMessage> basket = map.get(address);
            if (basket == null) {
                map.putIfAbsent(address, new LinkedBlockingQueue<RpcMessage>());
                basket = map.get(address);
            }
            basket.offer(rpcMessage);
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("offer message: " + rpcMessage.getBody());
            }
            if (!isSending) {
                synchronized (mergeLock) {
                    mergeLock.notifyAll();
                }
            }
        } else {
            ChannelFuture future;
            channelWriteableCheck(channel, msg);
            future = channel.writeAndFlush(rpcMessage);
            future.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture future) {
                    if (!future.isSuccess()) {
                        MessageFuture messageFuture = futures.remove(rpcMessage.getId());
                        if (messageFuture != null) {
                            messageFuture.setResultMessage(future.cause());
                        }
                        destroyChannel(future.channel());
                    }
                }
            });
        }
        if (timeout > 0) {
            try {
                return messageFuture.get(timeout, TimeUnit.MILLISECONDS);
            } catch (Exception exx) {
                LOGGER.error("wait response error:" + exx.getMessage() + ",ip:" + address + ",request:" + msg);
                if (exx instanceof TimeoutException) {
                    throw (TimeoutException)exx;
                } else {
                    throw new RuntimeException(exx);
                }
            }
        } else {
            return null;
        }
    }

可以看到接口的request放入body后再分装成MessageFuture（增加超时信息），然后rpc msg通过netty的ChannelFuture发送出去。

序列化

这里序列化用的java的序列化接口，部分request和reposne重写encode和decode来控制，例如AbstractBranchEndRequest

@Override
    public byte[] encode() {
        byte[] applicationDataBytes = null;
        if (this.applicationData != null) {
            applicationDataBytes = applicationData.getBytes(UTF8);
            if (applicationDataBytes.length > 512) {
                byteBuffer = ByteBuffer.allocate(applicationDataBytes.length + 1024);
            }
        }

        // 1. xid
        if (this.xid != null) {
            byte[] bs = xid.getBytes(UTF8);
            byteBuffer.putShort((short) bs.length);
            if (bs.length > 0) {
                byteBuffer.put(bs);
            }
        } else {
            byteBuffer.putShort((short) 0);
        }
        // 2. Branch Id
        byteBuffer.putLong(this.branchId);
        // 3. Branch Type
        byteBuffer.put((byte) this.branchType.ordinal());
        // 4. Resource Id
        if (this.resourceId != null) {
            byte[] bs = resourceId.getBytes(UTF8);
            byteBuffer.putShort((short) bs.length);
            if (bs.length > 0) {
                byteBuffer.put(bs);
            }
        } else {
            byteBuffer.putShort((short) 0);
        }

        // 5. Application Data
        if (this.applicationData != null) {
            byteBuffer.putInt(applicationDataBytes.length);
            if (applicationDataBytes.length > 0) {
                byteBuffer.put(applicationDataBytes);
            }
        } else {
            byteBuffer.putInt(0);
        }

        byteBuffer.flip();
        byte[] content = new byte[byteBuffer.limit()];
        byteBuffer.get(content);
        return content;
    }

    @Override
    public boolean decode(ByteBuf in) {
        int leftLen = in.readableBytes();
        int read = 0;
        int xidLen = in.readShort();
        if (xidLen > 0) {
            if (leftLen < xidLen) {
                return false;
            }
            byte[] bs = new byte[xidLen];
            in.readBytes(bs);
            setXid(new String(bs, UTF8));
            leftLen -= xidLen;
        }
        this.branchId = in.readLong();
        leftLen -= 8;
        this.branchType = BranchType.get(in.readByte());
        leftLen --;

        int resourceIdLen = in.readShort();
        if (resourceIdLen > 0) {
            if (leftLen < resourceIdLen) {
                return false;
            }
            byte[] bs = new byte[resourceIdLen];
            in.readBytes(bs);
            setResourceId(new String(bs, UTF8));
            leftLen -= resourceIdLen;
        }

        int applicationDataLen = in.readShort();
        if (applicationDataLen > 0) {
            if (leftLen < applicationDataLen) {
                return false;
            }
            byte[] bs = new byte[applicationDataLen];
            in.readBytes(bs);
            setApplicationData(new String(bs, UTF8));
            leftLen -= applicationDataLen;
        }

        return true;
    }

业务方法的映射

网络通信和message的序列化已经完备， 还剩一个就是message request映射到业务方法并组成reponse返回。 从server收到消息看，是DefaultServerMessageListenerImpl
在这里插入图片描述
这里的handler就负责映射业务的处理，这里handler也指向DefaultCoordinator的onRequest

@Override
    public AbstractResultMessage onRequest(AbstractMessage request, RpcContext context) {
        if (!(request instanceof AbstractTransactionRequestToTC)) {
            throw new IllegalArgumentException();
        }
        AbstractTransactionRequestToTC transactionRequest = (AbstractTransactionRequestToTC) request;
        transactionRequest.setTCInboundHandler(this);

        return transactionRequest.handle(context);
    }

可以看到最终的业务处理都放在request的handler方法完成。 我们拿其中一个request看看
例如BranchRollbackRequest，继承AbstractTransactionRequestToRM，而request的handler方法执行类是RMInboundHandler来执行， 可以看到

@Override
    public BranchCommitResponse handle(BranchCommitRequest request) {
        BranchCommitResponse response = new BranchCommitResponse();
        exceptionHandleTemplate(new Callback<BranchCommitRequest, BranchCommitResponse>() {
            @Override
            public void execute(BranchCommitRequest request, BranchCommitResponse response) throws TransactionException {
                doBranchCommit(request, response);
            }
        }, request, response);
        return response;
    }

至此，整个基于message request，response的rpc就完成了， 当然真正的rpc还有更多模块，例如服务的自注册与发行， 服务监控， 服务调度等。

文章到此结束，不想文章太长，主要分析fescar主要功能原理相关的代码， 而fescar还有其他未有提及。

蠢物
关注
专栏目录
基于Java+maat的分布式事务中间件源码.zip
02-21
基于Java+maat的分布式事务中间件源码.zip maat是一个分布式事务中间件,实现了基于可靠消息的最终一致性事务控制.其可靠消息服务通过独立消息服务方案实现,与业务系统耦合低,目前支持的MQ有RocketMQ。
Seata AT异常流程场景梳理
我神级欧文的博客
06-29 547
此时回滚重试定时器就能查询出该全局事务，然后对该全局事务下的所有分支事务进行回滚，如果回滚失败，就把状态改为TimeoutRollbackRetrying，然后继续重试回滚，在完成回滚之前全局锁不会被释放。分支事务在执行完业务sql以及undoLog的sql之后，会去往TC注册分支事务信息，同时去获取全局锁，然后再提交本地事务，最后提交完事务之后上报提交结果给TC。通过全局锁的超时机制解决，线程B在等待全局锁超时后会主动释放全局锁，然后进而释放本地锁。
seata之业务无侵入AT模式详解
qq_37436172的博客
09-03 1162
seata 业务无侵入AT模式详解 GlobalTransactional注解 1、使用此注解，设置事务名称以及超时时间等，加上此注解，会进入GlobalTransactionalInterceptor，切面中io.seata.tm.api.TransactionalTemplate.execute会根据注解组装事务信息，并开启分布式全局事务 // 2. begin transaction beginTransaction(txInfo, tx); Ob
科普文：微服务之Spring Cloud Alibaba分布式事务组件Seata4种分布式事务模式及其选择
最新发布
为无为，事无事，味无味。
08-06 1011
Seata是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata提供了ATTCCSAGA和XA事务模式，为用户打造一站式的分布式解决方案。官网Seata概述下载中心示例在Seata开源之前，Seata对应的内部版本在阿里经济体内部一直扮演着分布式一致性中间件的角色，帮助经济体平稳的度过历年的双11，对各BU业务进行了有力的支撑。商业化产品GTS先后在阿里云、金融云进行售卖。TCC与AT事务一样都是两阶段事务，它与ATTCC对业务代码侵入严重。
Seata中AT模式的实现原理03-二阶段提交
qq_41956309的博客
12-21 1040
1.当一阶段提交没有任何异常情况下进行二阶段提交 TM会发送提交全局事务请求给TC2.TC接收到全局事务提交请求之后会循环所有的分支事务 往RM发送分支事务提交的请求3.RM接收到分支事务提交请求之后会委派给AsyncWorker去处理 从阻塞队列里面拿数据4.AsyncWorker处理的时候其实就是将undo_log的数据删除5.当RM处理完之后返回TC 然后会将全局锁删除 就是 lock_table表数据6.将分支事务状态变为二阶段已提交。
Seata解析-TC处理全局事务和分支事务原理详解之分支状态报告请求和全局事务报告请求
龚厂长的博客
09-09 901
本文基于seata 1.3.0版本 本文接文章《Seata解析-TC处理全局事务和分支事务原理详解之全局事务开启和分支事务注册》继续介绍TC对请求的处理。本文将介绍分支状态报告请求和全局事务报告请求。 文章目录一、分支状态报告请求二、全局事务报告请求1、提交全局事务2、回滚全局事务3、其他事务状态4、总结 一、分支状态报告请求 分支状态报告请求的消息类型是MessageType.TYPE_BRANCH_STATUS_REPORT，请求对象为BranchReportRequest，该请求由RM发起。该请求.
对比7种分布式事务方案，还是偏爱阿里开源的Seata，真香！(原理+实战)
承诺不过儿戏的博客
06-02 3134
主要介绍一些目前主流的几种分布式解决方案以及阿里开源的一站式分布式解决方案Seata
基于Java的2阶段提交分布式事务中间件Raincat设计源码
05-25
本源码为基于Java的2阶段提交分布式事务中间件Raincat设计，包含261个Java文件、39个XML文件等，共366个文件。该项目旨在为用户提供一个全面、便捷的分布式事务解决方案，通过Java、JavaScript、Vue、HTML技术的结合...
分布式事务框架Fescar在SpringCloud环境下的应用实践-fescar-demo.zip
01-31
Fescar（原名Seata）是阿里开源的一款高性能、简单易用的分布式事务解决方案，它旨在为开发者提供一个轻量级、易接入的事务中间件，使得在分布式环境下也能保证数据的一致性。 Fescar的核心设计理念是ACID（原子性...
阿里分布式消息中间件RocketMQ-深入解析.docx
10-14
RocketMQ是阿里巴巴自研的第三代分布式消息中间件，2012年开源，2016年捐献给Apache软件基金会，成为孵化项目。RocketMQ具有高性能、低延迟、可靠重试、分布式事务等特性，广泛应用于电商、金融、大数据、物联网等...
分布式消息中间件实践_倪炜(著)
09-12
最后，RocketMQ是阿里巴巴开源的一款分布式消息中间件，最初为淘宝双11大促的订单系统提供服务。RocketMQ的设计目标是高可用、高并发和低延迟，尤其适合电商、金融等实时性要求高的业务场景。它支持发布/订阅模式，...
微服务servicecomb与阿里分布式事务fescar整合插件
03-09
将servicecomb和阿里的fescar分布式事务进行整合，使用方式 将jar文件添加到classpath目录，再配置jescar-consumer，jescar-provider，即可实现微服务间的事务控制
阿里开源分布式事务解决方案: FESCAR
街角有人祝福,巷口有人哭~
01-11 4450
开源地址:https://github.com/alibaba/fescar 什么是FESCAR？ 一种分布式事务解决方案，具有高性能和易用性的微服务架构。 微服务中的分布式事务问题 让我们想象一下传统的单片应用程序。其业务由3个模块构成。他们使用单个本地数据源。 当然，本地事务将保证数据的一致性。 微服务架构的情况发生了变化。上面提到的3个模块被设计为3个不同数据源之上的3个服务...
Seata实战-分布式事务简介及demo上手
热门推荐
hosaos的博客
04-09 12万+
文章目录Seata简介分布式事务产生背景数据库的水平分割微服务化分布式事务理论基础两阶段提交(2pc)TCCSeata解决方案第一阶段第二阶段Demo上手-Dubbo集成Seata配置修改启动测试 Seata简介 Seata(Simple Extensible Autonomous Transaction Architecture) 是 阿里巴巴开源的分布式事务中间件，以高效并且对业务 0 侵入的...
Seata阿里分布式事务中间件(一)：Seata的基本介绍
qq_33240556的博客
09-16 413
Fescar 是 阿里巴巴 开源的 分布式事务中间件，以 高效 并且对业务 0 侵入 的方式，解决 微服务 场景下面临的分布式事务问题。 什么是微服务化带来的分布式事务问题？ 首先，设想一个传统的单体应用（Monolithic App），通过 3 个 Module，在同一个数据源上更新数据来完成一项业务。 很自然的，整个业务过程的数据一致性由本地事务来保证。 随着业务需求和架构的变化，单体应用被拆分为微服务：原来的 3 个 Module 被拆分为 3 个独立的服务，分别使用独立的数据源（Pattern:
SpringCloud Alibaba-Seata分布式事务
沉浸式Study
06-17 882
2PC是一个强一致性的同步阻塞协议，事务执⾏过程中需要将所需资源全部锁定，也就是俗称的 刚性事务。
Seata源码分析之RpcServer
qq_33513250的博客
12-23 811
目录 一、概述 二、AbstractRpcRemoting 三、AbstractRpcRemotingServer 四、RpcServer 五、DefaultServerMessageListenerImpl 一、概述 seata的事务协调器TC(即DefaultCoordinator类)需要发送rpc请求至RM，进行branchCommit和branchRollback。 持有的S...
阿里开源分布式事务框架FESCAR
hfbin的博客
01-12 8613
阿里FESCAR开源地址：https://github.com/alibaba/fescar What is FESCAR? FESCAR（Fast &amp; Easy Commit And Rollback） 是一个用于微服务架构的分布式事务解决方案，它的特点是高性能且易于使用，旨在实现简单并快速的事务提交与回滚。 微服务架构中的分布式事务问题 从传统的单体应用说起，假设一个单体应用的业务由 ...
微服务架构下的分布式事务：阿里GTS解析
阿里GTS（Global Transaction Service）是为解决微服务架构下的分布式事务问题而设计的一种新型中间件。GTS提供了一种强一致性的事务处理能力，确保在分布式环境下的数据一致性。它通过协调各个服务节点，使得在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值