RocketMQ --- 实战篇

已于 2024-02-26 13:21:55 修改
阅读量4.4k 收藏 91
点赞数 24
分类专栏： 消息队列 文章标签： java-rocketmq rocketmq 运维 java
于 2023-06-26 21:26:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuai_h/article/details/130897445
版权
本文深入探讨了电商场景下基于RocketMQ的下单和支付业务，包括业务分析、技术选型（SpringBoot、Dubbo、Zookeeper、RocketMQ、MySQL），详细讲解了SpringBoot整合RocketMQ的生产者和消费者的配置与使用，以及如何处理失败的补偿机制。同时，还介绍了环境搭建、数据库设计和整体联调的过程。
摘要由CSDN通过智能技术生成

一、案例介绍

1.1、业务分析

模拟电商网站购物场景中的【下单】和【支付】业务

1.1.1、下单

在这里插入图片描述
流程

  1. 用户请求订单系统下单

  2. 订单系统通过RPC调用订单服务下单

  3. 订单服务调用优惠券服务，扣减优惠券

  4. 订单服务调用调用库存服务，校验并扣减库存

  5. 订单服务调用用户服务，扣减用户余额

  6. 订单服务完成确认订单

1.1.2、支付

在这里插入图片描述
流程

  1. 用户请求支付系统
  2. 支付系统调用第三方支付平台API进行发起支付流程
  3. 用户通过第三方支付平台支付成功后，第三方支付平台回调通知支付系统
  4. 支付系统调用订单服务修改订单状态
  5. 支付系统调用积分服务添加积分
  6. 支付系统调用日志服务记录日志

1.2、问题分析

1.2.1、问题1

用户提交订单后，扣减库存成功、扣减优惠券成功、使用余额成功，但是在确认订单操作失败，需要对库存、库存、余额进行回退。

如何保证数据的完整性？

在这里插入图片描述

使用MQ保证在下单失败后系统数据的完整性

在这里插入图片描述

1.2.2、问题2

用户通过第三方支付平台（支付宝、微信）支付成功后，第三方支付平台要通过回调API异步通知商家支付系统用户支付结果，支付系统根据支付结果修改订单状态、记录支付日志和给用户增加积分。

商家支付系统如何保证在收到第三方支付平台的异步通知时，如何快速给第三方支付凭条做出回应？

在这里插入图片描述

通过MQ进行数据分发，提高系统处理性能

在这里插入图片描述

二.、技术分析

2.1、技术选型

  • SpringBoot
  • Dubbo
  • Zookeeper
  • RocketMQ
  • Mysql

在这里插入图片描述

2.2、SpringBoot整合RocketMQ

下载rocketmq-spring项目

将rocketmq-spring安装到本地仓库

mvn install -Dmaven.skip.test=true

2.2.1、消息生产者

2.2.1.1、添加依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>rocketmq-producer</artifactId>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <spring-boot-version>2.3.2.RELEASE</spring-boot-version>
    </properties>

    <dependencies>
        <!-- 配置web启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <!-- rocketMQ -->
        <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

        <!-- lombok插件 -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot-version}</version>
            </plugin>
        </plugins>
    </build>
</project>
2.2.1.2、配置文件
server:
  port: 8094
spring:
  application:
    name: rocketmq-producer

rocketmq:
  name-server: 127.0.0.1:9876          # rocketMQ的名称服务器，格式为:' host:port;host:port '。
  # 生产端配置
  producer:
    group: ${
   spring.application.name}  # 生产着组名
    #access-key: access-key            # rocketMQ服务端配置acl授权信息，没有则不需要
    #secret-key: secret-key            # rocketMQ服务端配置acl授权信息，没有则不需要
  # 消费端配置
#  consumer:
#    access-key: access-key            #如果开启了acl，一定要配置。否则集群模式下会正常，广播模式消费端会失效！
#    secret-key: secret-key            #如果开启了acl，一定要配置。否则集群模式下会正常，广播模式消费端会失效！
2.2.1.3、消息发送
/**
 * <p>
 * RocektMQ 事务消息监听器
 * </p>
 *
 **/
@Slf4j
@RocketMQTransactionListener
public class TransactionListenerImpl implements RocketMQLocalTransactionListener {
   


