Rocket MQ更优雅的实现消息发送与消息监听—基于Spring注解实现消息监听

最新推荐文章于 2024-04-03 08:53:52 发布
最新推荐文章于 2024-04-03 08:53:52 发布
阅读量1.8w 收藏 37
点赞数 10
分类专栏： Rocket MQ JAVA 文章标签： java MQ Rocket MQ spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010351766/article/details/106080468
版权

如果项目使用Spring boot集成Rocket MQ可以使用RocketMQTemplate，代码看起来很简洁，但是如果项目只使用了spring，就要自己手写一堆代码去实现消息发送与消息监听

下面就参考RocketMQTemplate自己实现一个基于注解的消息监听框架

先看一下RocketMQTemplate是怎么实现注解方式注册消息监听的

@RocketMQMessageListener(
        topic = "test_topic", 					//topic：和消费者发送的topic相同
        consumerGroup = "test_my-consumer",     //group：不用和生产者group相同
        selectorExpression = "*") 			    //tag
@Component  //必须注入spring容器
//泛型必须和接收的消息类型相同
public class TestListner implements RocketMQListener<User> {

    @Override
    public void onMessage(User user) {
        System.out.println(user);
    }
}

接下来我们就自己实现@RocketMQMessageListener，我们为了区别就将注解命名为@RocketMqMsgListener

思路：

1.定义@RocketMqMsgListener

2.项目启动后扫描所有@RocketMqMsgListener注解的类

3.根据注解中的参数自动创建消费者

4.服务停止时自动停止消费者

 

1.定义@RocketMqMsgListener

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RocketMqMsgListener {

	/**
	 * 订阅主题
	 * @return
	 */
	String topic();
	
	/**
	 * 消费者组
	 * @return
	 */
	String consumerGroup();
	
	/**
	 * tag，订阅子查询条件，默认获取所有
	 * @return
	 */
	String selectorExpression() default "*";
	
	/**
	 * 查询类型 SelectorType.TAG根据tag查询   SelectorType.SQL92根据sql查询
	 * @return
	 */
	SelectorType selectorType() default SelectorType.TAG;
	
	/**
	 * 控制消息模式，如果希望所有订阅者都接收消息全部消息，广播是一个不错的选择。如果希望一个消费者接收则使用负载均衡模式
	 * @return
	 */
	MessageModel messageModel() default MessageModel.CLUSTERING;
    
    /**
     * 实例名称
     * @return
     */
    String instanceName() default "";
}

2.项目启动后扫描所有@RocketMqMsgListener注解的类

3.根据注解中的参数自动创建消费者

使用spring自带扫描，类实现ApplicationListener<ContextRefreshedEvent>会在容器启动后自动执行其中的onApplicationEvent(ContextRefreshedEvent event)方法

public class MqMsgLoadListener implements ApplicationListener<ContextRefreshedEvent>, DisposableBean {
	//扫描的类
	private Map<String, Object> beanMap = new HashMap<>();
	//消费者列表
	private List<SimpleConsumer> consumerList = new ArrayList<>();
	@Autowired
	private RocketConfig config;

	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		//如果是第二次加载则不处理了
		if(event.getApplicationContext().getParent() != null) {
			return;
		}
		
