SpringBoot整合Redis实现消息发布订阅

最新推荐文章于 2024-06-10 19:24:17 发布
最新推荐文章于 2024-06-10 19:24:17 发布
阅读量684 收藏 4
点赞数
分类专栏： redis 文章标签： spring boot redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39956506/article/details/129151277
版权

SpringBoot整合Redis实现消息发布订阅

Redis常量配置

public class RedisConstant {
    /**
   	 * 消息订阅点赞主题
   	 */
   	public static final String TOPIC_PRAISE = "TOPIC_PRAISE";
   	/**
   	 * 消息订阅收藏主题
   	 */
   	public static final String TOPIC_COLLECT = "TOPIC_COLLECT";
   	/**
   	 * 消息订阅评论主题
   	 */
   	public static final String TOPIC_COMMENT = "TOPIC_COMMENT";
   	/**
   	 * 消息订阅关注主题
   	 */
   	public static final String TOPIC_FOCUS = "TOPIC_FOCUS";
}

配置消息处理器

package com.java.single.service.impl;
import java.util.concurrent.CountDownLatch;
import com.java.single.entity.res.MessageCollect;
import com.java.single.entity.res.MessageComment;
import com.java.single.entity.res.MessageFocus;
import com.java.single.util.PushUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class ReceiverServiceImpl {

	private CountDownLatch latch;

	@Autowired
	public ReceiverServiceImpl(CountDownLatch latch) {
		this.latch = latch;
	}

	public void praiseReceive(MessagePraise messagePraise) {
		log.info("消费点赞数据:[{}]", messagePraise);
		PushUtil.pushOne(messagePraise.getToUserId(), "新消息",
				messagePraise.getUserName() + "点赞您的" + messagePraise.getTitle() + " 作品");
		latch.countDown();
	}

	public void collectReceive(MessageCollect messageCollect) {
		log.info("消费收藏数据:[{}]", messageCollect);
		PushUtil.pushOne(messageCollect.getToUserId(), "新消息",
				messageCollect.getUserName() + "收藏了您的" + messageCollect.getTitle() + " 作品");
		latch.countDown();
	}

	public void commentReceive(MessageComment messageComment) {
		log.info("消费评论数据:[{}]", messageComment);
		PushUtil.pushOne(messageComment.getToUserId(), "您有新的评论",
				messageComment.getUserName() + "对" + messageComment.getTitle() + "进行了评论:" + messageComment.getText());
		latch.countDown();
	}

	public void focusReceive(MessageFocus messageFocus) {
		log.info("消费关注数据:[{}]", messageFocus);
		PushUtil.pushOne(messageFocus.getToUserId(), "新消息", messageFocus.getUserName() + "关注了您");
		latch.countDown();
	}
}

上述为消息处理器，目前无用,需要后面配置。
PushUtil为个人封装的个推消息推送工具类，可以删除，根据自己逻辑决定相关操作。
上述一共写了四种主题，以其中一种主题为例，实际项目中按照自己需求更改

配置订阅消息处理

package com.java.single.entity.res;
 import java.io.Serializable;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 
 @Data
 @NoArgsConstructor
 public class MessageCollect implements Serializable {
 	/**
 	 * 
 	 */
 	private static final long serialVersionUID = 1L;
 	/**
 	 * 收藏数据标识
 	 */
 	private String id;
 	/**
 	 * 收藏用户标识
 	 */
 	private String userId;
 	/**
 	 * 收藏用户名字
 	 */
 	private String userName;
 	/**
 	 * 收藏数据名称
 	 */
 	private String title;
 	/**
 	 * 收藏目标用户
 	 */
 	private String toUserId;
 	/**
 	 * 
 	 * @param id
 	 *            收藏数据标识
 	 * @param userId
 	 *            收藏用户标识
 	 * @param userName
 	 *            收藏用户名字
 	 * @param title
 	 *            收藏数据名称
 	 * @param toUserId
 	 *            收藏目标用户
 	 */
 	public MessageCollect(String id, String userId, String userName, String title, String toUserId) {
 		super();
 		this.id = id;
 		this.userId = userId;
 		this.userName = userName;
 		this.title = title;
 		this.toUserId = toUserId;
 	}
}