    /**
     * 检测半消息，在该方法中，执行本地事务
     *
     * @param msg 发送消息
     * @param arg 外部参数
     * @return commit：提交事务，它允许消费者消费此消息。bollback：回滚事务，它代表该消息将被删除，不允许被消费。 unknown：中间状态，它代表需要检查消息队列来确定状态（checkLocalTransaction方法）。
     */
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
   
        log.info(">>>> MQ事务执行器，执行本地事务 message={},args={} <<<<", msg, arg);

        try {
   
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderPaidEvent payload = JSON.parseObject(jsonString, OrderPaidEvent.class);

            //模拟业务操作，当paidMoney >5 则提交，否则等事务会查
            if (payload.getPaidMoney().compareTo(new BigDecimal("5")) > 0) {
   
                //提交事务
                log.info("MQ提交事务啦！payload ={} ", payload);
                return RocketMQLocalTransactionState.COMMIT;
            }

            //不知道状态，转 checkLocalTransaction 回查执行
            log.info("MQ无法确定，等回查！payload ={} ", payload);
            return RocketMQLocalTransactionState.UNKNOWN;
        } catch (Exception e) {
   
            log.error("事务消息出错啦~ e:{}", e.getMessage(), e);
            //回滚
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }


    /**
     * 该方法时MQ进行消息事务状态回查、
     * <p>
     *
     * @param msg
     * @return bollback, commit or unknown
     */
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
   
        log.info(">>>> MQ事务执行器，事务状态回查 message={} <<<<", msg);
        try {
   
            String jsonString = new String((byte[]) msg.getPayload(), StandardCharsets.UTF_8);
            OrderPaidEvent payload = JSON.parseObject(jsonString, OrderPaidEvent.class);

            log.info("事务回查：checkLocalTransaction提交事务啦！payload ={} ", payload);
            return RocketMQLocalTransactionState.COMMIT;
        } catch (Exception e) {
   
            log.error("回调的事务出错啦~ e:{}", e.getMessage(), e);
            return RocketMQLocalTransactionState.ROLLBACK;
        }
    }
}

/**
 * <p>
 * RocektMQ生产者常用发送消息方法
 * 最佳实践:https://github.com/apache/rocketmq/blob/master/docs/cn/best_practice.md
 * </p>
 *
 **/
public interface IRocketMQService {
   

    /**
     * 发送同步消息（这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。）
     * <p>
     * （send消息方法只要不抛异常，就代表发送成功。但不保证100%可靠投递(所有消息都一样，后面不在叙述)。
     * 要确保不会丢失任何消息，还应启用同步Master服务器或同步刷盘，即SYNC_MASTER或SYNC_FLUSH。
     * 解析看：https://github.com/apache/rocketmq/blob/master/docs/cn/best_practice.md
     * ）
     *
     * @param destination 主题名:标签 topicName:tags
     * @param msg         发送对象
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendMessage(String destination, Object msg);

    /**
     * 发送同步消息（这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。）
     *
     * @param topicName 主题名 topicName
     * @param tags      标签 tags
     * @param msg       发送对象
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendMessage(String topicName, String tags, Object msg);

    /**
     * 发送同步消息（这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。）
     *
     * @param topicName 主题名 topicName
     * @param tags      标签 tags
     * @param key       唯一标识码要设置到keys字段，方便将来定位消息丢失问题
     * @param msg       发送对象
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendMessage(String topicName, String tags, String key, Object msg);

    /**
     * 发送同步消息-SQL92模式
     * 需要配置RocketMQ服务器  vim conf/broker.conf  ##支持sql语句过滤  enablePropertyFilter=true
     * 在console控制台查看集群状态  enablePropertyFilter=true 才正常
     *
     * @param topicName 主题名 topicName
     * @param map       自定义属性
     * @param msg       发送对象
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendMessageBySql(String topicName, Map<String, Object> map, Object msg);


    /**
     * 发送同步消息-SQL92模式
     * 需要配置RocketMQ服务器  vim conf/broker.conf  ##支持sql语句过滤  enablePropertyFilter=true
     * 在console控制台查看集群状态  enablePropertyFilter=true 才正常
     *
     * @param topicName 主题名 topicName
     * @param map       自定义属性
     * @param key       唯一标识码要设置到keys字段，方便将来定位消息丢失问题
     * @param msg       发送对象
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendMessageBySql(String topicName, Map<String, Object> map, String key, Object msg);


    /**
     * 发生异步消息（异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。）
     *
     * @param destination  主题名:标签 topicName:tags
     * @param msg          发送对象
     * @param sendCallback 异步回调函数
     */
    void sendAsyncMessage(String destination, Object msg, SendCallback sendCallback);

