springboot整合RocketMQ的各种消息类型，生产者，消费者

最新推荐文章于 2024-08-21 10:39:19 发布
最新推荐文章于 2024-08-21 10:39:19 发布
阅读量2.8k 收藏 18
点赞数 3
分类专栏： 框架依赖 linux服务 文章标签： java 中间件 spring
无想的一刀，斩断浮世——很高兴能帮到你，开心就点个赞～啦啦啦啦啦～
本文链接：https://blog.csdn.net/unicornre/article/details/117849396
版权

文章目录

Springboot整合使用

pom依赖

 <dependency>
        <groupId>org.apache.rocketmq</groupId>
        <artifactId>rocketmq-spring-boot-starter</artifactId>
        <version>2.1.0</version>
</dependency>

yml

group: producer-demo1指定生产者组名

rocketmq:
  name-server: 192.168.126.100:9876;192.168.64.152:9876
  producer:
    #生产者组名，规定在一个应用里面必须唯一
    group: group-1
    #消息发送的超时时间，默认为3000ms
    send-message-timeout: 3000
    #消息达到4096字节的时候，消息就会被压缩。默认4096
    compress-message-body-threshold: 4096
    #最大的消息限制 默认为128K
    max-message-size: 4194304
    #同步消息发送失败重试次数
    retry-times-when-send-failed: 3
    #在内部发送失败时是否重试其他代理,这个参数在有多个broker才生效。
    retry-next-server: true
    #异步消息发送失败重试的次数
    retry-times-when-send-async-failed: 3

整合使用

消息类型不同比如string,pojo实体类型需要分不同的topic，同consumer-group需要对应一种topic，consumer不管配置什么topic，tag，最后都是以group为准

（如果某个consumer的group名字与group-name1相同，但这个consumer的topic信息与group-name1这个组的topic不同，这会导致group-name1这个组的consumer不能接收全部消息，也就是会导致部分消息无法被消费，所以不要乱操作）

（如果group不同但是topic和tag都相同，那么所有group都会消费同样的消息，有多少个group就消费多少次）

（一台机器可部署多个consumer，需要保证他们的group-name不同，通常topic与group一一对应，所以topic也不同）

为方便查看，示例关键代码
某个service层的实现类MQServiceImpl

package com.ro.service;
import com.ro.pojo.User;
import org.apache.rocketmq.client.producer.*;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.apache.rocketmq.spring.support.RocketMQHeaders;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.PayloadApplicationEvent;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

@Service
public class MQServiceImpl implements MQService{

    Logger log= LoggerFactory.getLogger(MQServiceImpl.class);
    @Autowired
    private RocketMQTemplate mqTemplate;

    /**
     * 同步消息
     * 消息发送方发出数据后，会在收到接收方发回响应之后才发下一个数据包的通讯方式
     */
    @Override
    public void syncMQMessageSend() {
        mqTemplate.syncSend("topic1:tag1", "hello1");
        mqTemplate.syncSend("topic1:tag1", "hello2");
        SendResult s2=mqTemplate.syncSend("topic1:tag1", "hello3");
        log.info("3条同步消息String类型已发送:topic:topic1,tag:tag1:{}",s2);
        User user=new User("tom",100);
        SendResult result=mqTemplate.syncSend("topic2:tag1", MessageBuilder.withPayload(user).build());
        //可以简写成以下，直接传入pojo对象
        SendResult result2=mqTemplate.syncSend("topic2:tag1", user.setName("lily").setAge(200));
        log.info("object类型同步消息发送结果:{},{}",result,result2);
    }