		//获取注解类
        beanMap = event.getApplicationContext().getBeansWithAnnotation(RocketMqMsgListener.class);
        System.out.println("================"+beanMap.size());
        //未扫描到不处理
        if(beanMap == null || beanMap.size() == 0) {
        	return;
        }
        for(Object bean : beanMap.values()) {
        	createConsumer(bean);
        }
	}

	/**
	 * 创建消费者
	 * @param bean
	 */
	private void createConsumer(Object bean) {
		if(!(bean instanceof MessageListenerConcurrently)) {
			return;
		}
		//获取注解
		RocketMqMsgListener mqMsgListener = bean.getClass().getAnnotation(RocketMqMsgListener.class);
		//配置
		ConsumerConfig consumerConfig = new ConsumerConfig();
		consumerConfig.setConsumeFromWhere(mqMsgListener.consumeFromWhere());
		consumerConfig.setTopic(mqMsgListener.topic());
		consumerConfig.setConsumerGroup(mqMsgListener.consumerGroup());
		consumerConfig.setSelectorExpression(mqMsgListener.selectorExpression());
		consumerConfig.setSelectorType(mqMsgListener.selectorType());
		consumerConfig.setMessageModel(mqMsgListener.messageModel());
		consumerConfig.setConsumeMode(mqMsgListener.consumeMode());
		if(!StringUtils.isEmpty(mqMsgListener.instanceName())) {
			consumerConfig.setInstanceName(mqMsgListener.instanceName());
		}
		//创建消费者
		SimpleConsumer consumer = new SimpleConsumer(config, consumerConfig, (MessageListenerConcurrently)bean);
		consumerList.add(consumer);
		//初始化并启动
		try {
			consumer.init();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 服务停止
	 */
	@Override
	public void destroy() throws Exception {
		for(SimpleConsumer consumer : consumerList) {
			if(consumer == null) {
				continue;
			}
			consumer.destroy();
		}
	}
}

xml中配置


	<!-- 启动监听 -->
	<bean id="mqMsgLoadListener" class="com.tes.rocket.annotation.listener.MqMsgLoadListener" />

4.服务停止时自动停止消费者

实现DisposableBean接口，服务停止时会自动调用destroy()方法，在destroy()释放消费者资源

/**
	 * 服务停止
	 */
	@Override
	public void destroy() throws Exception {
		for(SimpleConsumer consumer : consumerList) {
			if(consumer == null) {
				continue;
			}
			consumer.destroy();
		}
	}

 

使用注解

@Component
@RocketMqMsgListener(topic = "test_topic", consumerGroup = "rocketmq-test")
public class StringMessageListener implements MessageListenerConcurrently {
	private int total;

	@Override
	public ConsumeConcurrentlyStatus consumeMessage(List<MessageExt> msgs, ConsumeConcurrentlyContext context) {
		setTotal();
		for (MessageExt msg : msgs) {
			System.out.println("========收到消息："+new String(msg.getBody())+"---------总数："+total);
		}
		return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;
	}
	
	public synchronized void setTotal() {
		total++;
	}

	public int getTotal(){
		return total;
	}
}

 

完整代码

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd 
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context.xsd ">
	
	<!-- rocket mq配置 -->
	<bean id="rocketMQConfig" class="com.test.config.RocketConfig">
		<constructor-arg name="address" value="192.168.1.113:9876"/>
	</bean>
	
	<!-- 默认生产者 -->
	<bean id="producer" class="com.test.rocket.producer.SimpleProducer" init-method="init" destroy-method="destroy">
		<constructor-arg name="producerGroup" value="rocketmq-test" />
		<constructor-arg name="config" ref="rocketMQConfig"/>
	</bean>
	
	<!-- 扫描包 -->
	<context:component-scan base-package="com.test.**.mq.**" />
	<!-- 启动监听 -->
	<bean id="mqMsgLoadListener" class="com.test.rocket.annotation.listener.MqMsgLoadListener" />
</beans>

RocketMqMsgListener

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RocketMqMsgListener {

	/**
	 * 订阅主题
	 * @return
	 */
	String topic();
	
	/**
	 * 消费者组
	 * @return
	 */
	String consumerGroup();
	
	/**
	 * tag，订阅子查询条件，默认获取所有
	 * @return
	 */
	String selectorExpression() default "*";
	
	/**
	 * 查询类型 SelectorType.TAG根据tag查询   SelectorType.SQL92根据sql查询
	 * @return
	 */
	SelectorType selectorType() default SelectorType.TAG;
	
	/**
	 * 控制消息模式，如果希望所有订阅者都接收消息全部消息，广播是一个不错的选择。如果希望一个消费者接收则使用负载均衡模式
	 * @return
	 */
	MessageModel messageModel() default MessageModel.CLUSTERING;
    
    /**
     * 实例名称
     * @return
     */
    String instanceName() default "";
}

RocketConfig

public class RocketConfig implements Serializable {
	private static final long serialVersionUID = 6807425160034094787L;
	
	public RocketConfig() {
		
	}
	
	/**
	 * 创建配置对象
	 * @param address 服务地址，多个用;分割,例如"192.168.25.135:9876;192.168.25.138:9876"
	 */
	public RocketConfig(String address) {
		this.address = address;
	}

	//地址
	private String address;

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}
}