    /**
     * 发送单向消息（这种方式主要用在不特别关心发送结果的场景，例如日志发送。）
     *
     * @param destination 主题名:标签 topicName:tags
     * @param msg         发送对象
     */
    void sendOneway(String destination, Object msg);

    /**
     * 发送批量消息(发送超过1MB,做了自动分割,超时时间设置30s（默认3s）)，注：默认最大是4MB，为了避免ListSplitter.calcMessageSize计算不精确及大批量数据发送超时才设置1MB
     *
     * @param destination 主题名:标签 topicName:tags
     * @param list        批量消息
     */
    void sendBatchMessage(String destination, List<?> list);


    /**
     * 发送批量消息(发送超过1MB,做了自动分割。)，注：默认最大是4MB，为了避免ListSplitter.calcMessageSize计算不精确及大批量数据发送超时才设置1MB
     *
     * @param topicName 主题名 topicName
     * @param tags      标签 tags
     * @param timeout   超时时间,空则默认设为30s
     * @param list      批量消息
     */
    void sendBatchMessage(String topicName, String tags, Long timeout, List<?> list);

    /**
     * 发送延时消息（超时时间，设置30s（默认3s））
     * 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
     * 1  2  3   4   5  6  7  8  9  10 11 12 13 14  15  16  17 18
     *
     * @param destination    主题名:标签 topicName:tags
     * @param msg            发送对象
     * @param delayTimeLevel 延时等级(从1开始)
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendDelayLevel(String destination, Object msg, int delayTimeLevel);

    /**
     * 发送延时消息
     * 1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
     * 1  2  3   4   5  6  7  8  9  10 11 12 13 14  15  16  17 18
     *
     * @param destination    主题名:标签 topicName:tags
     * @param msg            发送对象
     * @param timeout        超时时间（单位毫秒）
     * @param delayTimeLevel 延时等级(从1开始)
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendDelayLevel(String destination, Object msg, int timeout, int delayTimeLevel);


    /**
     * 发送顺序消息(分区有序,多个queue参与，即相对每个queue，消息都是有序的。)
     *
     * @param destination 主题名:标签 topicName:tags
     * @param msg         发送对象
     * @param hashKey     根据其哈希值取模后确定发送到哪一个queue队列
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendInOrder(String destination, Object msg, String hashKey);


    /**
     * 发送事务消息
     * 事务消息使用上的限制
     * 1:事务消息不支持延时消息和批量消息。
     * 2:为了避免单个消息被检查太多次而导致半队列消息累积，我们默认将单个消息的检查次数限制为 15 次，但是用户可以通过 Broker 配置文件的 transactionCheckMax参数来修改此限制。如果已经检查某条消息超过 N 次的话（ N = transactionCheckMax ） 则 Broker 将丢弃此消息，并在默认情况下同时打印错误日志。用户可以通过重写 AbstractTransactionalMessageCheckListener 类来修改这个行为。
     * 3:事务消息将在 Broker 配置文件中的参数 transactionTimeout 这样的特定时间长度之后被检查。当发送事务消息时，用户还可以通过设置用户属性 CHECK_IMMUNITY_TIME_IN_SECONDS 来改变这个限制，该参数优先于 transactionTimeout 参数。
     * 4:事务性消息可能不止一次被检查或消费。
     * 5:提交给用户的目标主题消息可能会失败，目前这依日志的记录而定。它的高可用性通过 RocketMQ 本身的高可用性机制来保证，如果希望确保事务消息不丢失、并且事务完整性得到保证，建议使用同步的双重写入机制。
     * 6:事务消息的生产者 ID 不能与其他类型消息的生产者 ID 共享。与其他类型的消息不同，事务消息允许反向查询、MQ服务器能通过它们的生产者 ID 查询到消费者。
     *
     * @param destination 主题名:标签 topicName:tags
     * @param msg         发送对象
     * @param arg         arg
     * @return 发送结果，只有为SEND_OK且同步Master服务器或同步刷盘才保证100%投递成功
     */
    SendResult sendMessageInTransaction(String destination, Object msg, Object arg);
}