注意，这个类有两点需要注意：1、必须实现序列化。2、必须有无参构造方法。

配置RedisMessageListener配置类

import java.util.concurrent.CountDownLatch;
import com.java.single.constant.RedisConstant;
import com.java.single.service.impl.ReceiverServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisMessageListener {

	/**
	 * redis消息监听器容器
	 * 
	 * @param connectionFactory
	 * @param praiseListenerAdapter
	 *            点赞消息订阅处理器
	 * @param collectListenerAdapter
	 *            收藏消息订阅处理器
	 * @param commentListenerAdapter
	 *            评论消息订阅处理器
	 * @param focusListenerAdapter
	 *            关注消息订阅处理器
	 * @return
	 */
	@Bean
	RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
			MessageListenerAdapter praiseListenerAdapter, MessageListenerAdapter collectListenerAdapter,
			MessageListenerAdapter commentListenerAdapter, MessageListenerAdapter focusListenerAdapter) {
		RedisMessageListenerContainer container = new RedisMessageListenerContainer();
		container.setConnectionFactory(connectionFactory);
		
		// 以下为修改默认的序列化方式，网上大多数消息发布订阅都是String类型,但是实际中数据类型肯定不止String类型
		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
				Object.class);
		ObjectMapper objectMapper = new ObjectMapper();
		objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
		objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
		jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
		
		// 针对每一个消息处理可以设置不同的序列化方式
		
		praiseListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
		// 点赞主题并绑定消息订阅处理器
		container.addMessageListener(praiseListenerAdapter, new PatternTopic(RedisConstant.TOPIC_PRAISE));
		// 收藏主题并绑定消息订阅处理器
		collectListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
		container.addMessageListener(collectListenerAdapter, new PatternTopic(RedisConstant.TOPIC_COLLECT));
		// 评论主题并绑定消息订阅处理器
		commentListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
		container.addMessageListener(commentListenerAdapter, new PatternTopic(RedisConstant.TOPIC_COMMENT));
		// 关注主题并绑定消息订阅处理器
		focusListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
		container.addMessageListener(focusListenerAdapter, new PatternTopic(RedisConstant.TOPIC_FOCUS));
		return container;
	}

	/**
	 * 点赞消息订阅处理器,并指定处理方法
	 * 
	 * @param receiver
	 * @return
	 */
	@Bean
	MessageListenerAdapter praiseListenerAdapter(ReceiverServiceImpl receiver) {
		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "praiseReceive");
		return messageListenerAdapter;
	}

	/**
	 * 收藏消息订阅处理器,并指定处理方法
	 * 
	 * @param receiver
	 * @return
	 */
	@Bean
	MessageListenerAdapter collectListenerAdapter(ReceiverServiceImpl receiver) {
		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "collectReceive");
		return messageListenerAdapter;
	}

	/**
	 * 评论消息订阅处理器,并指定处理方法
	 * 
	 * @param receiver
	 * @return
	 */
	@Bean
	MessageListenerAdapter commentListenerAdapter(ReceiverServiceImpl receiver) {
		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "commentReceive");
		return messageListenerAdapter;
	}

	/**
	 * 关注消息订阅处理器,并指定处理方法
	 * 
	 * @param receiver
	 * @return
	 */
	@Bean
	MessageListenerAdapter focusListenerAdapter(ReceiverServiceImpl receiver) {
		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "focusReceive");
		return messageListenerAdapter;
	}

	@Bean
	ReceiverServiceImpl receiver(CountDownLatch latch) {
		return new ReceiverServiceImpl(latch);
	}

	@Bean
	CountDownLatch latch() {
		return new CountDownLatch(1);
	}
}

注释应该已经足够，注意一定要修改序列化方法，否则使用的是默认是String类型的序列化方法，ReceiverServiceImpl方法接收到String类型的参数还需要再次转化为指定类！！！！

发布消息

redisTemplate.convertAndSend(RedisConstant.TOPIC_COLLECT,
					new MessageCollect(id, userPublish.getUserId(), userName, title, userId));

在使用的时候需要将构造函数的参数设置成自己的，这样项目启动之后执行上述方法后ReceiverServiceImpl的collectReceive方法就会自动处理这条消息，决定什么方法执行什么操作的配置在RedisMessageListener中实现。