    /**
     * 异步消息
     * 指发送方发出数据后，不等接收方发回响应，接着发送下个数据包
     * 关键实现异步发送回调接口（SendCallback）
     * 在执行消息的异步发送时应用不需要等待服务器响应即可直接返回，通过回调接口接收务器响应，并对服务器的响应结果进行处理
     * 这种方式任然需要返回发送消息任务的执行结果，异步不影响后续任务，不会造成阻塞
     */
    @Override
    public void asyncMQMessageSend() {
        User user=new User("tom",100);
        mqTemplate.asyncSend("topic3:tag1", user, new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("异步消息发送成功:{}",sendResult);
            }

            @Override
            public void onException(Throwable throwable) {
                log.info("异步消息发送失败:{}",throwable.getMessage());
            }
        });
    }

    /**
     * 单向消息
     * 特点为只负责发送消息，不等待服务器回应且没有回调函数触发，即只发送请求不等待应答
     * 此方式发送消息的过程耗时非常短，一般在微秒级别
     * 应用场景：适用于某些耗时非常短，但对可靠性要求并不高的场景，例如日志收集
     */
    @Override
    public void oneWaySendMQMessageSend() {
        User user=new User("tom",100);
        mqTemplate.sendOneWay("topic4:tag1", user);
        log.info("单向消息已发送");
    }
    /**
     * 延迟消息
     * rocketMQ的延迟消息发送其实是已发送就已经到broker端了，然后消费端会延迟收到消息。
     * RocketMQ 目前只支持固定精度的定时消息。
     * 固定等级：1到18分别对应1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h
     * 延迟的底层方法是用定时任务实现的。
     */
    @Override
    public void delayedSendMQMessageSend() {
        User user=new User("tom",100);
        SendCallback sc=new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("发送异步延时消息成功");
            }

            @Override
            public void onException(Throwable throwable) {
                log.info("发送异步延时消息失败:{}",throwable.getMessage());
            }
        };
        Message<User> message=MessageBuilder.withPayload(user).build();
        //异步延时
        mqTemplate.asyncSend("topic5:tag1", message, sc, 3000, 3);
        //同步延时（少一个sendCallback）
        SendResult result=mqTemplate.syncSend("topic5:tag1", message, 3000, 3);
        log.info("发送同步延时消息成功:{}",result);
    }

    /**
     * 顺序消息
     *使用hashcode对topic队列数量取模得到对应队列
     * 使消息按照顺序被消费，顺序与生产出来的顺序一致
     * 比如同一个订单生成，付费顺序需要一致，可以按照订单id来当作hashkey
     */
    @Override
    public void orderlyMQMessageSend() {
        String s1[]={"tom","1"};
        String s2[]={"klee我和tom在同一个消费者被消费，而且在tom之后","1"};
        String s3[]={"lily我可能不会和tom在同一个消费者被消费","2"};
        //同步顺序，也可以是其他类型比如异步顺序，单向顺序
        mqTemplate.syncSendOrderly("topic6:tag1", s1[0],s1[1]);
        mqTemplate.syncSendOrderly("topic6:tag1", s2[0],s2[1]);
        mqTemplate.syncSendOrderly("topic6:tag1", s3[0],s3[1]);
        log.info("单向消息已发送");
    }

    /**
     * 过滤消息
     * Tag 过滤
     * Sql 过滤
     * Sql类型语法：
     * 数值比较，比如：>，>=，<，<=，BETWEEN，=；
     * 字符比较，比如：=，<>，IN；
     * IS NULL 或者 IS NOT NULL；
     * 逻辑符号 AND，OR，NOT；
     */
    @Override
    public void selectorMQSend() {
        //Tag过滤就是在发送参数上指定，比如topic1:tag1就指定了tag1，这种光topic1不指定就是所有tag
        //这里使用sql92
        User user=new User("tom",16);
        User user2=new User("klee",9);
        Message<User> message=MessageBuilder
                .withPayload(user)
                .setHeader("age", user.getAge())
                .build();
        Message<User> message2=MessageBuilder
                .withPayload(user)
                .setHeader("age", user2.getAge())
                .build();
        mqTemplate.syncSend("topic10", message);//age=16,消费者设置sql92过滤(header)头数据age=9
        mqTemplate.syncSend("topic10", message2);//age=9
        log.info("添加age头信息的过滤消息发送完毕");
    }

    /**
     * 分布式事物消息
     *生产者需要一个监听自己的类
     */
    @Override
    public void transactionMQSend() {
        User user=new User("klee",9);
        Message<User> message=MessageBuilder
                .withPayload(user)
                .setHeader(RocketMQHeaders.TRANSACTION_ID, UUID.randomUUID())
                .build();
        TransactionSendResult result=mqTemplate.sendMessageInTransaction("topic15:tag1", message, null);
        if(result.getLocalTransactionState().equals(LocalTransactionState.COMMIT_MESSAGE)
                &&
                result.getSendStatus().equals(SendStatus.SEND_OK)){
           log.info("事物消息发送成功");

        }
        log.info("事物消息发送结果:{}",result);
    }
}

同步消息消费者

package com.ro.configure;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(consumerGroup = "consumer-group-1",topic = "topic1",selectorExpression = "tag1")
public class MQConsumer implements RocketMQListener<String> {
    Logger log= LoggerFactory.getLogger(MQConsumer.class);
    @Override
    public void onMessage(String s) {
        log.info("consumer-1 收到string类型消息:{}",s);
    }
}