ConsumerConfig

public class ConsumerConfig implements Serializable {
	private static final long serialVersionUID = 10022583900545392332L;

	/**
	 * 订阅主题
	 * @return
	 */
	private String topic;
	
	/**
	 * 消费者组
	 * @return
	 */
	private String consumerGroup;
	
	/**
	 * 默认是tag，订阅子查询条件，默认获取所有
	 * 如果selectorType为sql，则值为sql
	 * @return
	 */
	private String selectorExpression = "*";
	
	/**
	 * 查询类型 SelectorType.TAG根据tag查询   SelectorType.SQL92根据sql查询
	 * @return
	 */
	private SelectorType selectorType;
	
	/**
	 * 控制消息模式，如果希望所有订阅者都接收消息全部消息，广播是一个不错的选择。如果希望一个消费者接收则使用负载均衡模式
	 * Control message mode, if you want all subscribers receive message all message, broadcasting is a good choice.
	 * @return
	 */
	private MessageModel messageModel;
    
    /**
     * 实例名称
     * @return
     */
	private String instanceName;

	public String getTopic() {
		return topic;
	}

	public void setTopic(String topic) {
		this.topic = topic;
	}

	public String getConsumerGroup() {
		return consumerGroup;
	}

	public void setConsumerGroup(String consumerGroup) {
		this.consumerGroup = consumerGroup;
	}

	public String getSelectorExpression() {
		return selectorExpression;
	}

	public void setSelectorExpression(String selectorExpression) {
		this.selectorExpression = selectorExpression;
	}

	public SelectorType getSelectorType() {
		return selectorType;
	}

	public void setSelectorType(SelectorType selectorType) {
		this.selectorType = selectorType;
	}

	public MessageModel getMessageModel() {
		return messageModel;
	}

	public void setConsumeMode(ConsumeMode consumeMode) {
		this.consumeMode = consumeMode;
	}

	public String getInstanceName() {
		return instanceName;
	}

	public void setInstanceName(String instanceName) {
		this.instanceName = instanceName;
	}
}

SelectorType

public enum SelectorType {

    /**
     * @see 根据tag查询
     */
    TAG,

    /**
     * @see 根据sql查询
     */
    SQL92
}

SimpleProducer

public class SimpleProducer {
	private String producerGroup;
	private RocketConfig config;
	
	private String instanceName;
	
	private DefaultMQProducer producer;
	
	public DefaultMQProducer getProducer() {
		return producer;
	}

	public SimpleProducer(RocketConfig config, String producerGroup){
		this.producerGroup = producerGroup;
		this.config = config;
	}
	
	public void init() throws MQClientException{
		producer = new DefaultMQProducer(producerGroup);
		producer.setNamesrvAddr(config.getAddress());
		if(instanceName != null) {
			producer.setInstanceName(instanceName);
		}
		producer.start();
	}
	
	public void destroy(){
		producer.shutdown();
	}

	public String getInstanceName() {
		return instanceName;
	}

	public void setInstanceName(String instanceName) {
		this.instanceName = instanceName;
	}
}

SimpleConsumer

