手把手带你 SpringBoot 2.X 整合 rocketmq-spring-boot-starter 2.2.0

于 2021-04-22 16:28:16 发布 706 收藏 4
分类专栏： RocketMQ 文章标签： 中间件 spring java 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010101193/article/details/116017124
版权

我的springboot的版本是2.1.3 rocketmq-spring-boot-starter版本是2.2.0

1 安装RocketMq并启动

参考我之前的文章 Windows环境下单机安装RocketMQ

2 开始整合

先看一下大概的目录
在这里插入图片描述

  • 2.1 引入maven库
      <dependency>
            <groupId>org.apache.rocketmq</groupId>
            <artifactId>rocketmq-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
  • 2.2配置文件
server:
  port: 8088
#rocketmq配置
rocketmq:
  name-server: 127.0.0.1:9876
  # 生产者配置
  producer:
    isOnOff: on
    # 发送同一类消息的设置为同一个group，保证唯一
    group: user-rocketmq-group
    groupName: user-rocketmq-group

    group1: order-rocketmq-group
    groupName1: order-rocketmq-group
    # 服务地址
    namesrvAddr: 127.0.0.1:9876
    # 消息最大长度 默认1024*4(4M)
    maxMessageSize: 4096
    # 发送消息超时时间,默认3000
    sendMsgTimeout: 3000
    # 发送消息失败重试次数，默认2
    retryTimesWhenSendFailed: 2
  • 2.3 RocketMqHelper 工具类
package com.example.utils;

/**
 * @author guog
 * @create 2021-04-21 17:38
 */

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * RocketMq助手
 *
 * @Author: heyuhua
 * @Date: 2020/1/8 10:03
 */
@Component
public class RocketMqHelper {

    /**
     * 日志
     */
    private static final Logger LOG = LoggerFactory.getLogger(RocketMqHelper.class);

    /**
     * rocketmq模板注入
     */
    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @PostConstruct
    public void init() {
        LOG.info("---RocketMq助手初始化---");
    }

    /**
     * 发送异步消息
     *
     * @param topic   消息Topic
     * @param message 消息实体
     */
    public void asyncSend(Enum topic, Message<?> message) {
        asyncSend(topic.name(), message, getDefaultSendCallBack());
    }


    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     */
    public void asyncSend(Enum topic, Message<?> message, SendCallback sendCallback) {
        asyncSend(topic.name(), message, sendCallback);
    }

    /**
     * 发送异步消息
     *
     * @param topic   消息Topic
     * @param message 消息实体
     */
    public void asyncSend(String topic, Message<?> message) {
        rocketMQTemplate.asyncSend(topic, message, getDefaultSendCallBack());
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback);
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     * @param timeout      超时时间
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback, long timeout) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback, timeout);
    }

    /**
     * 发送异步消息
     *
     * @param topic        消息Topic
     * @param message      消息实体
     * @param sendCallback 回调函数
     * @param timeout      超时时间
     * @param delayLevel   延迟消息的级别
     */
    public void asyncSend(String topic, Message<?> message, SendCallback sendCallback, long timeout, int delayLevel) {
        rocketMQTemplate.asyncSend(topic, message, sendCallback, timeout, delayLevel);
    }

    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     */
    public void syncSendOrderly(Enum topic, Message<?> message, String hashKey) {
        syncSendOrderly(topic.name(), message, hashKey);
    }


    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     */
    public void syncSendOrderly(String topic, Message<?> message, String hashKey) {
        LOG.info("发送顺序消息，topic:" + topic + ",hashKey:" + hashKey);
        rocketMQTemplate.syncSendOrderly(topic, message, hashKey);
    }

    /**
     * 发送顺序消息
     *
     * @param message
     * @param topic
     * @param hashKey
     * @param timeout
     */
    public void syncSendOrderly(String topic, Message<?> message, String hashKey, long timeout) {
        LOG.info("发送顺序消息，topic:" + topic + ",hashKey:" + hashKey + ",timeout:" + timeout);
        rocketMQTemplate.syncSendOrderly(topic, message, hashKey, timeout);
    }

    /**
     * 默认CallBack函数
     *
     * @return
     */
    private SendCallback getDefaultSendCallBack() {
        return new SendCallback() {
            @Override
            public void onSuccess(SendResult sendResult) {
                LOG.info("---发送MQ成功---");
            }

            @Override
            public void onException(Throwable throwable) {
                LOG.error("---发送MQ失败---"+throwable.getMessage(), throwable.getMessage());
            }
        };
    }


    @PreDestroy
    public void destroy() {
        LOG.info("---RocketMq助手注销---");
    }

}
  • 2.4 创建User 和 Order 实体