日志打印：

消费收藏数据:[MessageCollect(id=c8738aed3ef9421898ebb4be62a11111, 
userId=6e5c7e33cbd34453b3273ed775e11111, userName=single_cong, title=CSDN博客, toUserId=d8e87f6615f64368a53bd6b4dbebc111)]

总结
网上绝大部分都是String类型的消息发布订阅，肯定无法满足现实需求，所以要自定义序列化方式并实现主题与对应的处理方法的配置，在这里需要注意两点，第一点是序列化类型的选择，第二是这里序列化的类需要有无参构造方法（给人的感觉类似MyBatis返回结果集时报构造函数不存在时添加无参构造函数就能解决一样）。

jarenyVO
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】36、SpringBoot整合Redis实现发布/订阅
Asurplus
10-23 21万+
一、简介 1、发布订阅 SUBSCRIBE, UNSUBSCRIBE 和 PUBLISH 实现了 发布/订阅消息范例，发送者 (publishers) 不用编程就可以向特定的接受者发送消息 (subscribers). Rather, 发布的消息进入通道，不需要知道有没有订阅者. 订阅者发表感兴趣的一个或多个通道，并且只接受他们感兴趣的消息，不管发布者是不是存在. 发布者和订阅者的解耦可以允许更大的伸缩性和更多动态的网络拓扑。 2、说明 本篇文章是继： 【SpringBoot】三十四、SpringBoot
SpringBoot Redis发布订阅
爱码猿的博客
05-09 1399
【代码】SpringBoot Redis发布订阅。
在Spring Boot中使用Redis的发布订阅功能
好看的皮囊千篇一律，有趣的灵魂万里挑一。
11-16 1797
Redis的发布订阅模式是一种消息传递模式，==它允许多个订阅者订阅一个或多个频道，同时一个发布者可以将消息发布到指定的频道==。这种模式在分布式系统中非常有用，可以解决以下问题： - **实时消息传递**：发布订阅模式可以用于实时消息传递，当发布者发布消息到指定频道时，所有订阅该频道的订阅者都能够接收到消息。这对于实时通信、聊天应用、实时数据更新等场景非常有用。 - **解耦系统组件**：发布订阅模式可以将系统的不同组件解耦，使得它们可以独立地进行通信。发布者和订阅者之间不需要直接知道彼此的存在，它们
Spring Boot整合Redis实现发布/订阅功能
最新发布
傲泣龙腾的博客
06-10 1万+
Redis作为一个高性能的内存数据存储，除了支持缓存和持久化数据，它还有很多功能，如：在博主分享的上一篇文章中，我们介绍了使用Redis实现的延迟队列功能【Spring Boot整合Redis通过Zset数据类型+定时任务实现延迟队列】发布/订阅（Pub/Sub）发布/订阅是一种消息通信模式，其中发送者（发布者）发布消息，多个接收者（订阅者）订阅并接收这些消息。发布者和订阅者之间没有直接联系，消息由消息中间件（如Redis）传递。通过本文，我们详细介绍了如何在中整合Redis。
springboot中 玩转redis的发布订阅
做一个有思想的技术人
03-10 1561
文章目录redis的发布订阅集成到springboot中集成测试 一般我们使用redis最多的场景还是作为缓存中间件使用，redis也能做为消息队列使用，但这不是Redis的强项，不过如果需要的话还是可以使用的。 redis的发布订阅 集成到springboot中 引入redis starter <dependency> <groupId>org.springframework.boot</groupId> <artifactId>sp
springboot+redis自定义注解实现发布订阅
m0_71777195的博客
08-12 329
我们内部组件抽象了两个方法，生产和消费，但这两个方法逻辑截然不同，生产方法是暴露给serverice层接口调用，调用方在调用生产方法后能直接知道生产了几条数据和成功与否。而消费方法是配合Spring生命周期函数服务启动时建立常驻消费线程的。scss复制代码/*** 生产消息*//*** 消费消息*/生产消息当然很容易实现，只需要调用已经封装好的convertAndSend方法。
微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单
11-10
【微服务SpringBoot整合Redis基于Redis的Stream消息队列实现异步秒杀下单】这篇文章主要讲解了如何在微服务架构中使用SpringBoot整合Redis来构建一个基于Redis Stream的消息队列，以此来实现实时、高效的异步秒杀...
SpringBoot + Redis实现事件的发布订阅功能
12-17
接下来，我们详细讲解如何在SpringBoot应用中整合Redis实现事件发布订阅。 1. **集成Redis** - 在`pom.xml`中添加Spring Data Redis和Jedis客户端的依赖。 - 配置`application.yml`或`application.properties`，...
SpringBoot 整合 Redis、mybatis 完整项目源码下载
05-26
**SpringBoot整合Redis** 1. **配置Redis**: 在SpringBoot项目中，可以通过`application.properties`或`application.yml`文件配置Redis连接信息，包括主机地址、端口、密码等。 2. **添加依赖**: 在`pom.xml`文件...
springboot与redis整合
10-26
3. **SpringBoot整合Redis** - **添加依赖**：在SpringBoot项目中，首先需要在`pom.xml`或`build.gradle`文件中引入Redis的依赖，通常使用`spring-boot-starter-data-redis`起步依赖。 - **配置Redis**：在`...
Springboot整合Redis实现消息发布订阅
qq_42077317的博客
12-13 919
有时候在实际项目中，某些业务场景下我们需要使用消息的发布订阅功能，以实现某些特殊的需求，那么我们实际上可以有多种选择，比如使用常见的消息中间件Rabbitmq，Kafka，Activemq等，但这几个都算是重量级的消息队列，使用成本相比较于Redis要高，而在有些业务中，我们可能只是想实现消息的发布订阅，并不是需要保证消息的完全的可靠性没有很高的要求，那么使用Redis无疑是最好的选择。3.实现自定义的Redis 消息订阅-消息监听器，处理收到的订阅消息。6.我们也可以在Controller测试下。
springboot集成kafka进行消息发布和订阅jar
05-22
java程序实现springboot集成kafka进行消息发布和订阅并打包，可直接进行linux主机应用。支持动态修改kafka集群配置，和监听主题；支持动态指向jdk版本。
springboot整合redis，spring aop实现接口缓存
一切简单化
08-29 885
springboot 2.x整合redis，spring aop实现接口缓存
SpringBoot+redis实现消息队列(发布/订阅)
hauchun的博客
02-03 1222
SpringBoot+redis实现消息队列(发布/订阅)
SpringBoot中实现消息的发布与订阅
weixin_44203221的博客
03-13 784
使用。
SpringBoot+消息队列RocketMQ(基于阿里云)
Jason
09-26 3836
最近由于公司技术框架更新，原先的RabbitMQ需要换成RocketMQ，其实两者大致原理都差不多，使用起来也是大同小异
【案例】SpringBoot使用Redis发布订阅
qq_40738239的博客
07-21 604
【案例】SpringBoot使用Redis发布订阅
Springboot Websocket Stomp 消息订阅推送实战
代码大师麦克拉瑞的博客
07-08 7338
闲话不扯，直奔主题。需要和web前端建立长链接，互相实时通讯，因此想到了websocket，后面随着需求的变更，需要用户订阅主题，实现消息的精准推送，发布订阅等，则想到了STOMP(Simple Text-Orientated Messaging Protocol) 面向消息的简单文本协议。
springboot整合redis实现发布订阅消息例子
09-26
### 回答1： 可以使用 RedisTemplate 实现发布订阅消息，具体实现可以参考以下代码： 1. 配置 RedisTemplate ``` @Configuration public class RedisConfig { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(redisConnectionFactory); redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return redisTemplate; } } ``` 2. 发布消息 ``` @Autowired private RedisTemplate<String, Object> redisTemplate; public void publish(String channel, Object message) { redisTemplate.convertAndSend(channel, message); } ``` 3. 订阅消息 ``` @Component public class RedisMessageSubscriber implements MessageListener { @Override public void onMessage(Message message, byte[] bytes) { String channel = new String(message.getChannel()); Object messageBody = redisTemplate.getValueSerializer().deserialize(message.getBody()); // 处理消息 } @Autowired private RedisTemplate<String, Object> redisTemplate; @PostConstruct public void subscribe() { redisTemplate.execute((RedisCallback<Void>) connection -> { connection.subscribe(this::onMessage, "channel1".getBytes()); return null; }); } } ``` 以上代码实现了一个简单的发布订阅消息功能，可以根据实际需求进行修改和扩展。 ### 回答2： Spring Boot是一个基于Java的开源框架，它提供了快速构建应用程序的能力。Redis是一个高性能的键值对存储数据库，可以用于缓存、消息队列等场景。 在Spring Boot中整合Redis实现发布订阅消息可以使用Redisson这个开源框架。下面是一个示例： 首先，在pom.xml文件中添加Redisson的依赖： ```xml <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.15.1</version> </dependency> ``` 然后，在application.properties文件中配置Redis连接信息： ```properties spring.redis.host=localhost spring.redis.port=6379 ``` 接下来，创建一个消息发布者： ```java @Component public class MessagePublisher { @Autowired private RedissonClient redissonClient; public void publishMessage(String channel, String message) { RTopic<String> topic = redissonClient.getTopic(channel); topic.publish(message); } } ``` 再创建一个消息订阅者： ```java @Component public class MessageSubscriber { @PostConstruct public void subscribeMessages() { RPatternTopic<String> topic = redissonClient.getPatternTopic("messages.*"); topic.addListener(new PatternMessageListener<String>() { @Override public void onMessage(CharSequence pattern, CharSequence channel, String message) { // 处理消息 System.out.println("Received message: " + message); } }); } } ``` 最后，在需要发布消息的地方调用发布者的publishMessage方法即可： ```java @Autowired private MessagePublisher messagePublisher; public void sendMessage() { messagePublisher.publishMessage("messages.test", "Hello, Redis!"); } ``` 以上是一个简单的Spring Boot整合Redis实现发布订阅消息的例子。通过配置Redis连接信息和使用Redisson框架，可以方便地实现消息发布和订阅的功能。 ### 回答3： Spring Boot整合Redis实现发布订阅消息的例子非常简单。首先，我们需要在pom.xml文件中添加Redis和Spring Boot依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ``` 接下来，在application.properties文件中配置Redis的连接信息： ``` spring.redis.host=127.0.0.1 spring.redis.port=6379 ``` 然后，我们创建一个消息发布者和一个消息订阅者的类。发布者负责发布消息，订阅者负责接收并处理消息。 发布者的示例代码如下： ``` @Component public class MessagePublisher { @Autowired private RedisTemplate<String, Object> redisTemplate; public void publish(String channel, String message) { redisTemplate.convertAndSend(channel, message); } } ``` 订阅者的示例代码如下： ``` @Component public class MessageSubscriber { @Autowired private RedisTemplate<String, Object> redisTemplate; private CountDownLatch latch; public MessageSubscriber(CountDownLatch latch) { this.latch = latch; } public void receiveMessage(String message) { System.out.println("Received message: " + message); latch.countDown(); } @Bean public MessageListenerAdapter messageListener() { return new MessageListenerAdapter(this); } @Bean public RedisMessageListenerContainer redisContainer(RedisConnectionFactory connectionFactory, MessageListenerAdapter messageListener) { RedisMessageListenerContainer container = new RedisMessageListenerContainer(); container.setConnectionFactory(connectionFactory); container.addMessageListener(messageListener, new PatternTopic("channel")); // 替换为实际的频道名称 return container; } } ``` 最后，我们创建一个包含main方法的启动类，并在该类中注入发布者和订阅者的实例，并进行消息发布和订阅的测试： ``` @SpringBootApplication public class RedisPubSubExampleApplication { public static void main(String[] args) { ApplicationContext ctx = SpringApplication.run(RedisPubSubExampleApplication.class, args); MessagePublisher publisher = ctx.getBean(MessagePublisher.class); publisher.publish("channel", "This is a test message"); CountDownLatch latch = ctx.getBean(CountDownLatch.class); try { latch.await(); } catch (InterruptedException e) { e.printStackTrace(); } } } ``` 以上就是使用Spring Boot整合Redis实现发布订阅消息的例子。通过简单的配置和几行代码，我们就可以实现消息的发布和订阅功能。需要注意的是，这只是一个简单的示例，实际应用中可能需要更多的配置和处理逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值