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

最新推荐文章于 2024-08-06 02:13:14 发布
最新推荐文章于 2024-08-06 02:13:14 发布
阅读量701 收藏
点赞数
分类专栏： 分布式事务
版权声明：本文为博主原创文章，遵循 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还有其他未有提及。

蠢物
关注
专栏目录
冬日魔幻之旅-seata+dubbo+nacos+springboot解决分布式事务的全网段唯一实践之作(上)
lifetragedy的专栏
01-22 8985
开篇 阿里把FESCAR开源了，开源后的名称叫SEATA。目前GIT上已经超1万3的星了。 可是笔者遍历全网段，无一篇是生产实用级说明同时GIT官网上的相关文档缺失以及Sample都太HelloWorld了，无法应用在真正的生产环境上。 于是笔者结合了在6，7年前那时在那个MQ年代来解决分布式事务的经验，结合这次的SEATA（最新一次COMMIT在2019年12月底）来讲一下最最新的也是目前...
阿里分布式事务框架fescar环境快速搭建以及简易使用fescar官方demo
ASzhiwei的博客
01-25 1万+
Fescar是什么？ Fescar 是 阿里巴巴 开源的 分布式事务中间件，以 高效 并且对业务 0 侵入 的方式，解决 微服务 场景,它的前身是阿里的全局事务服务GTS，不过GTS是商用的不开源，可以这样认为Fescar就是GTS的开源版，关于它的一些理论，在接下来我会出一系列的关于fescar理论介绍及源码解读文章，在这里先将介绍如何快速运行fescar的官方demo 一.安装Fescar...
来了！阿里开源分布式事务解决方案 Fescar
阿里技术
01-25 982
阿里妹导读：广为人知的阿里分布式事务解决方案：GTS（Global Transaction Service），已正式推出开源版本，取名为“Fescar”，希望帮助业界解决...
阿里开源分布式事务框架fescar
zsj777的专栏
01-25 381
快速开始 https://github.com/alibaba/fescar/wiki/Quick-Start   GIT地址 https://github.com/alibaba/fescar
Seata实战-分布式事务简介及demo上手
热门推荐
hosaos的博客
04-09 12万+
文章目录Seata简介分布式事务产生背景数据库的水平分割微服务化分布式事务理论基础两阶段提交(2pc)TCCSeata解决方案第一阶段第二阶段Demo上手-Dubbo集成Seata配置修改启动测试 Seata简介 Seata(Simple Extensible Autonomous Transaction Architecture) 是 阿里巴巴开源的分布式事务中间件，以高效并且对业务 0 侵入的...
基于阿里微服务架构分布式事务解决方案-FESCAR
学渣的博客
07-24 551
分布式事务Fescar中间件使用的总结以及对中间件的认识 分布式系统将不同的web模块部署在不同的服务器上，通过各种中间件将这些分散的web模块集于在一起，方便分布式系统数据的一致性。 FESCAR介绍 FESCAR（Fast & Easy Commit And Rollback） 是一个用于微服务架构的分布式事务解决方案，它的特点是高性能且易于使用，旨在实现简单并快速的事务提...
阿里开源分布式事务解决方案: FESCAR
街角有人祝福,巷口有人哭~
01-11 4457
开源地址:https://github.com/alibaba/fescar 什么是FESCAR？ 一种分布式事务解决方案，具有高性能和易用性的微服务架构。 微服务中的分布式事务问题 让我们想象一下传统的单片应用程序。其业务由3个模块构成。他们使用单个本地数据源。 当然，本地事务将保证数据的一致性。 微服务架构的情况发生了变化。上面提到的3个模块被设计为3个不同数据源之上的3个服务...
阿里开源分布式事务解决方案 Fescar 全解析
Cowboy
11-07 216
广为人知的阿里分布式事务解决方案：GTS（Global Transaction Service），已正式推出开源版本，取名为“Fescar”，希望帮助业界解决微服务架构下的分布式事务问题，今天我们一起来深入了解。 FESCAR on GitHub https://github.com/alibaba/fescar 微服务倡导将复杂的单体应用拆分为若干个功能简单、松耦合的服务，这样可以降低开发...
详解分布式Java项目与阿里开源技术面试要点
- TCC (Try-Confirm-Cancel) 事务和Fescar (现更名为Seata) 是两种事务管理机制，用于分布式系统中的一致性处理。 13. 开源项目和版本控制： - Git是版本控制系统的标准，开源项目通常通过Git来管理代码，如...
Seata阿里分布式事务中间件(一)：Seata的基本介绍
lizhou828的专栏
05-14 429
Fescar 是 阿里巴巴 开源的 分布式事务中间件，以 高效 并且对业务 0 侵入 的方式，解决 微服务 场景下面临的分布式事务问题。 什么是微服务化带来的分布式事务问题？ 首先，设想一个传统的单体应用（Monolithic App），通过 3 个 Module，在同一个数据源上更新数据来完成一项业务。 很自然的，整个业务过程的数据一致性由本地事务来保证。 随着业务需求和架构的变化，单体应用被拆分为微服务：原来的 3 个 Module 被拆分为 3 个独立的服务，分别使用独立的数据源（Pattern
初识阿里中间件Seata分布式事务
大鸡腿的博客
12-31 402
文章目录学习链接快速入手工作原理支持分布式事务 学习链接 Seata 官网 介绍 https://github.com/seata/seata 快速入手 seata-samples 工作原理 我们可以看到使用TC事务协调器作为中间的事务管理，当事务正常的时候进行提交，失败的时候通过回滚日志去回滚数据。 支持分布式事务 https://seata.io/zh-cn/docs/overview...
科普文：微服务之Spring Cloud Alibaba分布式事务组件Seata4种分布式事务模式及其选择
最新发布
为无为，事无事，味无味。
08-06 1046
Seata是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata提供了ATTCCSAGA和XA事务模式，为用户打造一站式的分布式解决方案。官网Seata概述下载中心示例在Seata开源之前，Seata对应的内部版本在阿里经济体内部一直扮演着分布式一致性中间件的角色，帮助经济体平稳的度过历年的双11，对各BU业务进行了有力的支撑。商业化产品GTS先后在阿里云、金融云进行售卖。TCC与AT事务一样都是两阶段事务，它与ATTCC对业务代码侵入严重。
阿里分布式中间件Seata从入门到精通
dotNET跨平台
11-14 498
最近在写一本关于阿里巴巴分布式事务中间件 Seata 的电子书，Seata可以说是分布式事务中间件中最完善的了，包括了 AT、TCC、Saga、XA 四种模式，目前 Seata 已经更新到...
阿里分布式事务seata入门（采坑）
tzxylao的博客
08-27 9910
1. 阿里分布式事务seata入门（采坑） 1.1. 前言 seata是feascar改名而来，这是阿里在19年年初开源出来的分布式事务框架，当初刚出来的时候就想研究下了，一直拖到了现在，目前是0.8.0版本，看版本就知道这还是个比较新的项目，但现在已经有上万个Star了，可见阿里的影响力。但是虽然有阿里背书，该挖坑还得挖，它宣称集成它比较简单，导致的是现在它的文档优点残缺不全，好几个...
Seata 分布式事务中间件
流子的专栏
11-25 278
Seata分布式事务中间件
SpringCloud Alibaba-Seata分布式事务
沉浸式Study
06-17 1028
2PC是一个强一致性的同步阻塞协议，事务执⾏过程中需要将所需资源全部锁定，也就是俗称的 刚性事务。
Seata AT异常流程场景梳理
我神级欧文的博客
06-29 597
此时回滚重试定时器就能查询出该全局事务，然后对该全局事务下的所有分支事务进行回滚，如果回滚失败，就把状态改为TimeoutRollbackRetrying，然后继续重试回滚，在完成回滚之前全局锁不会被释放。分支事务在执行完业务sql以及undoLog的sql之后，会去往TC注册分支事务信息，同时去获取全局锁，然后再提交本地事务，最后提交完事务之后上报提交结果给TC。通过全局锁的超时机制解决，线程B在等待全局锁超时后会主动释放全局锁，然后进而释放本地锁。
Seata中AT模式的实现原理03-二阶段提交
qq_41956309的博客
12-21 1078
1.当一阶段提交没有任何异常情况下进行二阶段提交 TM会发送提交全局事务请求给TC2.TC接收到全局事务提交请求之后会循环所有的分支事务 往RM发送分支事务提交的请求3.RM接收到分支事务提交请求之后会委派给AsyncWorker去处理 从阻塞队列里面拿数据4.AsyncWorker处理的时候其实就是将undo_log的数据删除5.当RM处理完之后返回TC 然后会将全局锁删除 就是 lock_table表数据6.将分支事务状态变为二阶段已提交。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值