个人笔记 rocketMQ学习

最新推荐文章于 2023-11-20 10:50:08 发布
最新推荐文章于 2023-11-20 10:50:08 发布
阅读量236 收藏
点赞数

pom.xml文件

<dependency>  
     <groupId>com.alibaba.rocketmq</groupId>  
     <artifactId>rocketmq-client</artifactId>  
     <version>3.2.6</version>  
</dependency>

yml文件

rocketmq:
  producer:
    isOnOff: on
    groupName: rocketMqGroupName1
    namesrvAddr: 192.168.210.25:9876
    maxMessageSize: 4096
    sendMsgTimeout: 3000
    retryTimesWhenSendFailed: 2
  consumer:
    isOnOff: on
    groupName: rocketMqGroupName1
    namesrvAddr: 192.168.210.25:9876
    topics: topic1~tg_01||tg_02
    consumeThreadMin: 20
    consumeThreadMax: 64
    consumeMessageBatchMaxSize: 1

生产者配置bean对象

package com.example.demo.rocketbean;

import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.util.StringUtils;

@SpringBootConfiguration
public class MQProducerConfiguration {
	
    /**
     * 发送同一类消息的设置为同一个group，保证唯一,默认不需要设置，rocketmq会使用ip@pid(pid代表jvm名字)作为唯一标示
     */
    @Value("${rocketmq.producer.groupName}")
    private String groupName;
    @Value("${rocketmq.producer.namesrvAddr}")
    private String namesrvAddr;
    /**
     * 消息最大大小，默认4M
     */
    @Value("${rocketmq.producer.maxMessageSize}")
    private Integer maxMessageSize;
    /**
     * 消息发送超时时间，默认3秒
     */
    @Value("${rocketmq.producer.sendMsgTimeout}")
    private Integer sendMsgTimeout;
    /**
     * 消息发送失败重试次数，默认2次
     */
    @Value("${rocketmq.producer.retryTimesWhenSendFailed}")
    private Integer retryTimesWhenSendFailed;

    @Bean
    public DefaultMQProducer getRocketMQProducer() {
        if (StringUtils.isEmpty(this.groupName)) {
        	System.out.println("StringUtils.isEmpty(this.groupName) 报错");
        }
        if (StringUtils.isEmpty(this.namesrvAddr)) {
        	System.out.println("StringUtils.isEmpty(this.namesrvAddr) 报错");
        }
        DefaultMQProducer producer;
        producer = new DefaultMQProducer(this.groupName);
        producer.setNamesrvAddr(this.namesrvAddr);
        //如果需要同一个jvm中不同的producer往不同的mq集群发送消息，需要设置不同的instanceName
        //producer.setInstanceName(instanceName);
        if(this.maxMessageSize!=null){
            producer.setMaxMessageSize(this.maxMessageSize);
        }
        if(this.sendMsgTimeout!=null){
            producer.setSendMsgTimeout(this.sendMsgTimeout);
        }
        //如果发送消息失败，设置重试次数，默认为2次
        if(this.retryTimesWhenSendFailed!=null){
            producer.setRetryTimesWhenSendFailed(this.retryTimesWhenSendFailed);
        }
        
        try {
            producer.start();
        } catch (Exception e) {
        	System.out.println("producer.start(); 报错");
        }
        return producer;
    }
}

消费者配置bean对象

package com.example.demo.rocketbean;

import java.util.List;

import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.consumer.ConsumeFromWhere;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Bean;
import org.springframework.util.StringUtils;

import com.example.demo.Event.RocketmqEvent;
import com.example.demo.Listener.MQConsumeMsgListenerProcessor;

@SpringBootConfiguration
public class MQConsumerConfiguration {
    @Value("${rocketmq.consumer.namesrvAddr}")
    private String namesrvAddr;
    @Value("${rocketmq.consumer.groupName}")
    private String groupName;
    @Value("${rocketmq.consumer.consumeThreadMin}")
    private int consumeThreadMin;
    @Value("${rocketmq.consumer.consumeThreadMax}")
    private int consumeThreadMax;
    @Value("${rocketmq.consumer.topics}")
    private String topics;
    @Value("${rocketmq.consumer.consumeMessageBatchMaxSize}")
    private int consumeMessageBatchMaxSize;
    
    @Autowired
    private ApplicationEventPublisher publisher;

    //监听器对象
    @Autowired
    private MQConsumeMsgListenerProcessor mQConsumeMsgListenerProcessor;
    
