SpringBoot+RocketMQ分布式下的消息最终一致性

最新推荐文章于 2024-09-30 09:31:36 发布
最新推荐文章于 2024-09-30 09:31:36 发布
阅读量492 收藏
点赞数 1
分类专栏： 分布式 文章标签： spring boot 分布式 java-rocketmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dasfv/article/details/126036438
版权

SpringBoot+RocketMQ分布式下的消息最终一致

示例划分说明

整个例子涉及模拟三个服务，eureka注册中心、pay-center支付中心服务和api-passenger核心业务服务。主要调用图如下：
在这里插入图片描述

  1. 首先第三方支付发起支付结果回调。
  2. 封装我们的生产者业务基础数据和消费者业务基础数据。
  3. 使用rocketmq提交半消息（发到broker上进行持久化但不能被消费者消费的消息）。
  4. 生产者实现RocketMQLocalTransactionListener监听半消息并处理生产者本地事务，记录事务执行日志。并返回执行结果。
  5. 消费者监听topic下的消息进行消费，校验幂等性，校验重试次数，进行业务数据处理并记录消息消费记录。
  6. 超过重试次数的消息直接记录消息消费记录，并发送警告通知邮件。将其放入redis事务池中等待回滚处理。
  7. 定时执行器拉取redis中的消息发起退款并对数据进行回滚操作。
  8. 对于定时器也解决不了的数据直接人工接口补偿。
生产者(第三方支付服务)

使用的表：

CREATE TABLE `pay_waybill_data_info` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `waybill_id` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '运单id',
  `pay_mount` decimal(16,2) NOT NULL COMMENT '支付金额',
  `pay_status` enum('WAITE_PAY','FINISH_PAY','CANCEL_PAY','REFUND') CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT 'WAITE_PAY' COMMENT '支付状态(1待支付，2完成支付，3客户取消支付，4退款)',
  `user_name` varchar(64) NOT NULL COMMENT '用户名称',
  `user_id` varchar(20) NOT NULL COMMENT '用户id',
  `id_card` varchar(32) NOT NULL COMMENT '用户身份证号',
  `vip_flag` tinyint(1) NOT NULL COMMENT '是否vip用户（1是，2否）',
  `create_time` datetime NOT NULL COMMENT '新增时间',
  `update_time` datetime NOT NULL COMMENT '修改时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `waybillId_index` (`waybill_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COMMENT='运单支付信息';