/**
 * <p>
 * RocektMQ生产者常用发送消息方法
 * 最佳实践:https://github.com/apache/rocketmq/blob/master/docs/cn/best_practice.md
 * </p>
 *
 */
@Slf4j
@Service
public class RocketMQServiceImpl implements IRocketMQService {
   

    @Autowired
    private RocketMQTemplate rocketMqTemplate;

    /**
     * 原生的producer
     */
    @Autowired
    private DefaultMQProducer producer;

    @Override
    public SendResult sendMessage(String destination, Object msg) {
   
        String[] split = destination.split(":");
        if (split.length == 2) {
   
            return this.sendMessage(split[0], split[1], msg);
        }
        return this.sendMessage(destination, null, msg);
    }

    @Override
    public SendResult sendMessage(String topicName, String tags, Object msg) {
   
        return this.sendMessage(topicName, tags, null, msg);
    }

    @Override
    public SendResult sendMessage(String topicName, String tags, String key, Object msg) {
   
        MessageBuilder<?> messageBuilder = MessageBuilder.withPayload(msg);
        //设置key,唯一标识码要设置到keys字段，方便将来定位消息丢失问题
        if (StringUtils.isNotBlank(key)) {
   
            messageBuilder.setHeader(MessageConst.PROPERTY_KEYS, key);
        }
        Message<?> message = messageBuilder.build();
        SendResult sendResult = this.rocketMqTemplate.syncSend(StringUtils.isBlank(tags) ? topicName : (topicName + ":" + tags), message);
        if (SendStatus.SEND_OK.equals(sendResult.getSendStatus())) {
   
            log.info("MQ发送同步消息成功,topicName={},tags={},msg={},sendResult={}", topicName, tags, msg, sendResult);
        } else {
   
            log.warn("MQ发送同步消息不一定成功,topicName={},tags={},msg={},sendResult={}", topicName, tags, msg, sendResult);
        }
        return sendResult;
    }

    @Override
    public SendResult sendMessageBySql(String topicName, Map<String, Object> map, Object msg) {
   
        return this.sendMessageBySql(topicName, map, null, msg);
    }

    @Override
    public SendResult sendMessageBySql(String topicName, Map<String, Object> map, String key, Object msg) {
   
        MessageBuilder<?> messageBuilder = MessageBuilder.withPayload(msg);
        //设置key,唯一标识码要设置到keys字段，方便将来定位消息丢失问题
        if (StringUtils.isNotBlank(key)) {
   
            messageBuilder.setHeader(MessageConst.PROPERTY_KEYS, key);
        }
        //设置自定义属性
        if (map != null && !map.isEmpty()) {
   
            for (Map.Entry<String, Object> entry : map.entrySet()) {
   
                messageBuilder.setHeader(entry.getKey(), entry.getValue());
            }
        }
        Message<?> message = messageBuilder.build();
        SendResult sendResult = this.rocketMqTemplate.syncSend(topicName, message);
        if (SendStatus.SEND_OK.equals(sendResult.getSendStatus())) {
   
            log.info("发送同步消息-SQL92模式成功,topicName={},map={},msg={},sendResult={}", topicName, map, msg, sendResult);
        } else {
   
            log.warn("发送同步消息-SQL92模式不一定成功,topicName={},map={},msg={},sendResult={}", topicName, map, msg, sendResult);
        }
        return sendResult;
    }

    @Override
    public void sendAsyncMessage(String destination, Object msg, SendCallback sendCallback) {
   
        this.rocketMqTemplate.asyncSend(destination, msg, sendCallback);
        log.info("MQ发送异步消息,destination={} msg={}", destination, msg);
    }

    @Override
    public void sendOneway(String destination, Object msg) {
   
        this.rocketMqTemplate.sendOneWay(destination, msg);
        log.info("MQ发送单向消息,destination={} msg={}", destination, msg);
    }

    @Override
    public void sendBatchMessage(String destination, List<?> list) {
   
        String topicName = destination;
        String tags = "";

        String[] split = destination.split(":");
        if (split.length == 2) {
   
            topicName = split[0];
            tags = split[1];
        }
        this.sendBatchMessage(topicName, tags, 30000L, list);
    }