public class SimpleConsumer {
	private DefaultMQPushConsumer consumer;
	//rocketMq配置
	private RocketConfig config;
	//消费者配置
	private ConsumerConfig consumerConfig;
	//消息监听器
	private MessageListenerConcurrently messageListener;
	
	public SimpleConsumer(RocketConfig config, ConsumerConfig consumerConfig, MessageListenerConcurrently messageListener){
		this.messageListener = messageListener;
		this.config = config;
		this.consumerConfig = consumerConfig;
 	}
	
	public void init() throws Exception{
		consumer = new DefaultMQPushConsumer(consumerConfig.getConsumerGroup());
		//服务地址
		consumer.setNamesrvAddr(config.getAddress());
		//实例名称
		if(consumerConfig.getInstanceName() != null) {
			consumer.setInstanceName(consumerConfig.getInstanceName());
		}
		//订阅主题
		if(consumerConfig.getSelectorType() == SelectorType.TAG) {//如果是根据tag过滤消息
			consumer.subscribe(consumerConfig.getTopic(), consumerConfig.getSelectorExpression());
		}else if(consumerConfig.getSelectorType() == SelectorType.SQL92) {//如果是根据sql过滤消息
			consumer.subscribe(consumerConfig.getTopic(), MessageSelector.bySql(consumerConfig.getSelectorExpression()));
		}
		//消息模式
		consumer.setMessageModel(consumerConfig.getMessageModel());
		//监听器
		consumer.registerMessageListener(messageListener);
		consumer.start();
	}

	public void destroy(){
		consumer.shutdown();
	}
	
	public DefaultMQPushConsumer getConsumer() {
		return consumer;
	}
}

MqMsgLoadListener

public class MqMsgLoadListener implements ApplicationListener<ContextRefreshedEvent>, DisposableBean {
	//扫描的类
	private Map<String, Object> beanMap = new HashMap<>();
	//消费者列表
	private List<SimpleConsumer> consumerList = new ArrayList<>();
	@Autowired
	private RocketConfig config;

	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		//如果是第二次加载则不处理了
		if(event.getApplicationContext().getParent() != null) {
			return;
		}
		
