Spring Cloud 分布式事务管理（转载）

最新推荐文章于 2024-04-17 04:31:31 发布

大龙拳

最新推荐文章于 2024-04-17 04:31:31 发布

阅读量722

点赞数 1

分类专栏：系统架构

系统架构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

转自：https://blog.csdn.net/zyndev/article/details/79604395

Spring Cloud 分布式事务管理

在微服务如火如荼的情况下，越来越多的项目开始尝试改造成微服务架构，微服务即带来了项目开发的方便性，又提高了运维难度以及网络不可靠的概率.

在说微服务的优缺点时，有对比才会更加明显，首先说一下单体式结构

单体式架构

在单体式架构中，系统通常采用分层架构模式（MVC），持久化层、表示层，业务逻辑层。架构主要存在以下问题：

系统内部互相访问，耦合紧密导致难以维护；
各业务领域需要采用相同的技术栈，难以快速应用新技术（例如使用SSH很难向SSM改造）；
对系统的任何修改都必须整个系统一起重新部署/升级；
在系统负载增加时，难以进行水平扩展；
当系统中一处出现问题，会影响整个系统；

为了克服以上缺点，微服务架构应运而生。微服务，又叫微服务架构。微服务就是一些协同工作的小而自治的服务.

微服务架构

优点:

1. 技术异构性

在不同的服务中，可以使用不同的技术来各自开发，只要保证服务间能相互协作即可

2. 弹性

当微服务中的某一个服务不可用时，不会影响整个系统，只会影响相关功能不可用

3. 扩展

易于扩展，使用小的多个服务，更加易于扩展新的功能

4. 简化部署

某个服务的更新部署，不需要重新部署整个应用

5. 可组合

通过组合多个服务，可以提供一些新的功能

6. 可替代

因为每个微服务都比较小，重新实现某一个服务或者直接删除该服务都是可操作的

缺点:

1. 复杂度高

微服务间通过REST、RPC等形式交互，相对于单体模式，需要考虑被调用方故障、过载、消息丢失等各种异常情况，代码逻辑更加复杂。

对于微服务间的事务性操作，因为不同的微服务采用了不同的数据库，将无法利用数据库本身的事务机制保证一致性，需要引入二阶段提交等技术。

同时，在微服务间存在少部分共用功能但又无法提取成微服务时，各个微服务对于这部分功能通常需要重复开发，或至少要做代码复制，以避免微服务间的耦合，增加了开发成本。

2. 运维复杂

在采用微服务架构时，系统由多个独立运行的微服务构成，需要一个设计良好的监控系统对各个微服务的运行状态进行监控。运维人员需要对系统有细致的了解才对够更好的运维系统。

3. 影响性能

相对于单体架构，微服务的间通过REST、RPC等形式进行交互，通信的时延会受到较大的影响。

分布式事务的引入

正如上面所说

对于微服务间的事务性操作，因为不同的微服务采用了不同的数据库，将无法利用数据库本身的事务机制保证一致性，需要引入二阶段提交等技术。

在单体项目中，很容易做到事务控制，而在多个服务之间很难实现

假设服务调用如下：

这里写图片描述

A B C D 的事务均在各个服务控制，如何做到，统一协调，保证数据的一致性？

分布式事务解决方案

基于XA协议的两阶段提交

XA是一个分布式事务协议，由提出。XA中大致分为两部分：事务管理器和本地资源管理器。其中本地资源管理器往往由数据库实现，比如Oracle、DB2这些商业数据库都实现了XA接口，而事务管理器作为全局的调度者，负责各个本地资源的提交和回滚。XA实现分布式事务的原理如下：
第一阶段：

Tuxedo

第二阶段:
这里写图片描述

总的来说，XA协议比较简单，而且一旦商业数据库实现了XA协议，使用分布式事务的成本也比较低。但是，XA也有致命的缺点，那就是性能不理想，特别是在交易下单链路，往往并发量很高，XA无法满足高并发场景。XA目前在商业数据库支持的比较理想，在mysql数据库中支持的不太理想，mysql的XA实现，没有记录prepare阶段日志，主备切换回导致主库与备库数据不一致。许多nosql也没有支持XA，这让XA的应用场景变得非常狭隘。

消息事务+最终一致性

所谓的消息事务就是基于消息中间件的两阶段提交，本质上是对消息中间件的一种特殊利用，它是将本地事务和发消息放在了一个分布式事务里，保证要么本地操作成功成功并且对外发消息成功，要么两者都失败，开源的RocketMQ就支持这一特性.

该方案采用最终一致的，牺牲了一致性，换来了性能的大幅度提升。存在造成数据不一致的风险

TCC编程模式

所谓的TCC编程模式，也是两阶段提交的一个变种。TCC提供了一个编程框架，将整个业务逻辑分为三块：Try、Confirm和Cancel三个操作。以在线下单为例，Try阶段会去扣库存，Confirm阶段则是去更新订单状态，如果更新订单失败，则进入Cancel阶段，会去恢复库存。总之，TCC就是通过代码人为实现了两阶段提交，不同的业务场景所写的代码都不一样，复杂度也不一样，因此，这种模式并不能很好地被复用。

对此部分感兴趣的可以查看原文。

以下为原文信息，以下为作者自己输入的。

消息事务+最终一致性（详细）

从oschina中得知，rocketmq 4.3已经发布，并新增了事务消息的功能。