package com.example.entity;

/**
 * @author guog
 * @create 2021-04-21 17:39
 */
public class User {
    String name;
    Integer id;
    Integer age;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}


package com.example.entity;

/**
 * @author guog
 * @create 2021-04-22 11:32
 */
public class Order {
    Integer id;
    String OrderType;
    String OrderNO;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getOrderType() {
        return OrderType;
    }

    public void setOrderType(String orderType) {
        OrderType = orderType;
    }

    public String getOrderNO() {
        return OrderNO;
    }

    public void setOrderNO(String orderNO) {
        OrderNO = orderNO;
    }
}
  • 2.5 创建消息监听
  • 2.5.1 UserMqListener
package com.example.Listener;

import com.example.entity.User;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * @author guog
 * @create 2021-04-21 17:40
 */
@Component
@RocketMQMessageListener(consumerGroup = "${rocketmq.producer.groupName}", topic = "USER_ADD")
public class UserMqListener implements RocketMQListener<User> {
@Override
public void onMessage(User user) {
        System.out.println("----------------------------------");
        System.out.println("接收到消息，开始消费..name:" + user.getName() + ",age:" + user.getAge());
        }
        }
  • 2.5.2 OrderMqListener
package com.example.Listener;

import com.example.entity.Order;
import org.apache.rocketmq.spring.annotation.ConsumeMode;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Component;

/**
 * @author guog
 * @create 2021-04-21 17:40
 */
@Component
@RocketMQMessageListener(consumerGroup = "${rocketmq.producer.groupName1}", topic = "ORDER_ADD",consumeMode = ConsumeMode.ORDERLY)
public class OrderMqListener implements RocketMQListener<Order> {
@Override
public void onMessage(Order order) {
                System.out.println("接收到消息，开始消费..OrderType:" + order.getOrderType() + ",OrderNO:" + order.getOrderNO());
        }
 }
  • 2.6 写一个testController测试代码
  • 2.6.1 测试异步发送并消费
  //发送异步消息
    @GetMapping("asyncSend")
    public void asyncSend() {
        User user= new User();
        user.setName("java");
        user.setAge(18);
        rocketMqHelper.asyncSend("USER_ADD", MessageBuilder.withPayload(user).build());
    }

查看结果
在这里插入图片描述

  • 2.6.1 测试顺序发送并消费