		//获取注解类
        beanMap = event.getApplicationContext().getBeansWithAnnotation(RocketMqMsgListener.class);
        System.out.println("================"+beanMap.size());
        //未扫描到不处理
        if(beanMap == null || beanMap.size() == 0) {
        	return;
        }
        for(Object bean : beanMap.values()) {
        	createConsumer(bean);
        }
	}

	/**
	 * 创建消费者
	 * @param bean
	 */
	private void createConsumer(Object bean) {
		if(!(bean instanceof MessageListenerConcurrently)) {
			return;
		}
		//获取注解
		RocketMqMsgListener mqMsgListener = bean.getClass().getAnnotation(RocketMqMsgListener.class);
		//配置
		ConsumerConfig consumerConfig = new ConsumerConfig();
		consumerConfig.setTopic(mqMsgListener.topic());
		consumerConfig.setConsumerGroup(mqMsgListener.consumerGroup());
		consumerConfig.setSelectorExpression(mqMsgListener.selectorExpression());
		consumerConfig.setSelectorType(mqMsgListener.selectorType());
		consumerConfig.setMessageModel(mqMsgListener.messageModel());
		if(!StringUtils.isEmpty(mqMsgListener.instanceName())) {
			consumerConfig.setInstanceName(mqMsgListener.instanceName());
		}
		//创建消费者
		SimpleConsumer consumer = new SimpleConsumer(config, consumerConfig, (MessageListenerConcurrently)bean);
		consumerList.add(consumer);
		//初始化并启动
		try {
			consumer.init();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 服务停止
	 */
	@Override
	public void destroy() throws Exception {
		for(SimpleConsumer consumer : consumerList) {
			if(consumer == null) {
				continue;
			}
			consumer.destroy();
		}
	}
}

示例代码抛砖引玉，要用于生产环境还需要完善

凌寒11
关注
  • 10
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Rocketmq
QQ418579986的博客
08-29 572
实战总结
Spring Boot集成RocketMQ全部种类消息实现+生产者和消费者配置信息介绍（内含5.x新增可自定义时间的定时/延时消息）
kerwin的博客
04-01 9106
Spring Boot集成RocketMQ全部种类消息实现+生产者和消费者配置信息介绍（内含5.x新增可自定义时间的定时/延时消息）
RocketMQ 优雅停机技巧，从头到尾，都是精华
最新发布
ccc6553584的博客
04-03 534
瞅了一眼consumer的代码（这里就不贴代码了，反正贴了你也不会看），consumer注册了一个ShutdownHook，ShutdownHook里consumer执行了shutdown来优雅地退出，并且给这个shutdownThread设置了最高优先级，然而从实践看来，这个线程最高优先级并没有什么卵用。而且从《ShutdownHook原理》这篇文章中也知道ShutdownHook是并发执行的，spring容器关闭也是一个ShutdownHook，他们之前没有先后顺序。
【Spring Boot】Spring Boot 集成 RocketMQ 实现简单的消息发送和消费
DreamSun的博客
08-05 3360
简单消息的发送顺序消息的发送RocketMQTemplate的API介绍环境搭建：RocketMQ的安装教程：在官网上下载bin文件，解压到本地，并配置环境变量，如下图所示：在 Spring boot 项目中引入 RocketMQ 依赖：
rocketMq 学习及实践（一）
LeAng_Lee的博客
12-26 3953
rocketmq 学习及实践
RocketMQ原理
qq1344691727的博客
08-11 1273
RocketMQ概览 简介 上图是一个典型的消息中间件收发消息的模型，RocketMQ也是这样的设计，简单说来，RocketMQ具有以下特点： 是一个队列模型的消息中间件，具有高性能、高可靠、高实时、分布式特点。 Producer、Consumer、队列都可以分布式。 Producer向一些队列轮流发送消息，队列集合称为Topic，Consumer如果做广播消费，则一个consumer实例消费这个Topic对应的所有队列，如果做集群消费，则多个Consumer实例平均消费这个topic对应的队
RocketMQ 消费端如何监听消息？
m0_71777195的博客
11-28 2223
目前只是将整体的一个消费端监听消息的流程了解清楚，里面还有许多细节需要去推敲~
RocketMQ保姆级教程
uuqaz的博客
08-28 4251
RocketMQ是阿里巴巴旗下一款开源的MQ框架，经历过双十一考验、Java编程语言实现，有非常好完整生态系统。RocketMQ作为一款纯java、分布式、队列模型的开源消息中间件，支持事务消息、顺序消息、批量消息、定时消息、消息回溯等，总之就是葛大爷的一句话通过上面的理论介绍和实际的环境搭建再加上代码的测试，相信应该可以对RocketMQ有个入门，有兴趣的小伙伴可以手动搭起来，整个过程顺利的话可能就十几二十分钟这样子。...
使用Kotlin+RocketMQ实现延时消息的示例代码
08-25
使用Kotlin+RocketMQ实现延时消息的示例代码 延时消息是指消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。使用延时消息的典型场景，例如：在电商系统中，用户下...
分布式开放消息系统(RocketMQ)的原理与实践
01-27
本文来自于简书，介绍了关键特性以及其实现原理，Rocket MQ最佳实践，专业术语和整体架构等知识。消息有序指的是一类消息消费时，能按照发送的顺序来消费。例如：一个订单产生了3条消息，分别是订单创建、订单付款、...
RocketMQ自定义selector实现消息通道定向发送和拉取
04-26
NULL 博文链接：https://hbxflihua.iteye.com/blog/2370891
rocket mq 视频（龙果）
08-23
这个视频是龙果 的rocket mq视频，讲的非常不错。分为上下两个系列。直接用txt 打开后。里边是百度云资源
springboot1.5.10.RELEASE集成rocketmq4.3.1消息服务demo，多个消费者多监听
08-03
springboot1.5.10.RELEASE集成rocketmq4.3.1消息服务demo，多个消费者多监听
一、RocketMQ介绍
m_lonel的博客
08-26 967
2011年，Linkin(领英：全球知名的职场社交平台)推出Kafka消息引擎，阿里巴巴中间件团队在研究了Kafka的整体机制和架构设计之后，基于Kafka(Scala语言编写)的设计使用Java进行了完全重写并推出了MetaQ 1.0版本，主要是用于解决顺序消息和海量堆积的问题，由开源社区killme2008维护。......
SpringBoot RocketMQ消息监听器(RocketMQMessageListener)后置注册
TianXinCoord的博客
09-23 4165
SpringBoot RocketMQ可以从源码中查看到实现了**SmartInitializingSingleton**接口，在所有Bean注册完成之后就会开始注册，注册使用的是main线程，就会导致如果消息队列积压大量消息时注册占用main线程时间过长，导致SpringBoot不能完全完成初始化（主要影响web无法对外提供接口访问）
RocketMq踩坑
眼神多像云朵
02-27 1617
provider 默认情况下不需要设置instanceName，rocketmq会使用ip@pid(pid代表jvm名字)作为唯一标示 　　如果同一个jvm中，不同的producer需要往不同的rocketmq集群发送消息，需要设置不同的instanceName 原因如下：如果不设置instanceName，那么会使用ip@pid作为producer唯一标识，那么会导致多个producer内部只有一个MQClientInstance(与mq交互)实例，从而导致只往一个集群发消息。 consumer 默认情况
springboot+rocketmq（6）:实现消息过滤
12程序猿的博客
07-04 3331
springboot+rocketmq（6）:实现消息过滤
RocketMQListener监听器的使用思考
热门推荐
一只蜗牛的博客
04-26 2万+
前言 刚开始用Spring-rocketmq时，好奇怎么只需要一个实现了RocketMQListener接口的自定义监听器就可以消费消息了： 这个自定义的消息监听器里，并没有如rocketmq原生Consumer那样对消息进行ack或者nack，那他到底是怎么控制的？为此专门看了下源码，全局搜了@RocketMQMessageListener注解，搜到一些东西，分享下： 源码 首先ListenerContainerConfiguration实现了SmartInitializingSingleto
java spring rocket 实现监听消息
05-10
Java Spring RocketMQ 提供了多种方式实现消息监听。以下是其中两种常用方式： 1. 使用 @RocketMQMessageListener 注解 首先，需要在项目中引入 rocketmq-spring-boot-starter 依赖，然后在需要监听消息的方法上加上 @RocketMQMessageListener 注解，如下所示： ```java @RocketMQMessageListener(topic = "test-topic", consumerGroup = "test-group") public class TestRocketMQListener implements RocketMQListener<String> { @Override public void onMessage(String message) { // 处理接收到的消息 } } ``` 上述代码中，@RocketMQMessageListener 注解中的 topic 属性表示要监听的消息主题，consumerGroup 属性表示消费者组名，RocketMQListener 接口中的泛型表示接收到消息的类型。 2. 实现 RocketMQListener 接口 另一种方式是实现 RocketMQListener 接口，如下所示： ```java @Component public class TestRocketMQListener implements RocketMQListener<String> { @Override @RocketMQMessageListener(topic = "test-topic", consumerGroup = "test-group") public void onMessage(String message) { // 处理接收到的消息 } } ``` 上述代码中，通过在类上加上 @Component 注解，将其注入到 Spring 容器中。然后在 onMessage 方法上加上 @RocketMQMessageListener 注解，表示要监听的消息主题和消费者组名。 以上两种方式都可以实现 RocketMQ 消息的监听，具体选择哪种方式取决于实际需求和个人喜好。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值