    @Override
    public void sendBatchMessage(String topicName, String tags, Long timeout, List<?> list) {
   
        //转为message
        List<org.apache.rocketmq.common.message.Message> messages = list.stream().map(x ->
                new org.apache.rocketmq.common.message.Message(topicName, tags,
                        //String类型不需要转JSON，其它类型都要转为JSON模式
                        x instanceof String ? ((String) x).getBytes(StandardCharsets.UTF_8) : JSON.toJSONBytes(x))
        ).collect(Collectors.toList());

        //自动分割发送，把大的消息分裂成若干个小的消息(每次发送最大只能4MB)
        ListSplitter splitter = new ListSplitter(messages);

        while (splitter.hasNext()) {
   
            try {
   
                List<org.apache.rocketmq.common.message.Message> listItem = splitter.next();
                SendResult sendResult = producer.send(listItem, timeout == null ? 30000L : timeout);
                if (SendStatus.SEND_OK.equals(sendResult.getSendStatus())) {
   
                    log.info("MQ发送批量消息成功,topicName={}  tags={}， size={},sendResult={}", topicName, tags, listItem.size(), sendResult);
                } else {
   
                    log.warn("MQ发送批量消息不一定成功,topicName={}  tags={}， size={},sendResult={}", topicName, tags, listItem.size(), sendResult);
                }
            } catch (Exception e) {
   
                //处理error
                log.error("MQ发送批量消息失败,topicName={}  tags={}，,errorMessage={}", topicName, tags, e.getMessage(), e);
                throw new RuntimeException("MQ发送批量消息失败,原因：" + e.getMessage());
            }
        }
    }

    @Override
    public SendResult sendDelayLevel(String destination, Object msg, int delayTimeLevel) {
   
        return this.sendDelayLevel(destination, msg, 30000, delayTimeLevel);
    }

    @Override
    public SendResult sendDelayLevel(String destination, Object msg, int timeout, int delayTimeLevel) {
   
        Message<?> message = MessageBuilder
                .withPayload(msg)
                .build();
        SendResult sendResult = this.rocketMqTemplate.syncSend(destination, message, timeout, delayTimeLevel);
        if (SendStatus.SEND_OK.equals(sendResult.getSendStatus())) {
   
            log.info("MQ发送延时消息成功,destination={} msg={} sendResult={}", destination, message, sendResult);
        } else {
   
            log.warn("MQ发送延时消息不一定成功,destination={} msg={} sendResult={}", destination, message, sendResult);
        }
        return sendResult;
    }

    @Override
    public SendResult sendInOrder(String destination, Object msg, String hashKey) {
   
        Message<?> message = MessageBuilder
                .withPayload(msg)
                .build();
        //hashKey:  根据其哈希值取模后确定发送到哪一个队列
        SendResult sendResult = this.rocketMqTemplate.syncSendOrderly(destination, message, hashKey);
        if (SendStatus.SEND_OK.equals(sendResult.getSendStatus())) {
   
            log.info("MQ发送顺序消息成功,destination={} msg={} sendResult={}", destination, message, sendResult);
        } else {
   
            log.warn("MQ发送顺序消息不一定成功,destination={} msg={} sendResult={}", destination, message, sendResult);
        }
        return sendResult;
    }

    @Override
    public SendResult sendMessageInTransaction(String destination, Object msg, Object arg) {
   
        Message<?> message = MessageBuilder
                //转为JSON格式
                .withPayload(msg instanceof String ? msg : JSON.toJSONString(msg))
                .build();

        TransactionSendResult sendResult = rocketMqTemplate.sendMessageInTransaction(destination, message, arg);

        if (SendStatus.SEND_OK.equals(sendResult.getSendStatus())) {
   
            log.info("MQ发送事务消息成功,destination={} msg={} sendResult={}", destination, message, sendResult);
        } else {
   
            log.warn("MQ发送事务消息不一定成功,destination={} msg={} sendResult={}", destination, message, sendResult);
        }
        return sendResult;
    }
}

/**
 * <p>
 * 消息列表分割,复杂度只有当你发送大批量时才会增长，你可能不确定它是否超过了大小限制（4MB）。这时候你最好把你的消息列表分割一下：
 * </p>
 *
 **/
public class ListSplitter implements Iterator<List<Message>> {
   
    /**
     * 最大4MB，这里每次只发送1MB。（为了避免ListSplitter.calcMessageSize计算不精确及大批量数据发送超时才设置1MB）
     */
    private final int SIZE_LIMIT = 1024 * 1024 * 1;
    private final List<Message> messages;
    private int currIndex;