    @Bean
    public DefaultMQPushConsumer getRocketMQConsumer() {
        if (StringUtils.isEmpty(groupName)){
        }
        if (StringUtils.isEmpty(namesrvAddr)){
        }
        if(StringUtils.isEmpty(topics)){
        }
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer(groupName);
        consumer.setNamesrvAddr(namesrvAddr);
        consumer.setConsumeThreadMin(consumeThreadMin);
        consumer.setConsumeThreadMax(consumeThreadMax);
        /**
         * 设置Consumer第一次启动是从队列头部开始消费还是队列尾部开始消费
         * 如果非第一次启动，那么按照上次消费的位置继续消费
         */
        consumer.setConsumeFromWhere(ConsumeFromWhere.CONSUME_FROM_LAST_OFFSET);
        /**
         * 设置消费模型，集群还是广播，默认为集群
         */
        //consumer.setMessageModel(MessageModel.CLUSTERING);
        /**
         * 设置一次消费消息的条数，默认为1条
         */
        consumer.setConsumeMessageBatchMaxSize(consumeMessageBatchMaxSize);
        try {
            /**
             * 设置该消费者订阅的主题和tag，如果是订阅该主题下的所有tag，则tag使用*；如果需要指定订阅该主题下的某些tag，则使用||分割，例如tag1||tag2||tag3
             */
            String[] topicTagsArr = topics.split(";");
            for (String topicTags : topicTagsArr) {
                String[] topicTag = topicTags.split("~");
                consumer.subscribe(topicTag[0],topicTag[1]);
            }
            consumer.registerMessageListener(mQConsumeMsgListenerProcessor);
//使用springboot监听器方式
//            consumer.registerMessageListener((List<MessageExt> msgs, ConsumeOrderlyContext context) -> {
//            	try {
//            		if(msgs.size() == 0) return ConsumeOrderlyStatus.SUCCESS;
//					this.publisher.publishEvent(new RocketmqEvent(msgs, consumer));
//				} catch (Exception e) {
//					e.printStackTrace();
//					return ConsumeOrderlyStatus.SUSPEND_CURRENT_QUEUE_A_MOMENT;
//				}
//            	return ConsumeOrderlyStatus.SUCCESS;
//            });
            consumer.start();
        }catch (Exception e){
        }
        return consumer;
    }
}

配置消费者监听

package com.example.demo.Listener;

import java.io.UnsupportedEncodingException;
import java.util.List;

import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerConcurrently;
import org.apache.rocketmq.common.message.MessageExt;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component
public class MQConsumeMsgListenerProcessor implements MessageListenerConcurrently {
    /**
     *  默认msgs里只有一条消息，可以通过设置consumeMessageBatchMaxSize参数来批量接收消息<br/>
     *  不要抛异常，如果没有return CONSUME_SUCCESS ，consumer会重新消费该消息，直到return CONSUME_SUCCESS
     */
    @Override
//    @EventListener(condition = "#event.msgs[0].topic=='topic1'")
    public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
        if(CollectionUtils.isEmpty(msgs)){
            return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
        }
        MessageExt messageExt = msgs.get(0);
        if(messageExt.getTopic().equals("topic1")){
            if(messageExt.getTags().equals("tg_01")){
                //TODO 判断该消息是否重复消费（RocketMQ不保证消息不重复，如果你的业务需要保证严格的不重复消息，需要你自己在业务端去重）
                //TODO 获取该消息重试次数
                int reconsume = messageExt.getReconsumeTimes();
                if(reconsume ==3){//消息已经重试了3次，如果不需要再次消费，则返回成功
                    return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
                }
                //TODO 处理对应的业务逻辑
                try {
					System.out.println("接收到消息 : " + new String(messageExt.getBody(), "utf-8"));
				} catch (UnsupportedEncodingException e) {
					e.printStackTrace();
				}
            }
        }
        // 如果没有return success ，consumer会重新消费该消息，直到return success
        return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
    }

}

生产者测试代码

package com.example.demo.test;

import org.apache.rocketmq.client.exception.MQBrokerException;
import org.apache.rocketmq.client.exception.MQClientException;
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.exception.RemotingException;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MQTest {

    /**使用RocketMq的生产者*/
    @Autowired
    private DefaultMQProducer defaultMQProducer;
    
    /**
     * 发送消息
     * 
     * @throws InterruptedException 
     * @throws MQBrokerException 
     * @throws RemotingException 
     * @throws MQClientException 
     */
    @Test
    public void send() throws MQClientException, RemotingException, MQBrokerException, InterruptedException {
        String msg = "event监听。。。";
        Message sendMsg = new Message("topic1","tg_01",msg.getBytes());
        //默认3秒超时
        SendResult sendResult = defaultMQProducer.send(sendMsg);
    }
}

