Springboot通过redisTemplate实现发布订阅

最新推荐文章于 2024-09-14 19:25:10 发布
原创 最新推荐文章于 2024-09-14 19:25:10 发布 · 3.8k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍如何在SpringBoot中利用Redis实现发布订阅功能，包括配置Redis连接、消息监听及序列化过程。通过实例演示了如何创建监听器、处理消息，并展示了两种实现方式。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Springboot通过redisTemplate实现发布订阅

要点：

RedisMessageListenerContainer Redis订阅发布的监听容器，你的消息发布、订阅配置都必须在这里面实现
* addMessageListener（MessageListenerAdapter，PatternTopic） 新增订阅频道及订阅者，订阅者必须有相关方法处理收到的消息。
* setTopicSerializer(RedisSerializer) 对频道内容进行序列化解析

MessageListenerAdapter 监听适配器

  • MessageListenerAdapter(Object , defaultListenerMethod) 订阅者及其方法

redisTemplate redis模版类

  • convertAndSend（String channel, Object message） 消息发布

第一种：

RedisConfig核心类，实现了Redis连接，订阅以及发布配置

package com.example.demo.config;

import com.example.demo.project.MessageReceive1;
import com.example.demo.project.MessageReceive2;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
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 org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认的jdkSerializeable序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * redis消息监听器容器
     * 可以添加多个监听不同话题的redis监听器，只需要把消息监听器和相应的消息订阅处理器绑定，该消息监听器
     * 通过反射技术调用消息订阅处理器的相关方法进行一些业务处理
     * @param redisConnectionFactory
     * @param listenerAdapter1
     * @return
     */
    //序列化对象（特别注意：发布的时候需要设置序列化；订阅方也需要设置序列化）
    @Bean
    public RedisMessageListenerContainer container1(RedisConnectionFactory redisConnectionFactory, MessageListenerAdapter listenerAdapter1, MessageListenerAdapter listenerAdapter2) {
        RedisMessageListenerContainer redisMessageListenerContainer = new RedisMessageListenerContainer();
        redisMessageListenerContainer.setConnectionFactory(redisConnectionFactory);
        // 订阅多个频道
        redisMessageListenerContainer.addMessageListener(listenerAdapter1, new PatternTopic("test1"));
        redisMessageListenerContainer.addMessageListener(listenerAdapter1, new PatternTopic("test2"));
        //不同的订阅者
        redisMessageListenerContainer.addMessageListener(listenerAdapter2, new PatternTopic("test2"));

        //序列化对象（特别注意：发布的时候需要设置序列化；订阅方也需要设置序列化）
        Jackson2JsonRedisSerializer seria = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        seria.setObjectMapper(objectMapper);
        redisMessageListenerContainer.setTopicSerializer(seria);
        return redisMessageListenerContainer;
    }


    //表示监听一个频道
    @Bean
    public MessageListenerAdapter listenerAdapter1(MessageReceive1 messageReceive1) {
        //这个地方 是给messageListenerAdapter 传入一个消息接受的处理器，利用反射的方法调用“MessageReceive1 ”
        return new MessageListenerAdapter(messageReceive1, "getMessage");
    }

    //表示监听一个频道
    @Bean
    public MessageListenerAdapter listenerAdapter2(MessageReceive2 messageReceive2) {
        //这个地方 是给messageListenerAdapter 传入一个消息接受的处理器，利用反射的方法调用“MessageReceive2 ”
        return new MessageListenerAdapter(messageReceive2, "getMessage");
    }
}

被消费的对象(即传输的数据)

@Data
public class Person implements Serializable {
    private final long serialVersionUID = 1L;

    private String id;

    private String userName;

    private String memberName;

    private String password;

    private String email;

    private String status;

    private String pwdSalt;

}

客户端：