链接：https://www.oschina.net/news/98553/rocketmq-4-3-0-released?from=20180805

在github中比较详细的介绍。链接：https://github.com/apache/rocketmq/issues/292

目前在apche中，下载链接还没有放出来，但是可以找到。下载链接：http://mirrors.hust.edu.cn/apache/rocketmq/4.3.0/

查看源码包提供测试用例:

package org.apache.rocketmq.example.transaction;

import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.TransactionListener;
import org.apache.rocketmq.client.producer.TransactionMQProducer;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.io.UnsupportedEncodingException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TransactionProducer {
    public static void main(String[] args) throws MQClientException, InterruptedException {
        TransactionListener transactionListener = new TransactionListenerImpl();
        TransactionMQProducer producer = new TransactionMQProducer("please_rename_unique_group_name");
        ExecutorService executorService = new ThreadPoolExecutor(2, 5, 100, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(2000), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("client-transaction-msg-check-thread");
                return thread;
            }
        });

        producer.setExecutorService(executorService);
        producer.setTransactionListener(transactionListener);
        producer.start();

        String[] tags = new String[] {"TagA", "TagB", "TagC", "TagD", "TagE"};
        for (int i = 0; i < 10; i++) {
            try {
                Message msg =
                    new Message("TopicTest1234", tags[i % tags.length], "KEY" + i,
                        ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
                SendResult sendResult = producer.sendMessageInTransaction(msg, null);
                System.out.printf("%s%n", sendResult);

                Thread.sleep(10);
            } catch (MQClientException | UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        for (int i = 0; i < 100000; i++) {
            Thread.sleep(1000);
        }
        producer.shutdown();
    }
}

主要需要一个事务监控器，需要业务去实现，实现一下回查的方法及线程池。

事务消息实现的核心代码：

public TransactionSendResult sendMessageInTransaction(final Message msg,
                                                          final TransactionListener tranExecuter, final Object arg)
        throws MQClientException {
        if (null == tranExecuter) {
            throw new MQClientException("tranExecutor is null", null);
        }
        Validators.checkMessage(msg, this.defaultMQProducer);

        SendResult sendResult = null;
        MessageAccessor.putProperty(msg, MessageConst.PROPERTY_TRANSACTION_PREPARED, "true");
        MessageAccessor.putProperty(msg, MessageConst.PROPERTY_PRODUCER_GROUP, this.defaultMQProducer.getProducerGroup());
        try {
            sendResult = this.send(msg);
        } catch (Exception e) {
            throw new MQClientException("send message Exception", e);
        }

        LocalTransactionState localTransactionState = LocalTransactionState.UNKNOW;
        Throwable localException = null;
        switch (sendResult.getSendStatus()) {
            case SEND_OK: {
                try {
                    if (sendResult.getTransactionId() != null) {
                        msg.putUserProperty("__transactionId__", sendResult.getTransactionId());
                    }
                    String transactionId = msg.getProperty(MessageConst.PROPERTY_UNIQ_CLIENT_MESSAGE_ID_KEYIDX);
                    if (null != transactionId && !"".equals(transactionId)) {
                        msg.setTransactionId(transactionId);
                    }
                    localTransactionState = tranExecuter.executeLocalTransaction(msg, arg);
                    if (null == localTransactionState) {
                        localTransactionState = LocalTransactionState.UNKNOW;
                    }

                    if (localTransactionState != LocalTransactionState.COMMIT_MESSAGE) {
                        log.info("executeLocalTransactionBranch return {}", localTransactionState);
                        log.info(msg.toString());
                    }
                } catch (Throwable e) {
                    log.info("executeLocalTransactionBranch exception", e);
                    log.info(msg.toString());
                    localException = e;
                }
            }
            break;
            case FLUSH_DISK_TIMEOUT:
            case FLUSH_SLAVE_TIMEOUT:
            case SLAVE_NOT_AVAILABLE:
                localTransactionState = LocalTransactionState.ROLLBACK_MESSAGE;
                break;
            default:
                break;
        }

        try {
            this.endTransaction(sendResult, localTransactionState, localException);
        } catch (Exception e) {
            log.warn("local transaction execute " + localTransactionState + ", but end broker transaction failed", e);
        }

        TransactionSendResult transactionSendResult = new TransactionSendResult();
        transactionSendResult.setSendStatus(sendResult.getSendStatus());
        transactionSendResult.setMessageQueue(sendResult.getMessageQueue());
        transactionSendResult.setMsgId(sendResult.getMsgId());
        transactionSendResult.setQueueOffset(sendResult.getQueueOffset());
        transactionSendResult.setTransactionId(sendResult.getTransactionId());
        transactionSendResult.setLocalTransactionState(localTransactionState);
        return transactionSendResult;
    }

这些核心代码配合上面给的示例图，可以看看。

附：

本方案主要强调最终一致性，在某些情况下，无法保证最终一致性的(因为业务的问题)，需要三思。

大龙拳

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring Cloud 分布式事务管理（转载）

转自：https://blog.csdn.net/zyndev/article/details/79604395Spring Cloud 分布式事务管理在微服务如火如荼的情况下，越来越多的项目开始尝试改造成微服务架构，微服务即带来了项目开发的方便性，又提高了运维难度以及网络不可靠的概率. Spring Cloud 分布式事务管理单体式架构微服务架构优点: 缺点: ...
复制链接

扫一扫