至此springboot集成rocketMQ完成。

转载  https://www.jianshu.com/p/8c4c2c2ab62e

相关文章 https://blog.csdn.net/qq_18603599/article/details/81172866

Z·L·H·H
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot 集成 RocketMQ
RUN166的博客
04-17 1933
1、引入Maven配置 <dependency> <groupId>org.apache.rocketmq</groupId> <artifactId>rocketmq-spring-boot-starter</artifactId> <version>2.1.1</version> </dependency> 2、连接rocketMq客户端 rocketmq: na
RocketMq事务消息（分布式事务解决方案）
疯狂的蜗牛
09-07 8675
从问题出发 阅读本文后，我们将了解以上两个问题的答案。 1、RocketMq生产者组（producer group）的设定有什么用？ 2、一个订单处理的场景，消费者订阅了订单topic，但总担心丢消息。于是为了防止丢消息，每天都会通过定时任务做一致性校验，这是最佳方案吗？ 这还得从基于消息队列实现实现分布式事务的解决方案说起。 常见的分布式事务包括 2PC、3PC、TCC、本地消息表、消息事务、最大努力通知。 今天我们主要讲讲本地消息表、消息事务两种方案。 本地消息表 本地消息表的大致流程是这样的。 pub
RocketMQ集群配置
xiaojie19871116的博客
07-03 1426
RocketMQ集群配置 分类： 消息中间件/消息推送2014-11-09 17:15 1488人阅读 评论(2) 收藏 举报 RocketMQ Broker集群部署方式主要有以下几种：（Slave 不可写，但可读） （1）单个Master 这种方式风险较大，一旦Broker 重启或者宕机时，会导致整个服务不可用，不建议线上环境使用。 （2）多M
SpringBoot 最新教程：SpringBoot 2.7 整合 RocketMQ 项目搭建-2022年最新图文版本
架构师小冯的专栏
07-18 2446
SpringBoot2.7教程SpringBoot整合RocketMQ项目搭建-2022年最新图文版本。 目录 ​​​​​​​一、新建项目rocketmq-sample，项目结构如下 二、配置pom文件 三、配置application.yml文件 四、配置消费消息类 五、配置生产消息类 六、controller 七、测试............
深入浅出Spring Boot整合RocketMQ
CERTAINTY的博客
08-09 5273
深入浅出Spring Boot整合RocketMQ
尚硅谷完整的关于rocketmq的学习视频整理笔记
09-12
尚硅谷提供的 RocketMQ 学习视频笔记旨在帮助初学者系统地掌握 RocketMQ 的核心概念和使用方法。 1. **MQ 简述** 消息队列（Message Queue，MQ）是一种异步通信机制，它在生产者和消费者之间充当了缓冲的角色，...
RocketMQ学习笔记1
08-04
RocketMQ学习笔记1 RocketMQ是Apache旗下的一个开源的消息队列系统，具有分布式、可靠、可扩展、高性能等特点。下面是对RocketMQ的学习笔记的总结。 分布式架构 RocketMQ原生支持分布式，解决了单点故障问题，...
RocketMQ学习笔记 1
08-03
RocketMQ学习笔记 1 RocketMQ学习笔记 1是关于Apache RocketMQ的学习笔记，涵盖了RocketMQ的基本概念、架构、消息模型、Producer和Consumer的基本概念、JMS规范等知识点。 1. 消息模型 在RocketMQ中，消息模型是...
RocketMQ黑马笔记
06-08
"RocketMQ黑马笔记" RocketMQ是阿里巴巴开源的消息中间件，在阿里内部历经了双十一等很多高并发场景的考验，能够处理亿万级别的消息。2016年开源后捐赠给Apache，现在是Apache的一个顶级项目。目前RocketMQ在阿里云...
MyBatis个人笔记
最新发布
05-13
MyBatis个人笔记
RocketMQ技术全面解析（概念、设计理念与目标、信息发送、同步发送--含代码！）
Java_Yhua的博客
12-08 1388
目录1.RocketMQ 介绍2.核心概念2.1NameServer2.2主题2.3生产者2.4消费者2.5消息3.核心概念4.RocketMQ 的设计理念和目标4.1设计理念4.2设计目标5.RocketMq 中消息的发送5.1单向(OneWay)发送5.1.1.代码演示5.1.2.Producer Group（生产者分组）5.1.3.Producer 实例5.1.4.Message Key5.1.5.Tag5.2.可靠同步发送5.2.1.Message ID5.2.2.SendStatus5.2.3Q.
RocketMQ Topic/Group/Tags介绍
xzh_blog
07-20 8718
Topic是RocketMQ里对消息的一级归类。RocketMQ支持发布和订阅模型，通过Topic完成消息的发布和订阅。消息生产者将消息发送到Topic中，而消息消费者则通过订阅该Topic来消费消息。
在SpringBoot中使用RocketMQ
zhao_god的专栏
11-20 741
Producer和Consumer的初始化比较慢，不建议每发一个消息或者消费一个消息就启动和注销对应的Object，所以适合把初始化操作代码写到@PostConstruct函数里，把关闭操作代码写到@PreDestroy函数里。更多的配置选项，可以到源码中查找。直接使用的方式比较简单，也足够灵活，但不是很符合Spring风格，Spring Boot对于消息传递，有统一的接口模板，基于这个模板可以对接各种类型的消息通信组件，比如Kafka、RabbitMQ、RocketMQ等。
RocketMQ的安装和springboot集成RocketMQ的使用
qq_38275723的博客
05-01 2086
RocketMQ 是阿里巴巴开源的分布式消息中间件。 RocketMQ 特点： ●是一个队列模型的消息中间件，具有高性能、高可靠、高实时、分布式等特点 ●Producer、Consumer、队列都可以分布式 ●Producer 向一些队列轮流发送消息，队列集合称为 Topic，Consumer 如果做广播消费，则一个 Consumer 实例消费这个 Topic 对应的所有队列，如果做集群消费，则多...
在Spring Boot中集成RocketMQ后，通过初始化代码来自动创建主题和消费分组
闫小甲的专栏
07-26 1869
通过在Spring Boot中编写这样的初始化代码，你可以在应用启动时自动创建RocketMQ的主题和消费分组。这样可以确保在应用运行时，所需的主题和消费分组已经存在，从而避免手动创建的麻烦。然后，你可以编写一个初始化类，使用RocketMQ的Admin API来自动创建主题和消费分组。在Spring Boot中集成RocketMQ后，通过初始化代码来自动创建主题和消费分组。在上面的示例代码中，我们通过RocketMQ的Admin API来创建主题和消费分组。方法来创建主题，并指定队列数量和主题副本数。
Spring boot集成RocketMQ
AnNanDu的博客
10-21 1567
之前安装好了RocketMQ,这一篇就简单记录一下是怎么集成RocketMQ的，如果有需要安装RocketMQ的同学看这一篇,Linux在线安装RocketMQ，如果没有linux环境的同学也可以本地启动，只需要有java环境即可。
【RocketMQ】（一）NameServer
S-H_A-N
08-16 631
NameServer是一个注册中心，提供服务注册和服务发现的功能。NameServer可以集群部署，集群中每个节点都是对等的关系（没有像ZooKeeper那样在集群中选举出一个Master节点），节点之间互不通信。Broker启动的时候会向所有的NameServer节点进行注册，注意这里是向集群中所有的NameServer节点注册，而不是只向其中的某些节点注册，因为NameServer每个节点都是对等的，所以Broker需要向每一个节点进行注册，这样每一个节点都会有一份Broker的注册信息。
RocketMQ集群（2主2从）搭建
qq_35059264的博客
07-29 311
勿以浮沙筑高台 基础准备：准备2台170,171机子并且安装了rocketMQ. 1.更改hosts信息 vi /etc/hosts # nameserver 192.168.95.170 rocketmq-nameserver1 192.168.95.171 rocketmq-nameserver2 # broker 192.168.95.170 rocketmq-master1 192.168.95.170 rocketmq-slave2 192.168.95.171 rocketmq-master
RocketMQ--环境构建和启动
puwan4207的博客
10-18 254
环境搭建 修改hosts vim /etc/hosts 上传编译好的包 # 上传 apache-rocketmq.tar.gz 文件至/usr/local # tar -zxvf apache-rocketmq.tar.gz -C /usr/local # 建立软链接 ln -s apache-rocketmq rocketmq ll /usr/local =====================================================================

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值