package com.ro.configure;
import com.ro.pojo.User;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(consumerGroup = "consumer-group-2",topic = "topic2",selectorExpression = "tag1")
public class MQConsumer implements RocketMQListener<User> {
    Logger log= LoggerFactory.getLogger(MQConsumer.class);
    @Override
    public void onMessage(User u) {
        log.info("consumer-2 收到user类型消息:{}",u);
    }
}

异步消息消费者

代码与同步消费者相同

单向消息消费者

代码与同步消费者相同

延时消息消费者

代码与同步消费者相同

顺序消息消费者

只需要在之前的基础上指定consumeMode = ConsumeMode.ORDERLY

package com.ro.configure;
import com.ro.pojo.User;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
@RocketMQMessageListener(consumeMode = ConsumeMode.ORDERLY,consumerGroup = "consumer-orderly",topic = "topic6",selectorExpression = "tag1")
public class MQConsumerOrderly implements RocketMQListener<String> {
    Logger log= LoggerFactory.getLogger(MQConsumerOrderly.class);
    @Override
    public void onMessage(String s) {
        log.info("接收到顺序消息了:{}",s);
    }
}

sql92过滤消息消费者

更多rocketmq集群方案安装配置请查看我的其他文章
https://blog.csdn.net/UnicornRe/article/details/117745226
需要在安装的配置文件xxx.conf加入

#支持sql92
enablePropertyFilter=true

sql语法

数值比较，比如：>，>=，<，<=，BETWEEN，=；
字符比较，比如：=，<>，IN；
IS NULL 或者 IS NOT NULL；
逻辑符号 AND，OR，NOT；

package com.ro.configure;
import com.ro.pojo.User;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.MessageModel;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.annotation.SelectorType;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
//selectorExpression指明了只能接收消息属性（header）中age的消息。
@RocketMQMessageListener(
        selectorType = SelectorType.SQL92,
        consumerGroup = "consumer-selector",
        topic = "topic10",
        selectorExpression = "age = 9")
public class MQConsumer implements RocketMQListener<User> {
    Logger log= LoggerFactory.getLogger(MQConsumer.class);
    @Override
    public void onMessage(User u) {
        log.info("接收到sql过滤消息了:{}",u);
    }
}

事物消息消费者

发送方向 MQ 服务端发送消息。
MQ Server 将消息持久化成功之后，向发送方 ACK 确认消息已经发送成功，此时消息为半消息。
发送方开始执行本地事务逻辑。
发送方根据本地事务执行结果向 MQ Server 提交二次确认（Commit 或是 Rollback），MQ Server 收到 Commit 状态则将半消息标记为可投递，订阅方最终将收到该消息；MQ Server 收到 Rollback 状态则删除半 消息，订阅方将不会接受该消息。
在断网或者是应用重启的特殊情况下，上述步骤4提交的二次确认最终未到达 MQ Server，经过固定时间后 MQ Server 将对该消息发起消息回查。
发送方收到消息回查后，需要检查对应消息的本地事务执行的最终结果。
发送方根据检查得到的本地事务的最终状态再次提交二次确认，MQ Server 仍按照步骤4对半消息进行操作。

producer需要一个监听类

package com.ro.configure;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.apache.rocketmq.spring.support.RocketMQHeaders;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@RocketMQTransactionListener
public class TransactionListner implements RocketMQLocalTransactionListener {
    Logger log= LoggerFactory.getLogger(TransactionListner.class);
    //保障线程安全且保证高性能的hashmap，用来记录执行结果
    private static Map<String,RocketMQLocalTransactionState> transStateMap=new ConcurrentHashMap<>();
    //执行本地事物
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message message, Object o) {
        //方法里的object o这个对象是生产者发送消息方法最后一个参数的值
        String transId=(String)message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID);
        log.info("事物id:{}",transId);
        try {
            //模拟执行任务
            Thread.sleep(10000);
            //执行成功后记录执行结果
            transStateMap.put(transId, RocketMQLocalTransactionState.COMMIT);
            return RocketMQLocalTransactionState.COMMIT;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //try以外执行失败后
        transStateMap.put(transId, RocketMQLocalTransactionState.ROLLBACK);
        return RocketMQLocalTransactionState.ROLLBACK;
    }

    //回查
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message message) {
        String transId = (String)message.getHeaders().get(RocketMQHeaders.TRANSACTION_ID);
        System.out.println("回查消息");
        return transStateMap.get(transId);
    }
}