@Component
public class MessageReceive1 {
    public void getMessage(String object) {
//序列化对象（特别注意：发布的时候需要设置序列化；订阅方也需要设置序列化）
        Jackson2JsonRedisSerializer seria = new Jackson2JsonRedisSerializer(Person.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        seria.setObjectMapper(objectMapper);
        Person user = (Person) seria.deserialize(object.getBytes());
        System.out.println("消息客户端1号：" + user.toString());
    }
}

@Component
public class MessageReceive2 {
    public void getMessage(String object) {
//序列化对象（特别注意：发布的时候需要设置序列化；订阅方也需要设置序列化）
        Jackson2JsonRedisSerializer seria = new Jackson2JsonRedisSerializer(Person.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        seria.setObjectMapper(objectMapper);
        Person user = (Person) seria.deserialize(object.getBytes());
        System.out.println("消息客户端2号：" + user);
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestPack {
    @Resource
    private RedisTemplate redisTemplate;
    @Test
    public void test() {
        Person person1 = new Person();
        person1.setId("001");
        person1.setUserName("一号");
        Person person2 = new Person();
        person2.setId("002");
        person2.setUserName("二号");
        redisTemplate.convertAndSend("test1", person1);
        redisTemplate.convertAndSend("test2", person2);
    }
}

第二种（简单版）：

配置类：

@Configuration
public class MyRedisConf {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认的jdkSerializeable序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    @Bean
    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                                   MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("test1"));
        return container;
    }

    /**
     * 绑定消息监听者和接收监听的方法,必须要注入这个监听器，不然会报错
     */
    @Bean
    public MessageListenerAdapter listenerAdapter() {
        return new MessageListenerAdapter(new Receiver(), "receiveMessage");
    }
}

@Slf4j
class Receiver {
    public void receiveMessage(String message) {
        System.out.println(message);
    }
}

测试类：

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestPack {
    @Resource
    private RedisTemplate redisTemplate;
    @Test
    public void test(){
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            redisTemplate.convertAndSend("test1","这是我发送的第"+i+"个消息");
        }
    }

}
springboot 整合使用redis发布订阅功能
congge_study的博客
09-04 1万+
springboot 整合使用redis发布订阅功能
5分钟实现springboot整合redis发布订阅功能
猿脑2.0的博客
06-16 472
请注意，以上代码示例可能需要根据你的具体需求进行调整。此外，确保Redis服务器已正确配置并正在运行，以便能够成功地进行发布和订阅操作。接口时，Redis会发布消息到指定的频道（topic），而订阅了该频道的所有客户端都会收到消息。
RedisTemplate 批量操作、发布订阅、事务、管道
suk_java的博客
07-16 872
RedisTemplate 批量操作、发布订阅、事务、管道
RedisTemplate实现发布订阅
qq_44300280的博客
03-19 4536
RedisTemplate实现发布订阅
Redis发布订阅
LB_bei的博客
07-22 935
环境：windows10、jdk17、springboot3Redis有两种发布订阅模式：频道发布订阅、模式发布订阅频道就是消息发到指定频道，订阅此频道的客户端都能收到消息；模式发布订阅就是匹配以xxx为开头的多个频道；我们这里用的是频道发布订阅，模式发布订阅不做讨论。
Redis通过redisTemplate实现发布订阅
qq_35406874的博客
05-06 2604
RedisConfig核心类，实现了Redis连接，订阅以及发布配置 @Configuration public class RedisConfig { /** * redisTemplate配置 * * @param redisConnectionFactory redis连接工厂 * @return RedisTemplate */ @Bean public RedisTemplate<String, String&gt.
Redis发布订阅及SpringBoot集成Redis实现发布订阅消息
2301_79351943的博客
04-30 814
Redis发布订阅提供了简单的消息队列功能，但实际应用较少，因为其模式单一、消息丢失性高，但其简单易用，常用于日志等不重要的数据传输。
Spring boot项目redisTemplate实现轻量级消息队列的方法
08-26
在这个场景下，我们将使用RedisTemplate的`lpush`和`rpop`方法来实现消息的发布和订阅，即生产者和消费者模型。 首先，我们需要在项目中添加相关的依赖。Spring Boot的`spring-boot-starter-redis`依赖提供了与...
SpringBoot + Redis实现事件的发布订阅功能
12-17
本话题主要探讨如何利用SpringBoot和Redis实现事件的发布订阅功能，这对于实现分布式系统中的异步通信和解耦至关重要。 首先，我们需要理解SpringBoot的核心特性。SpringBoot是Spring框架的一个简化版本，它旨在...
SpringBoot redisTemplate 实现基础订阅与发布
bbs_zhi的专栏
05-15 1639
... <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.3.RELEASE</version> </parent> ... <dependency> .
SpringBoot集成Redis消息订阅发布
业精于勤-行成于思
07-20 8257
SpringBoot集成Redis消息订阅发布
Redis如何实现发布订阅功能？
m0_74293254的博客
07-30 1258
Redis的发布订阅功能提供了一个高效的消息传递机制，特别适用于需要实时通信和广播的场景。发布者可以向一个或多个频道发布消息，而订阅者则可以选择性地接收他们感兴趣的频道的消息，从而实现了灵活的消息传递和处理。这种模式对于构建实时聊天、消息推送、实时数据更新等应用非常有用，能够有效地降低系统的耦合度和增强实时性。
Redis实现发布/订阅功能（实战篇）
最新发布
weixin_63944437的博客
09-14 2020
全网最详细最全面的关于Redis实现消息队列的知识讲解！网上的很多博文不是看的一知半解，就是代码有问题，压根运行不起来。于是博主花费数天时间完成这项工作。只为让以后学习的朋友们少踩坑。
SpringBoot RedisTemplate 发布订阅
ljh_learn_from_base的博客
08-31 4208
使用window 版本的redis 1.打开一个 cmd 窗口 使用cd命令切换目录到redis安装目录下运行 redis-server.exe redis.windows.conf 2.这时候另启一个cmd窗口，还是切换到redis安装目录下,原来的不要关闭，不然就无法访问服务端了 输入：redis-cli.exe -h 127.0.0.1 -p 6379 进入127.0.0....
springboot-redis-messageListener
weixin_39523456的博客
04-10 3198
主要实现两个功能1.过期事件监听 KeyspaceEventMessageListener2.发布订阅 RedisMeaasgeListener DispatchMessageListener MessagelistenerAdapter。
redisTemplate操作redis实现sub/sub发布订阅功能
weixin_46855885的博客
04-08 1806
redisTemplate操作redis实现sub/pub实现发布订阅功能
Spring Boot StringRedisTemplate 发布订阅
sjy_2010的专栏
12-10 1879
Spring Boot StringRedisTemplate 发布订阅
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、付费专栏及课程。

余额充值