    public ListSplitter(List<Message> messages) {
   
        this.messages = messages;
    }

    @Override
    public boolean hasNext() {
   
        return currIndex < messages.size();
    }

    @Override
    public List<Message> next() {
   
        int startIndex = getStartIndex();
        int nextIndex = startIndex;
        int totalSize = 0;
        for (; nextIndex < messages.size(); nextIndex++) {
   
            Message message = messages.get(nextIndex);
            int tmpSize = calcMessageSize(message);
            if (tmpSize + totalSize > SIZE_LIMIT) {
   
                break;
            } else {
   
                totalSize += tmpSize;
            }
        }
        List<Message> subList = messages.subList(startIndex, nextIndex);
        currIndex = nextIndex;
        return subList;
    }

    private int getStartIndex() {
   
        Message currMessage = messages.get(currIndex);
        int tmpSize = calcMessageSize(currMessage);
        while (tmpSize >
最低0.47元/天 解锁文章
大迂居士
关注
  • 24
    点赞
  • 踩
  • 91
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
RocketMQ快速入门实战
流楚丶格念的博客
07-23 3227
主题相当于消息的一级分类，具有相同topic的消息将发送至该topic下的消息队列中，比方说一个电商系统可以分为商品消息、订单消息、物流消息等，就可以在broker中创建商品主题、订单主题等，所有商品的消息发送至该主题下的消息队列中。producer向broker发送消息时指定消息发送成功及发送异常的回调方法，调用API后立即返回，producer发送消息线程不阻塞，消息发送成功或失败的回调任务在一个新的线程中执行。消息的最大长度是4M。.........
RocketMQ 学习笔记及项目实战
超超IT的博客
05-30 946
什么是 RocketMQ? RocketMQ 是众多 MQ 中的一种，属于Alibaba旗下，使用JAVA语言开发的一款消息中间件，具有高性能、高可靠、高实时、分布式特点。MQ的全称是 Message Queue 消息队列，使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。 RocketMQ的重要组成部分 现实生活中的邮政系统要正常运行，离不开下面这四个角色， 一是发信者， 二是收信者， 三是负责暂存、传输的邮局， 四是负责协调各个地方邮局的管
RocketMQ-六大场景实操指南
csdn565973850的博客
07-10 1008
介绍RocketMQ 六大场景 普通消息场景、定时消息场景、事务消息场景、顺序消息场景、消息堆积场景、消息失败重投场景、消息异常运维 的实操相关内容
rocket MQ 实战应用
拒绝躺平，适当内卷
10-14 3192
rocketmq 开发实例，springboot 集成
RocketMQ指南（一）基础篇&实战篇
最新发布
YE1208030123的博客
08-24 902
消息队列是一种“先进先出”的数据结构 其应用场景主要包含以下3个方面系统的耦合性越高，容错性就越低。以电商应用为例，用户创建订单后，如果耦合调用库存系统、物流系统、支付系统，任何一个子系统出了故障或者因为升级等原因暂时不可用，都会造成下单操作异常，影响用户使用体验。 使用消息队列解耦合，系统的耦合性就会提高了。比如物流系统发生故障，需要几分钟才能来修复，在这段时间内，物流系统要处理的数据被缓存到消息队列中，用户的下单操作正常完成。当物流系统回复后，补充处理存在消息队列中的订单消息即可，终端系统感知不到物
超详细的RocketMq知识点讲解以及实战
weixin_44291453的博客
08-29 3498
一，什么是Rocketmq？ rocketmq是阿里借鉴kafaka改造和优化而来的,用的是java语言写的。支持了阿里历年的双十一，系统的稳定性是很可靠的。 二，rocketmq的应用场景 *应用解耦 可以解耦出一些系统，用RocketMq进行解耦，例如将订单发到RocketMQ中，然后订单系统对其消费 *流量削峰 如果系统有大量的请求过来，很可能导致系统奔溃，我们可以将消息发到RocketMQ中进行消息缓存，然后分散处理 *数据分发 我们可以将信息发到rocketMq中，由下游系统去选择
RocketMQ实战
qq_38900306的博客
01-25 292
1.新建开发环境 新建一个maven工程,在pom.xml文件中加入如下依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org
RocketMQ实战与最佳实践
KIMTOU的博客
09-21 1306
实战应用 maven依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-client</artifactId> <version>4.9.1</version> </dependency> 普通消息 消息发送 1、Producer端发送同步消息 这种可靠性同步地发送方式使用的比较广泛，比
RocketMQ 实战入门
xusanyao的博客
02-07 744
RocketMQ 是什么 Github 上关于 RocketMQ 的介绍： RcoketMQ 是一款低延迟、高可靠、可伸缩、易于使用的消息中间件。具有以下特性： 支持发布/订阅（Pub/Sub）和点对点（P2P）消息模型在一个队列中可靠的先进先出（FIFO）和严格的顺序传递支持拉（pull）和推（push）两种消息模式单一队列百万消息的堆积能力支持多种消息协议，如 JMS、MQTT 等分
RocketMQ实战与原理
10-17
Producer: 生产者，负责生产消息并发送到消息引擎。测评开始时，测评程序会启动10~20个Producer，每个Producer在一条线程中，然后每个Producer随机生产某个Topic或者附属于Queue的消息并发送到消息引擎； Topic: 消息主题。 Queue: 队列。抽象的概念，消息可以发送到特定的队列，或者属于某个特定的Topic Consumer：消费者。每个消费者必须attach到某个特定的Queue上，而且Consumer和Queue是一一对应关系。同时，Consumer可以订阅多个Topic。测评程序开始消费时，会启动10~20个Consumer，每个Consumer属于一条线程，而且attach到一个queue上，并订阅多个Topic。对于被多个Consumer订阅的某个Topic，这些Consumer直接的消费应该是独立的，也就是每个Consumer都应该全量消费这个Topic的消息。
rocketmq实例代码
11-09
RocketMQ是一个纯java、分布式、队列模型的开源消息中间件，前身是Metaq，当 Metaq 3.0发布时，产品名称改为 RocketMQ。
java -RocketMQ实战视频教程（上下全集）
01-25
废话不多说，懂的来！！我也是花钱买来的，要收点C分。
rocketMq实战(3)-console和运维
06-10
RocketMQ实战(3)-Console和运维 RocketMQ是阿里巴巴开源的一款分布式消息中间件，它具有高吞吐量、低延迟、高可用性以及强大的消息模型等特点。在本篇实战中，我们将聚焦于RocketMQ的控制台（Console）及其运维相关...
Mall4j商城实战 - 部署 rocketmq-namesrv、rocketmq-broker、rocketmq-dashboard 消息队列
yueerba126的博客
11-15 174
RocketMQ 是一个开源的分布式消息和流处理平台，主要用于处理大规模的数据传输。它包括几个关键组件，每个组件都承担着不同的角色。其中。
性能调优篇-困扰我半年多的RocketMQ-timeout-exception-终于被破解了
2401_84048290的博客
04-21 793
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
一张图进阶 RocketMQ - 通信机制
三此君的博客
07-14 831
三此君看了好几本书，看了很多遍源码整理的 一张图进阶 RocketMQ 图片链接，关于 RocketMQ 你只需要记住这张图。 今天我们先聊一聊 Netty 基本流程，然后分析 RocketMQ 的通信机制，最后通过异步消息发送来串联 RocketMQ 通信机制...............
rocketmq-client-go
09-03
RocketMQ是阿里巴巴开源的分布式消息中间件，而rocketmq-client-go是其针对Go语言开发的客户端库。 rocketmq-client-go提供了与RocketMQ Broker进行连接和交互的功能，可以方便地使用Go语言发送和接收消息。它支持顺序消息和广播消息模式，可以根据业务需求选择最适合的消息模式。 使用rocketmq-client-go，我们可以通过创建一个生产者来发送消息到RocketMQ消息队列，也可以创建一个消费者来订阅并消费队列中的消息。通过创建消费者组，可以实现消息的负载均衡和容错处理。 rocketmq-client-go还提供了一些高级特性，比如延迟消息、定时消息和事务消息。延迟消息可以让消息在指定的时间之后才被消费，定时消息可以让消息在指定的时间点被发送，而事务消息可以保证消息的可靠性传输和处理。 此外，rocketmq-client-go还支持消息过滤功能，可以根据一些条件来过滤和选择需要消费的消息，提高消费的效率。 总之，rocketmq-client-go是一个功能强大的Go语言客户端库，可以方便地与RocketMQ Broker进行交互，实现消息的生产、消费和处理。它提供了很多高级特性和功能，可以满足各种不同场景下的需求。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值