消费者consumer

package com.ro.configure;
import com.ro.pojo.User;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.annotation.RocketMQTransactionListener;
import org.apache.rocketmq.spring.annotation.SelectorType;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionListener;
import org.apache.rocketmq.spring.core.RocketMQLocalTransactionState;
import org.apache.rocketmq.spring.support.RocketMQHeaders;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Component
@RocketMQMessageListener(
        selectorType = SelectorType.TAG,
        consumerGroup = "consumer-transaction",
        topic = "topic15",
        selectorExpression = "tag1")
public class MQConsumerTransaction implements RocketMQListener<User> {
    Logger log= LoggerFactory.getLogger(MQConsumerTransaction.class);

    @Override
    public void onMessage(User user) {
        log.info("接收到事物消息:{}",user);
    }
}

@RocketMQMessageListener参数解释

selectorType
过滤标签
SelectorType.TAG ----->selectorExpression = “tagName”
SelectorType.SQL92 --------->selectorExpression =“sql语法条件”
consumerGroup
指定消费者组名称，通常对应一个topic
topic
指定主题
consumeMode
消费类型
ConsumeMode.ORDERLY ------>顺序消息必用
ConsumeMode.CONCURRENTLY--------->其他消息

我的rocketmq各种集群方案安装

https://blog.csdn.net/UnicornRe/article/details/117745226