//发送顺序消息
    @GetMapping("syncSendOrderly")
    public void syncSendOrderly() {
        Order order1 = new Order();
        Order order2 = new Order();
        Order order3 = new Order();
        Order order4 = new Order();
        order1.setOrderNO("1111111");
        order2.setOrderNO("2222222");
        order3.setOrderNO("3333333");
        order4.setOrderNO("4444444");


        order1.setOrderType("创建订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order1).build(),order1.getOrderNO());

        order2.setOrderType("创建订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order2).build(),order2.getOrderNO());

        order2.setOrderType("支付订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order2).build(),order2.getOrderNO());

        order3.setOrderType("创建订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order3).build(),order3.getOrderNO());


        order1.setOrderType("支付订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order1).build(),order1.getOrderNO());

        order2.setOrderType("已发货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order2).build(),order2.getOrderNO());


        order3.setOrderType("支付订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order3).build(),order3.getOrderNO());

        order2.setOrderType("已收货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order2).build(),order2.getOrderNO());


        order1.setOrderType("已发货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order1).build(),order1.getOrderNO());



        order4.setOrderType("创建订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order4).build(),order4.getOrderNO());

        order3.setOrderType("已发货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order3).build(),order3.getOrderNO());

        order4.setOrderType("支付订单");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order4).build(),order4.getOrderNO());

        order1.setOrderType("已收货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order1).build(),order1.getOrderNO());


        order4.setOrderType("已发货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order4).build(),order4.getOrderNO());


        order3.setOrderType("已收货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order3).build(),order3.getOrderNO());

        order4.setOrderType("已收货");
        rocketMqHelper.syncSendOrderly("ORDER_ADD", MessageBuilder.withPayload(order4).build(),order4.getOrderNO());


    }

创建 4个Order对象 分别有4中状态 创建订单—》支付订单—》已发货----》已收货 我们测试看同一个订单号是否是按照这个顺序进行消费的

结果

2021-04-22 15:38:51.783  INFO 6632 --- [nio-8088-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 3 ms
2021-04-22 15:38:51.800  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:1111111
2021-04-22 15:38:51.967  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:2222222
2021-04-22 15:38:51.969  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:2222222
2021-04-22 15:38:51.970  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:3333333
2021-04-22 15:38:51.971  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:1111111
2021-04-22 15:38:51.972  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:2222222
2021-04-22 15:38:51.974  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:3333333
2021-04-22 15:38:51.975  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:2222222
2021-04-22 15:38:51.976  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:1111111
2021-04-22 15:38:51.976  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:4444444
2021-04-22 15:38:51.977  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:3333333
2021-04-22 15:38:51.978  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:4444444
2021-04-22 15:38:51.979  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:1111111
2021-04-22 15:38:51.980  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:4444444
2021-04-22 15:38:51.981  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:3333333
2021-04-22 15:38:51.982  INFO 6632 --- [nio-8088-exec-1] com.example.utils.RocketMqHelper         : 发送顺序消息，topic:ORDER_ADD,hashKey:4444444
接收到消息，开始消费..OrderType:创建订单,OrderNO:1111111
接收到消息，开始消费..OrderType:创建订单,OrderNO:4444444
接收到消息，开始消费..OrderType:创建订单,OrderNO:2222222
2021-04-22 15:39:49.312  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811A770000 cost: 31 ms
2021-04-22 15:39:49.312  INFO 6632 --- [MessageThread_1] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC90012 cost: 31 ms
2021-04-22 15:39:49.312  INFO 6632 --- [MessageThread_3] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ABF0002 cost: 31 ms
接收到消息，开始消费..OrderType:支付订单,OrderNO:4444444
接收到消息，开始消费..OrderType:支付订单,OrderNO:2222222
接收到消息，开始消费..OrderType:创建订单,OrderNO:3333333
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_1] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ACA0016 cost: 0 ms
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC20006 cost: 0 ms
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_3] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC10004 cost: 0 ms
接收到消息，开始消费..OrderType:已发货,OrderNO:4444444
接收到消息，开始消费..OrderType:支付订单,OrderNO:1111111
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_1] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ACC001A cost: 0 ms
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC40008 cost: 0 ms
接收到消息，开始消费..OrderType:已发货,OrderNO:2222222
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_3] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC5000A cost: 0 ms
接收到消息，开始消费..OrderType:已收货,OrderNO:4444444
接收到消息，开始消费..OrderType:支付订单,OrderNO:3333333
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_1] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ACE001E cost: 0 ms
2021-04-22 15:39:49.314  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC6000C cost: 0 ms
接收到消息，开始消费..OrderType:已收货,OrderNO:2222222
2021-04-22 15:39:49.315  INFO 6632 --- [MessageThread_3] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC7000E cost: 1 ms
接收到消息，开始消费..OrderType:已发货,OrderNO:1111111
2021-04-22 15:39:49.315  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811AC80010 cost: 0 ms
接收到消息，开始消费..OrderType:已发货,OrderNO:3333333
2021-04-22 15:39:49.315  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ACA0014 cost: 0 ms
接收到消息，开始消费..OrderType:已收货,OrderNO:1111111
2021-04-22 15:39:49.315  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ACB0018 cost: 0 ms
接收到消息，开始消费..OrderType:已收货,OrderNO:3333333
2021-04-22 15:39:49.316  INFO 6632 --- [MessageThread_2] a.r.s.s.DefaultRocketMQListenerContainer : consume C0A8640919E818B4AAC26F811ACD001C cost: 1 ms

我们看到 发送消息是4个订单状态随机发送 但消息消费时是按照每个订单号的 创建订单—》支付订单—》已发货----》已收货 顺序消费

rocketmq-spring-boot-starter：RocketMQ的Spring Boot启动器
01-30
RocketMQ的Spring启动启动器 项目介绍 是由阿里巴巴团队开发并幸存给apache团队的优秀消息中间件，承受过历年双十一大促的考验。 你可以通过本项目轻松的集成Rocketmq到你的SpringBoot项目中。本项目主要包含以下特性 同步发送消息 初步发送消息 广播发送消息 有序发送和消费消息 发送延迟消息 消息标签和密钥支持 自动序列化和反序列化消息体 消息的实际消费方IP跟随 发送事务消息（NEW） ... 发送即忘消息（可能由于直接抛弃所有异常导致消息静默丢失，弃用） 拉取方式消费（配置方式复杂，位点可能发生偏移，弃用） 简单入门实例 1.添加maven依赖： < dependency> < groupId> com . maihaoche < / groupId > < artifactId> spring - boot - starter - rocketmq < / artifactId > < version> 0.1 . 0 < / version > < / dependency > 2.添加配置： spring :
评论 1 您还未登录，请先 登录 后发表或查看评论
SpringBoot2 集成 RocketMQ
lovelichao12的专栏
01-16 1200
RocketMQ是阿里云基于Apache RocketMQ构建的低延迟、高并发、高可用、高可靠的分布式消息中间件。消息队列RocketMQ版既可为分布式应用系统提供异步解耦和削峰填谷的能力，同时也具备互联网应用所需的海量消息堆积、高吞吐、可靠重试等特性。
SpringBoot 2.X 整合 rocketmq-spring-boot-starter 2.2.0 实现事务消息
不会吉他的肌肉男不是好的挨踢男的专栏
04-27 531
我的springboot的版本是2.1.3 rocketmq-spring-boot-starter版本是2.2.0 之前我的博文手把手带你 SpringBoot 2.X 整合 RocketMq 实现了rocketmq的异步消息生产消费和顺序消息生产和消费 今天来学习一下RocketMQ事务消息的发送消费。 RocketMQ的事务消息分为3种状态，分别是提交状态、回滚状态、中间状态： TransactionStatus.CommitTransaction: 提交事务，它允许消费者消费此消息。 Tra.
rocketmq-spring-boot-starter：rocketmq-spring-boot-starter
01-30
rocketmq-spring-boot-starter 阿里云RocketMQSpring图书版 支持功能： 发送普通消息的三种模式：同步，异步和单向 订阅消息群集，广播 发送和接收顺序消息 交易讯息 延迟讯息 接收和接收定时消息 定时消息和延迟消息： 延迟消息和定时消息：在官方情况下，延迟新闻与常规新闻几乎相同，本质上是普通新闻。 如果需要延迟消息和计时消息，建议使用计时任务（计时任务调度平台） 以达到延迟或定时的目的。 交易留言： 在框架中，对事务消息的操作越来越简单。 您只能通过注释来完成交易消息。 无论是事务消息，分布式事务解决方案还是跨平台语言解决方案，事务解决方案的核心问题是确保可以发送消息，并且消费者可以使用它们。 可靠性保证 1.添加@TransactionMessage批注，内核保证，本地事务错误，不发送消息，正确执行，发送消息，即默认提交。 2.默认情况下采用可靠性保证，并核对默认提交。 原因来自先前的因素，该因素保证本地交易不会出错。 快速开始 <!-- Adding dependencies to pom. XML -->
spring-boot-starter-rocketmq
04-28
自己写的一个spring-boot整合rocketmq的starter，以及一个用来测试的项目rocketmq-starter-test。 涉及以下知识的最佳实践： 1、自定义spring boot starter； 2、使用spring的事件传播机制实现bean与bean之间基于事件驱动的通信 3、自定义注解、组合注解 相关资料参考我写的博文：http://blog.csdn.net/jayjjb/article/details/70906511 1个最佳实践1分，很划算的^_^
springboot 2.x 整合rocketmq-spring-boot-starter
wodiaonihai的博客
01-09 770
一、导入maven依赖，rocketmq-spring-boot-starter可在maven中央仓库查找 org.apache.rocketmq rocketmq-spring-boot-starter 2.0.4 rocketmq 服务搭建在此省略..... 二、yml 配置 rocketmq: name-server: http://127.0.0.1:9876 #rocketmq服务地址 producer: group: rocketmq_test #自定义的组名称 send-message-t
springboot使用rocketmq-spring-boot-starter整合RocketMQ
程序员劝退师的博客
12-16 1492
前言 前面写过一片文章使用rocketmq-client整合RocketMQ的，这篇文章也不讲这些理论，理论还是前往RocketMQ消息类型或者其他往期文章，本文就如标题，纯粹的操一下rocketmq-spring-boot-starter这个玩意！ 依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spri
rocketmq-spring-boot-starter使用指南
热门推荐
武汉红喜
01-09 8万+
https://github.com/apache/rocketmq-spring.git 针对官方starter修改点 官方 支持连接多个集群(订阅) （官方一个应用只能连接一个集群） 顺序消息消费失败，可配重试次数 （非顺序消息默认重试16次，每次时间延后） 发送延时消息方法参数优化(魔法参数改为枚举) 优化getMessageType方法，支持 MyConsumer extends Abs...
SpringBoot整合RocketMQ，三种测试附带源码【rocketmq-spring-boot-starter】
小道仙的后宫
03-07 2623
我们整合boot项目的时候都是引入 xxx-start 依赖，但是现在大多数的整合RocketMQ都还不是这样。 我花了一天时间使用rocketmq-spring-boot-starter整合，使得操作起来更加简单。 1、说明 1-1：rocketmq-spring-boot-starter 提供了一个 rocketMQTemplate 使得发消息更加简单，它底层也还是基于DefaultMQP...
SpringBoot中使用RocketMQ
qq_31155349的博客
09-16 2893
接下来我们模拟一种场景：商品下单成功之后，向下单用户发送短信。以此来示例SpringBoot中RocketMQ的使用方式。 目录 1 订单微服务发送消息 1.1 订单微服务添加rocketmq的依赖 1.2 添加配置 1.3 编写测试代码 1.4 测试 2 用户微服务订阅消息 2.1 用户微服务增加rocketmq依赖 2.2 修改主类，启动nacos客户端 2.3 修改配置文件 2.4 编写消息接收服务 2.5 测试 1 订单微服务发送消息 1.1 订单微服务添加ro.
【MQ篇】Spring Boot 整合 RocketMQ 消息队列
最新发布
csp732171109的博客
04-24 407
写在最前 Docker安装RocketMQ RocketMQ 入门必读 Spring Boot 整合 RocketMQ Demo 地址：mingyue-springboot-rocketmq 1.添加依赖 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <
RocketMQ在SpringBoot中的使用
weixin_42029738的博客
07-22 1888
RocketMQ 在SpringBoot中的使用 一、前言 在Springboot中使用RocketMQ基本有两种方式， 第一种是基于RocketMQ原生的API，第二种是采用Springboot对RocketMQ封装的写法，接下来分别介绍这两种方式的基本用法，各自的优缺点各位看官仁者见仁，智者见智。 二、RocketMQ原生API的使用方式 2.1生产者的使用 pom 依赖如下： <dependency> <groupId>org.apache.rocketmq</g
Spring Cloud Alibaba与Spring Boot、Spring Cloud版本对应关系
Thinkingcao的专栏
04-21 1万+
一、前言 在搭建SpringCloud项目环境架构的时候，Springboot版本与SpringCloud版本对应关系很重要，如果版本不对应，常见的会遇见项目启动不起来，怪异的会是项目出现一些诡异的问题。 Release train Spring Boot compatibility Spring Cloud Release Train Spring Boot Version Ho...
SpringBoot整合RocketMQ
沮丧的南瓜
08-25 4063
一、快速实战 在使用SpringBoot的starter集成包时，要特别注意版本。 因为SpringBoot集成RocketMQ的starter依赖是由Spring社区提供的，目前正在快速迭代的过程当中，不同版本之间的差距非常大，甚至基础的底层对象都会经常有改动。例如如果使用rocketmq-spring-boot-starter:2.0.4版本开发的代码，升级到目前最新的rocketmq-spring-boot-starter:2.1.1后，基本就用不了了。 1、maven依赖： <depende
SpringBoot2.x整合RocketMQ
紫蝶侠的博客
04-03 3808
SpringBoot2.x整合RockketMQ JMS介绍和使用场景及基础编程模型 1、JMS介绍和使用场景及基础编程模型 简介：讲解什么是小写队列，JMS的基础知识和使用场景 1、什么是JMS: Java消息服务（Java Message Service),Java平台中关于面向消息中间件的接口 2、JMS是一种与厂商无关的 API，用来访问消息收发系统消息，它类似于JDBC(Java Dat...
SpringBoot2.0整合RocketMQ实战
weixin_43073775的博客
11-15 523
目录同步消息异步消息单向消息批量消息事务消息队列自选择 同步消息 异步消息 单向消息 批量消息 事务消息 队列自选择
SpringBoot集成RocketMQ（进阶版）
Soda_lw的博客
01-21 1万+
上一篇文章我们讲了如何简单的springboot集成rocketmq（建议先看上一篇，此篇实在上一篇的基础上改进的），但在实际应用中，往往不会只有一个消息处理类，MessageProcessorImpl。消费者会收到不同topic，不同tag的的消息，这里我们来对我们的consumer类和消息处理类进行扩展一下。 一、修改我们的MessageProcessor接口。 改造一下： package c...
springboot整合rocketmq，rocketmq-spring-boot-starter：2.0.3
shuaishuai5213的博客
10-21 4515
这里有点坑，之前的springboot与rocketmq的依赖，maven中央仓库并没有收纳，所以要想使用，需要自己去自己通过源码install到本地仓库的。但这里我一直没有弄成功，我不死心，去maven官网一直查找，终于找到了 如图，maven中央仓库是在今年一月份才开始收纳springboot与rocketmq的依赖，到现在为止也只有三个版本，而且使用的人很少，所以接下来我们就开心的使用吧 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题：黑客帝国 设计师：我叫白小胖 返回首页

打赏作者

不会吉他的肌肉男不是好的挨踢男

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

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额：-- )
扫码支付
扫码支付：¥2
获取中
扫码支付

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

打赏作者

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

抵扣说明：

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

余额充值