CREATE TABLE `t_mq_transaction_log` (
  `transaction_id` varchar(64) NOT NULL COMMENT '事务id',
  `befor_log` varchar(250) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提交前日志',
  `after_log` varchar(250) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '提交后日志',
  `op_type` enum('ADD','UPDATE','DELETE') CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT 'ADD' COMMENT '数据库操作类型()',
  `msg_key` varchar(64) NOT NULL COMMENT '消息的key唯一',
  PRIMARY KEY (`transaction_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci COMMENT='事务日志表';

MQTXProducerService：生产者半消息发送

@Component
@Slf4j
public class MQTXProducerService {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    /**
     * 发送事务半消息
     *
     * @param topic            主题
     * @param tag              过滤
     * @param transactionParam 本地事务参数
     * @param consumerParam 消费者参数
     * @return
     */
    public TransactionSendResult sendHalfMessage(String topic, String tag, TransactionParam transactionParam,ConsumerParam consumerParam) {
        if (StringUtils.isEmpty(topic)) {
            log.error("【事务开始发送半消息】topic不能为空");
            return null;
        }
        String destination = topic;
        if (!StringUtils.isEmpty(tag)) {
            destination = topic + ":" + tag;
        }
        String transactionId = IdUtil.simpleUUID();
        String keys = IdUtil.simpleUUID();
        consumerParam.setMsgKey(keys);
        transactionParam.setMsgKey(keys);
        log.info("【事务开始发送半消息】transactionId：{},transactionParam：{}", transactionId, JSON.toJSONString(transactionParam));
        /**
         * 参数1：指定发送的topic和过滤的tag（tag可以不指定默认为*表示不过滤）
         * 参数2：message发送的消息体
         * 参数3：交给本地事务的参数
         */
        String msg = JSON.toJSONString(consumerParam);
        TransactionSendResult transactionSendResult = rocketMQTemplate.sendMessageInTransaction(destination,
                MessageBuilder.withPayload(msg).setHeader(RocketMQHeaders.TRANSACTION_ID, transactionId).setHeader(RocketMQHeaders.KEYS, keys).build(),
                transactionParam);
        log.info("【事务发送半消息返回】transactionSendResult：{}", JSON.toJSONString(transactionSendResult));
        return transactionSendResult;
    }

}

MQTXListenerService：生产者本地事务监听处理器

@Slf4j
@RocketMQTransactionListener
public class MQTXListenerService implements RocketMQLocalTransactionListener, ApplicationContextAware {

    private ApplicationContext applicationContext;

    @Autowired
    private TmqTransactionLogMapper tmqTransactionLogMapper;

    /**
     * 执行器，执行本地事务
     *
     * @param message
     * @param o
     * @return
     */
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        try {
            String transactionId = message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID, String.class);
            TransactionParam transactionParam = (TransactionParam) o;
            log.info("【执行本地事务】消息参数 transactionId：{}，transactionParam：{}", transactionId, JSON.toJSONString(transactionParam));
            Object bean = applicationContext.getBean(transactionParam.getBeanName());
            TXLocalTransaction transaction = null;
            if (!(bean instanceof TXLocalTransaction)) {
                log.error("【执行本地事务】分布式事务没有匹配到合法的父类处理器，请检查子类是否实现TXLocalTransaction。{}", JSON.toJSONString(transactionParam));
                return RocketMQLocalTransactionState.ROLLBACK;
            }
            transaction = (TXLocalTransaction) bean;
            switch (transactionParam.getMethodName()) {
                case TransactionContans.ADD:
                    transaction.add(transactionParam, transactionId);
                    return RocketMQLocalTransactionState.COMMIT;
                case TransactionContans.UPDATE:
                    transaction.update(transactionParam, transactionId);
                    return RocketMQLocalTransactionState.COMMIT;
                case TransactionContans.DELETE:
                    transaction.delete(transactionParam, transactionId);
                    return RocketMQLocalTransactionState.COMMIT;
                default:
                    log.error("【开始执行本地事务】分布式事务没有匹配到合法的方法名称，请检查执行事务方法名称是否正确。{}", JSON.toJSONString(transactionParam));
                    return RocketMQLocalTransactionState.ROLLBACK;
            }
        } catch (Exception e) {
            log.error("【执行本地事务】分布式事务之本地事务发生异常。", e);
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }

    /**
     * 回查：用于回查本地事务结果（解决长时间不响应问题）
     *
     * @param message
     * @return
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        String transactionId = message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID, String.class);
        TMQTransactionLogPO logByTransactionId = tmqTransactionLogMapper.findLogByTransactionId(transactionId);
        log.error("【执行本地事务回查】分布式事务回查事务日志。transactionId：{}，TMQTransactionLogPO：{}", transactionId, JSON.toJSONString(logByTransactionId));
        if (Objects.isNull(logByTransactionId)) {
            return RocketMQLocalTransactionState.ROLLBACK;
        }
        return RocketMQLocalTransactionState.COMMIT;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

TXLocalTransaction：接口封装自适应实现接口重写方法即可接入生产者本地事务

public interface TXLocalTransaction {

    /**
     * 新增
     * @param transactionParam
     * @param transactionId
     * @return
     */
    TaoTuMasterResult add(TransactionParam transactionParam,String transactionId);

    /**
     * 修改
     * @param transactionParam
     * @param transactionId
     * @return
     */
    TaoTuMasterResult update(TransactionParam transactionParam,String transactionId);

    /**
     * 删除
     * @param transactionParam
     * @param transactionId
     * @return
     */
    TaoTuMasterResult delete(TransactionParam transactionParam,String transactionId);
}

PayCallbackServiceImpl：本地业务及本地调用

@Service
public class PayCallbackServiceImpl implements PayCallbackService, TXLocalTransaction {
    private static final String Topic = "RLT_PAY_TRANS_TOPIC";
    private static final String Tag = "Pay";
    @Autowired
    private MQTXProducerService mqtxProducerService;

    @Autowired
    private PayWaybillDataInfoMapper payWaybillDataInfoMapper;

    @Autowired
    private TmqTransactionLogMapper tmqTransactionLogMapper;

    @Override
    public TaoTuMasterResult getCallback(PayWaybillDataInfoPO payWaybillDataInfoPO) {
        PayWaybillDataInfoPO payWaybillDataInfoByWaybillId = payWaybillDataInfoMapper.findPayWaybillDataInfoByWaybillId(payWaybillDataInfoPO.getWaybillId());
        TransactionParam<PayWaybillDataInfoPO> transactionParam = new TransactionParam<>("payCallbackServiceImpl", TransactionContans.UPDATE, payWaybillDataInfoPO);
        ConsumerParam consumerParam = new ConsumerParam(payWaybillDataInfoPO);
        transactionParam.setOldParam(payWaybillDataInfoByWaybillId);
        TransactionSendResult transactionSendResult = mqtxProducerService.sendHalfMessage(Topic, Tag, transactionParam, consumerParam);
        return TaoTuMasterResultUtil.result(transactionSendResult);
    }

    @Override
    public TaoTuMasterResult add(TransactionParam transactionParam, String transactionId) {
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TaoTuMasterResult update(TransactionParam transactionParam, String transactionId) {
        PayWaybillDataInfoPO newPayWaybillDataInfoPO = (PayWaybillDataInfoPO) transactionParam.getNewParam();
        PayWaybillDataInfoPO oldPayWaybillDataInfoPO = (PayWaybillDataInfoPO) transactionParam.getOldParam();
        int i = payWaybillDataInfoMapper.update(newPayWaybillDataInfoPO);
        if (i <= 0) {
            throw new RuntimeException("更新失败");
        }
        TMQTransactionLogPO tmqTransactionLogPO = new TMQTransactionLogPO();
        tmqTransactionLogPO.setTransactionId(transactionId);
        tmqTransactionLogPO.setOpType(OpTypeEnum.UPDATE);
        tmqTransactionLogPO.setMsgKey(transactionParam.getMsgKey());
        tmqTransactionLogPO.setAfterLog(JSON.toJSONString(newPayWaybillDataInfoPO));
        tmqTransactionLogPO.setBeforLog(JSON.toJSONString(oldPayWaybillDataInfoPO));
        int count = tmqTransactionLogMapper.add(tmqTransactionLogPO);
        if (count <= 0) {
            throw new RuntimeException("新增事务日志失败");
        }
        return TaoTuMasterResultUtil.ok();
    }

    @Override
    public TaoTuMasterResult delete(TransactionParam transactionParam, String transactionId) {
        return null;
    }
}

PayRefundServiceImpl：消费者异常下的数据回退

@Service
@Slf4j
public class PayRefundServiceImpl implements PayRefundService {

    @Autowired
    private TaoTuRedisUtil taoTuRedisUtil;
    @Autowired
    private TmqTransactionLogMapper tmqTransactionLogMapper;
    @Autowired
    private PayWaybillDataInfoMapper payWaybillDataInfoMapper;
    @Autowired
    @Qualifier("delayExecutor")
    private ScheduledThreadPoolExecutor scheduledThreadPoolExecutor;


    /**
     * 执行一次定时任务
     */
    @Override
    @PostConstruct
    public void scheduledRefund() {
        scheduledThreadPoolExecutor.scheduleAtFixedRate(new DeadHandler(payWaybillDataInfoMapper,tmqTransactionLogMapper,taoTuRedisUtil),0,60, TimeUnit.SECONDS);
    }
}

DeadHandler：数据回退执行器

@Slf4j
public class DeadHandler implements Runnable {
    private static final String PAY_TRANS = "PAY_TRANS";
    private PayWaybillDataInfoMapper payWaybillDataInfoMapper;
    private TmqTransactionLogMapper tmqTransactionLogMapper;
    private TaoTuRedisUtil taoTuRedisUtil;

    public DeadHandler(PayWaybillDataInfoMapper payWaybillDataInfoMapper, TmqTransactionLogMapper tmqTransactionLogMapper, TaoTuRedisUtil taoTuRedisUtil) {
        this.payWaybillDataInfoMapper = payWaybillDataInfoMapper;
        this.tmqTransactionLogMapper = tmqTransactionLogMapper;
        this.taoTuRedisUtil = taoTuRedisUtil;
    }

    @Override
    public void run() {
        Map<String, Object> map = taoTuRedisUtil.hmGet(PAY_TRANS);
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String msg = (String) entry.getValue();
            String msgKey = entry.getKey();
            log.info("【发起退款】参数信息：{} msgKey：{}", msg, msgKey);
            TMQTransactionLogPO tmqTransactionLogPO = tmqTransactionLogMapper.findLogByMsgKey(msgKey);
            log.info("【事务日志】查询结果为{}",JSON.toJSONString(tmqTransactionLogPO));
            if (tmqTransactionLogPO == null) {
                log.error("【事务日志】查询异常，查询结果为空");
                return;
            }
            if (OpTypeEnum.ADD.equals(tmqTransactionLogPO.getOpType())) {
                log.info(" **********************  操作支付数据回滚删除newParam数据操作  **********************");
            } else if (OpTypeEnum.UPDATE.equals(tmqTransactionLogPO.getOpType())) {
                // 用这个为例
                // 发起第三方支付退款业务调用
                log.info(" **********************  发起第三方支付退款业务调用  **********************");
                /**
                 * 。。。。。。省略退款业务
                 */
                // 第三方退款失败（几率小，首先要保证我们这边支付服务的稳定）万一失败数据在redis中，后续使用接口进行人工补偿。补偿数据原理同这里，只不过是接口触发，从redis中读取数据处理。
                boolean refundResult = true;
                if (!refundResult) {
                    // 退款失败--->自动回退数据失败后将一直保留在redis中，后续可直接从redis中取出并人工补偿
                    log.error("【发起退款】第三方支付退款失败，请进行人工数据补偿：msgKey{}", msgKey);
                    return;
                }

                // 退款成功数据回退
                log.info("【开始发起退款】操作支付数据回滚修改为oldParam操作");
                // 从事务日志表中拿到之前的数据日志信息进行回滚
                String beforLog = tmqTransactionLogPO.getBeforLog();
                PayWaybillDataInfoPO oldPayWaybillDataInfoPO = JSON.parseObject(beforLog, PayWaybillDataInfoPO.class);
                payWaybillDataInfoMapper.update(oldPayWaybillDataInfoPO);
                // 正常结束的清除redis数据
                taoTuRedisUtil.hDel(PAY_TRANS, msgKey);
            } else if (OpTypeEnum.DELETE.equals(tmqTransactionLogPO.getOpType())) {
                log.info(" **********************  操作支付数据回滚增加oldParam操作  **********************");
            }
        }
    }
}
消费者(核心业务服务)

用到的表：

CREATE TABLE `waybill_info_data` (
  `id` varchar(20) NOT NULL COMMENT '运单id',
  `waybill_status` tinyint(1) NOT NULL COMMENT '1未完成  2已完成',
  `create_time` datetime NOT NULL COMMENT '新增时间',
  `update_time` datetime NOT NULL COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='运单信息';

CREATE TABLE `msg_consumer_log` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `msg_id` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '消息id',
  `consumer_status` tinyint(1) NOT NULL COMMENT '消费状态（1未消费 2已消费）',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COMMENT='消息消费日志';

WaybillDataServiceImpl：消费者监听消息

@Slf4j
@Service
@RocketMQMessageListener(topic = "RLT_PAY_TRANS_TOPIC", consumerGroup = "PAY_TRANS_GROUP", selectorExpression = "Pay")
public class WaybillDataServiceImpl implements RocketMQListener<MessageExt>, RocketMQPushConsumerLifecycleListener {
    private static final String PAY_TRANS = "PAY_TRANS";

    @Value("${spring.application.name}")
    private String instanceName;
    @Autowired
    private MsgConsumerLogMapper msgConsumerLogMapper;
    @Autowired
    private WaybillInfoDataMapper waybillInfoDataMapper;
    @Autowired
    private TaoTuRedisUtil taoTuRedisUtil;
    @Autowired
    private JavaMailSender javaMailSender;



    @Override
    @Transactional(rollbackFor = Exception.class)
    public void onMessage(MessageExt msgExt) {
        if (msgExt == null) {
            return;
        }
        String msg = new String(
                msgExt.getBody()
        );
        JSONObject object = JSON.parseObject(msg);
        String msgKey = object.get("msgKey").toString();

        // 1.先检查幂等性
        MsgConsumerLogPO msgConsumerLogPO = msgConsumerLogMapper.findByMsgId(msgKey);
        if (msgConsumerLogPO != null) {
            log.info("消息已经消费过了");
            return;
        }
        // 2.判断触发重试次数
        if (msgExt.getReconsumeTimes() > 3) {
            log.info("【消费者事务异常】超过最大重试次数 consumerParam：{}", msg);

            // （事务出现异常之后）发邮件通知并将死信消息放入redis中用于后续数据补偿
            // 2-1.发邮件通知《用于通知及时处理业务报错问题，防止代码问题导致业务操作不一致问题》
            Map<String,Object> map = new HashMap<>(16);
            map.put(msgKey, JSON.toJSONString(msg));
            SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
            simpleMailMessage.setTo("");
            simpleMailMessage.setSubject("分布式事务异常通知");
            simpleMailMessage.setText("【消费者事务异常】消费者接收信息msgKey为：" + msgKey + "，请及时处理！！！");
            simpleMailMessage.setFrom("");

            // 2-2.组装并插入消费记录，发送邮件-加入redis
            msgConsumerLogPO = new MsgConsumerLogPO();
            msgConsumerLogPO.setMsgId(msgKey);
            msgConsumerLogPO.setConsumerStatus(2);
            msgConsumerLogMapper.add(msgConsumerLogPO);
            javaMailSender.send(simpleMailMessage);
            taoTuRedisUtil.hmSet(PAY_TRANS, map);
            return;
        }

        log.info("【事务消费消息】consumerParam：{}", JSON.toJSONString(msg));
        Object param = object.get("param");
        String paramStr = JSON.toJSONString(param);
        JSONObject jsonObject = JSON.parseObject(paramStr);
        // 3.查询并更新业务数据
        WaybillInfoDataPO waybillInfoDataPO = waybillInfoDataMapper.findByWaybillId(jsonObject.get("waybillId").toString());
        if (waybillInfoDataPO == null) {
            log.error("单子不存在");
            return;
        }
        waybillInfoDataPO.setWaybillStatus(2);
        waybillInfoDataPO.setUpdateTime(new Date());
        int i = waybillInfoDataMapper.update(waybillInfoDataPO);
        if (i <= 0) {
            throw new RuntimeException("数据表未更新成功");
        }

        // 制造消费端异常
        //int s = 1/0;
        // 4.保存消息消费记录
        msgConsumerLogPO = new MsgConsumerLogPO();
        msgConsumerLogPO.setMsgId(msgKey);
        msgConsumerLogPO.setConsumerStatus(2);
        msgConsumerLogMapper.add(msgConsumerLogPO);
    }

    @SneakyThrows
    @Override
    public void prepareStart(DefaultMQPushConsumer defaultMQPushConsumer) {
        // 设置最大重试次数
        //defaultMQPushConsumer.setMaxReconsumeTimes(3);
        defaultMQPushConsumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_FIRST_OFFSET);
        defaultMQPushConsumer.setInstanceName(instanceName);
        //defaultMQPushConsumer.setConsumeTimestamp(UtilAll.timeMillisToHumanString3(System.currentTimeMillis()));
    }
}

测试

发起事务请求
执行前的数据结果：
执行前的支付状态
执行前的运单状态
正常执行后：
正常执行后的支付状态
正常执行后的运单状态
消费端异常：
。。。。。。。。。。自己测试，消息失败重试超过3次后会进入redis，执行器每60s执行一次。数据回滚后将和刚开始保持一致。

SpringCloud + RocketMQ实现可靠消息最终一致性事务
weixiaohuai的博客
12-31 684
目录 一、概述 二、案例说明和数据库、表准备 三、下载安装RocketMQ并启动 四、搭建中国建设银行CCB微服务 五、搭建中国工商银行ICBC微服务 六、测试转账 七、总结 一、概述 前面一篇文章介绍了RocketMQ实现可靠消息最终一致性事务的整体流程，大部分都是理论知识，本篇文章我们将结合前面我们使用过的【银行转账案例】详细说明如何利用RocketMQ实现可靠消息最终一致性事务。 二、案例说明和数据库、表准备 案例： 张三【中国建设银行】给李四【中国工商银行】转账 说明：张三和
分布式事务（八）Spring Cloud微服务系统基于Rocketmq可靠消息最终一致性实现分布式事务
꯭ 瞎꯭扯꯭蛋꯭的博客
11-01 240
安装搭建 Rocketmq 服务器 搭建单机 Rocketmq 服务器笔记： 《RocketMQ (一) 安装》 搭建双主双从同步复制 Rocketmq 服务器笔记： 《RocketMQ (二) 双主双从同步复制集群方案》 基于 Rocketmq 可靠消息的分布式事务方案原理 Rocketmq事务消息笔记： 《RocketMQ 发送事务消息原理分析和代码实现》 在 rocketmq-dtx 下导入订单项目，无事务版本 order 发送事务消息，并执行本地事务 Rocketmq 中添加 Topic 使用 or
Springboot+RocketMQ+消息顺序发送与顺序消费及其事务控制
言语之间的博客
12-10 3097
消息顺序发送 消息有序指的是可以按照消息的发送顺序来消费。 RocketMQ可以严格的保证消息有序。但这个顺序，不是全局顺序，只是分区（queue）顺序。要全局顺序只能一个分区。 之所以出现你这个场景看起来不是顺序的，是因为发送消息的时候，消息发送默认是会采用轮询的方式发送到不通的queue（分区）。如图： 话不多说看代码： 首先是顺序消息的生产者 package com.rocketmq.roc...
分布式事务（半消息）
最新发布
weixin_46619605的博客
09-30 844
RocketMQ的半消息实现分布式事务
数据库事务隔离级别 与 脏读、不可重复读、幻读
程序员小哲的博客
11-03 3246
事务的四大特征 原子性 　　原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚。 一致性 　　一致性是指事务必须使数据库从一个一致性状态变换到另一个一致性状态，也就是说一个事务执行之前和执行之后都必须处于一致性状态。 隔离性 　　隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。 持久性 　　持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的，即便是在数据库系统遇到故障的情况下也不会丢失提
RabbitMQ 系列之分布式事务处理-最终一致性-SpringBoot实现
人人都是程序员
06-05 8323
目录 分布式事务应用场景： 如何使用RabbitMQ 解决分布式事务-最终一致性： 实现场景：用户下单service - 扣减用户积分 service 结合Springboot 处理分布式事务-为减少篇幅，只列出主要几块代码，详见文末源码链接： maven-parent . pom.xml 以下是Maven-module.orderProducer 生产者模块内容 mav...
RocketMQ整合SpringBoot收发消息-可靠消息最终一致性实现分布式事务(三)
qq_15740267的博客
07-13 628
1. 编辑pom.xml配置文件 pom.xml文件添加依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <version>2.1.0</version> </
springboot 整合rabbitMq保证消息一致性方案
qq_38041439的博客
05-01 1781
RabbitMQ是一种开源的消息代理软件，它实现了高级消息队列协议（AMQP）标准，可用于在应用程序之间传递消息。RabbitMQ最初由LShift开发，现在由Pivotal Software维护。RabbitMQ可以在多个平台上运行，包括Windows、Mac OS X和各种Linux发行版。它提供了多种编程语言的客户端库，如Java、Python、Ruby、.NET等等。
springBoot RabbitMq流量削峰，可靠性传递
qq_46859110的博客
10-06 581
导入依赖 <dependencies> <!-- junit--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency>
springboot+rocketmq（7）:实现事务消息
12程序猿的博客
07-11 2506
springboot+rocketmq（7）:实现事务消息
Springboot+Redis+Dubbo+Rocketmq
01-15
标题 "Springboot+Redis+Dubbo+Rocketmq" 暗示了这是一个关于构建分布式系统的技术组合，其中Springboot作为基础框架，Redis用于缓存管理，Dubbo是服务治理框架，而Rocketmq则是消息中间件。现在，我们将深入探讨...
SpringBoot+RocketMQ
12-28
在当今的互联网开发中，消息队列（Message Queue）已经成为分布式系统中的重要组件，它能够有效地缓解高并发场景下的压力，提高系统的可扩展性和稳定性。本篇文章将深入探讨如何利用SpringBoot框架与阿里云的...
商城秒杀项目，基于springboot开发，使用redis和rocketmq技术增加高并发能力
02-16
- 事务一致性：提供分布式事务功能，确保秒杀操作的原子性和一致性。 4. 环境搭建与启动 "项目环境搭建总结.md"文件详细记录了项目的搭建过程，包括JDK、Maven、SpringBoot、Redis和RocketMQ的安装配置。启动脚本...
【Rocket MQ】RocketMQ4.2.0 和 spring boot的结合使用，实现分布式事务
weixin_33860528的博客
07-20 802
RocketMQ4.2.0 和 spring boot的结合使用，实现分布式事务   参考地址：https://www.jianshu.com/p/f57de40621a0
springboot监听两个不同源的Rocketmq
tswdya的博客
03-16 905
添加RocketMq依赖，根据需要选择对应的版本。一、创建一个springboot 项目。RocketMqConfig配置类。四、添加配置类及消息监听。
springboot 服务最终一致性方案
maple_son的专栏
09-22 1627
目前市面上现有的最终一致性方案有： 1.分布式事务 一致性第一个想到的方案，但性能低下，数据源限制，等等问题，基本没用 2.RPC直调 最便宜，最省事，也是最没有保障的一种方案 3.MQ,KAFKA中间件 使用得最多，也是最容易入坑的方式，看看你的项目中是否有注意以下问题： 0.埋点问题，在一个复杂的业务中，是写个拦截器呢还是所有地方都来埋个点呢？ 1.发送端埋点上报与数据库事务非原子性操作问题，先操作数据库，还是先上报MQ? 2.发送端发送消息是否有确认机制？ 3.发送端发送消息在内存重试过程中
5 SpringBoot整合RocketMQ发送同步消息
java1234的博客
09-01 1544
发送同步消息是指producer向 broker 发送消息，执行 API 时同步等待， 直到broker 服务器返回发送结果； 相对异步发送消息，同步会阻塞线程，性能相对差点，但是可靠性高，这种方式得到广泛使用，比如：短信通知，邮件通知，站内重要信息通知等。 RocketMQTemplate给我们提供了syncSend方法(有多个重载)，来实现发送同步消息； 下面给一个实例： /** * 发送同步消息 */ public void sendSyncMessage(){ for(int i=0;i&lt
SpringBoot分布式事务之可靠消息最终一致性
asoklove的专栏
03-31 492
环境：springboot2.3.9 + RocketMQ4.8.0 可靠消息最终一致性原理 执行流程 Producer发送Prepare message到broker。 Prepare Message发送成功后开始执行本地事务。 如果本地事务执行成功的话则返回commit，如果执行失败则返回rollback。（这个是在事务消息的回调方法里由开发者自己决定commit or rollback） Producer发送上一步的commit还是rollback到broker，这里有以下两种情况.
school-bus:本项目是基于微服务架构的班车预约系统，采用两个版本第一个版本：springboot+mybatis+dubbo+rocketmq+mysql+redis等。第二个版本：spring-cloud重构，当然，该项目也是前后端分离，前端采用比较流行的vue框架
05-13
RocketMQ(最终一致性、幂等性) Swagger2 Validated Druid监测 Spring定时器 单点登录 Sentinel熔断降级限流 分布式唯一ID(雪花算法) 持续补充... V2 spring-cloud-alibaba 前端： vue vuex vue-router axios vant-ui...
SpringCloud集成RocketMQ实现事务消息方案
热门推荐
传智燕青
09-01 3万+
前边的话 当前SpringCloud作为微服务开发的首选开源方案提供了完善的微服务开发技术套件，不过针对分布式领域的难题–分布式事务控制并没有成熟的方案，本篇将介绍作为柔性事务控制的优秀方案RocketMQ的使用原理和方法。 通过本案例的学习，掌握SpringCloud集成RocketMQ事务分布式事务控制的方法。 RocketMQ事务消息方案 RocketMQ 是一个来自阿里巴巴的分布式消息中间...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值