可——叹——落叶飘零
关注
专栏目录
SpringBoot 2整合rocketMQ 顺序消息、延时消息、批量消息
liuerchong的博客
06-07 1730
顺序消息 RocketMQ 默认消息同时的，但是在有些场景需要队列中的消息有顺序性，比如：发送了一条添加数据的消息，然后接着发送了一条更改数据的消息，此时肯定需要添加数据的消息先被消费，在rocketmq中可以指定消费者的consumeMode，其有两个属性CONCURRENTLY、ORDERLY，ORDERLY便是让一个队列中的数据有顺序的消费，先进先出。 RocketMQ 一个Topic其实是分成了4个队列，所以在消息投递时，需要顺序的消息，要放在同一个队列中。 消费者 指定 consumeMode
SpringBoot+RocketMQ
12-28
SpringBoot集成RocketMQ,实现消息的生产者，消费者，使用SpringBoot2.0以及阿里云RocketMQ3.2.6,版本控制依托于MVN
从零到一：Spring Boot 与 RocketMQ 的完美集成指南
最新发布
qq_51447436的博客
08-21 3578
从零到一：Spring Boot 与 RocketMQ 的完美集成指南
Spring Boot集成RocketMq（一看就会）
热门推荐
weixin_44039105的博客
12-06 1万+
Spring boot 整合RocketMq快速上手，一看就会
Springboot整合RocketMQ
GSON的博客
04-17 3412
顺序消息是 Apache RocketMQ 提供的一种高级消息类型，支持消费者按照发送消息的先后顺序获取消息，从而实现业务场景中的顺序处理。普通消息为 Apache RocketMQ 中最基础的消息 ， 普通消息一般应用于微服务解耦、事件驱动、数据集成等场景，这些场景大多数要求数据传输通道具有可靠传输的能力，且对消息的处理时机、处理顺序没有特别要求。封装了RocketMQ的生产者API，提供了一系列简单易用的方法，用于发送不同类型的消息， 后面的例子都会用到它。
SpringBoot整合RocketMQ
上善若泪
05-08 6045
先看看每次发送消息或者消费消息消息发送成功或者失败要打印消息日志，用于业务排查问题。如果消息量较少，建议在消费入口方法打印消息，消费耗时等，方便后续排查问题。RocketMQ无法避免消息重复（），所以如果业务对消费重复非常敏感，务必要在业务层面进行去重处理。可以借助关系数据库进行去重。首先需要确定消息的唯一键，可以是msgId，也可以是消息内容中的唯一标识字段，例如订单Id等。接下来讨论的是在RocketMQ中发送消息时选择何种消息类型最为合适。在RocketMQ发送Json对象。
SpringBoot集成RocketMQ
Ahjbvj的博客
07-14 6718
MQ（Message Queue）是一种跨进程的通信机制，用于传递消息。使用MQ之后可以实现异步解耦和流量消峰的功能。在微服务项目中是一个常用的组件。RocketMQ的使用需要先启动RocketMQ的服务，这样才可以在后端连接RocketMQ并使用RocketMQ传递消息。
springboot整合rocketmq源码
04-22
【标题】：SpringBoot整合RocketMQ源码解析 在当今的微服务架构中，消息队列（Message Queue）已经成为解耦、异步处理以及提高系统可靠性的关键组件。本主题将深入探讨如何在SpringBoot应用中整合Apache RocketMQ，...
Springboot整合RocketMQ之生产者
JemeryShen的专栏
09-15 1548
顺序消息是一种对消息发送和消费顺序有严格要求的消息。对于一个指定的Topic，消息严格按照先进先出（FIFO）的原则进行消息发布和消费，即先发布的消息先消费，后发布的消息后消费。在 Apache RocketMQ 中支持分区顺序消息，如下图所示。我们可以按照某一个标准对消息进行分区（比如图中的ShardingKey），同一个ShardingKey的消息会被分配到同一个队列中，并按照顺序被消费。需要注意的是 RocketMQ 消息的顺序性分为两部分，生产顺序性和消费顺序性。
SpringBoot整合rocketmq事务消息
02-13
3. **创建生产者**：在SpringBoot应用中，我们创建一个RocketMQ生产者实例，用于发送消息。生产者需要实现`SendCallback`接口，以便在消息发送成功或失败时进行回调处理。 4. **创建消费者**：为了接收和处理消息，...
springboot整合RocketMQ的实践代码（生产者、消费者的演示）
07-26
springboot整合RocketMQ的实践代码
springboot-rocketmq
01-09
springboot整和rocketmq, 分别通过配置和xml两种方式实现整合.
Springboot 整合RocketMQ
lisaihang96的博客
10-24 3700
因为已经保存用户的基本信息，保存上状态标志位（0），消费者计算完后，根据id更新该数据标志位（1），计算异常问题更新标志位（2），每日定时任务对异常数据进行批量推送重新计算。根据用户提交的手机号计算用户数据，计算用户实时数据比较长数据量大的3-5分钟，数据小的1分钟上下，移动端不需要实时放回用户计算数据，所以接口保存完用户基本信息。此机制只能针对 消息队列宕机 网络异常或队列数据丢失问题。业务场景：该接口为H5、小程序提供，收集用户信息姓名、手机号、身份证号、地区等信息。4. 监听器事务配置。
Springboot整合RocketMq
xdscode的博客
07-30 1143
如果业务需要高性能、灵活的路由配置和对在线业务的响应时延有较高要求，可以考虑使用RocketMQ；如果业务需要高并发、高吞吐量、健壮稳定且易于使用和管理的消息队列产品，可以考虑使用RabbitMQ。@RocketMQMessageListener表示这是一个rocketmq的消费者，该注解只能用在类上面 topic：指定需要消费的队列。解决办法：https://blog.csdn.net/LLittleF/article/details/130689449。解释一下消费者中的代码。
Spring Boot集成RocketMQ
xzh_blog
12-30 448
引入RocketMQ <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <version>2.0.3</version> </dependency&g.
SpringBoot 集成 RocketMQ
魂-淡
03-20 7804
RocketMQ 主要由 Producer、Broker、Consumer 三部分组成，其中 Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。Broker 在实际部署过程中对应一台服务器，每个 Broker 可以存储多个 Topic 的消息，每个Topic 的消息也可以分片存储于不同的 Broker。消息中转角色，负责存储消息、转发消息。表示一类消息的集合，每个主题包含若干条消息，每条消息只能属于一个主题，是RocketMQ 进行消息订阅的基本单位。
6-rocketmq-springboot整合
Link的博客
01-07 477
官方手册 https://github.com/apache/rocketmq-spring/wiki/用户手册 引包 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifa...
RocketMQ（一）：Linux安装RocketMQ和常用命令
qq_28834355的博客
01-30 1180
下载安装 版本：4.8.0 下载地址：https://www.apache.org/dyn/closer.cgi?path=rocketmq/4.8.0/rocketmq-all-4.8.0-source-release.zip 下载成功后，上传到 /opt 目录，并解压
SpringBoot集成RocketMQ：生产者与消费者实战
在SpringBoot整合RocketMQ的过程中，关键步骤如下： 1. **添加依赖**： - 在`pom.xml`文件中，添加`rocketmq-spring-boot-starter`依赖，指定版本2.0.4，这将自动包含RocketMQ的客户端库和Spring Boot的集成支持。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

可——叹——落叶飘零

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值