Spring Boot文档阅读笔记-Messaging with Redis

﹏ヽ暗。殇╰゛Y 2023-01-05 12:22 201阅读 0赞

首先要启动Redis服务端

redis-server

redis启动后会有如下信息：

[35142] 01 May 14:36:28.939 # Warning: no config file specified, using the default config. In order to specify a config file use redis-server /path/to/redis.conf
    [35142] 01 May 14:36:28.940 * Max number of open files set to 10032
                    _._
                  _.-``__ ''-._
            _.-``    `.  `_.  ''-._           Redis 2.6.12 (00000000/0) 64 bit
        .-`` .-```.  ```\/    _.,_ ''-._
      (    '      ,       .-`  | `,    )     Running in stand alone mode
      |`-._`-...-` __...-.``-._|'` _.-'|     Port: 6379
      |    `-._   `._    /     _.-'    |     PID: 35142
        `-._    `-._  `-./  _.-'    _.-'
      |`-._`-._    `-.__.-'    _.-'_.-'|
      |    `-._`-._        _.-'_.-'    |           https://redis.io
        `-._    `-._`-.__.-'_.-'    _.-'
      |`-._`-._    `-.__.-'    _.-'_.-'|
      |    `-._`-._        _.-'_.-'    |
        `-._    `-._`-.__.-'_.-'    _.-'
            `-._    `-.__.-'    _.-'
                `-._        _.-'
                    `-.__.-'
    
    [35142] 01 May 14:36:28.941 # Server started, Redis version 2.6.12
    [35142] 01 May 14:36:28.941 * The server is now ready to accept connections on port 6379

Maven配置如下：

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.4.1</version>
            <relativePath/> 
        </parent>
        <groupId>cn.it1995</groupId>
        <artifactId>demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>demo</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                    <configuration>
                        <excludes>
                            <exclude>
                                <groupId>org.projectlombok</groupId>
                                <artifactId>lombok</artifactId>
                            </exclude>
                        </excludes>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

创建Redis消息接受者

发布者发送消息，然后接受者接收消息，下面是创建一个接受者，带有接收消息的方法，代码如下：

package cn.it1995.demo;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class Receiver {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(Receiver.class);
    
        private AtomicInteger counter = new AtomicInteger();
    
        public void receiveMessage(String message){
    
            LOGGER.info("Received <" + message + ">");
            counter.incrementAndGet();
        }
    
        public int getCount(){
    
            return counter.get();
        }
    }

Receiver为POJO类定义了接收数据的方法。这里是要注册消息监听器监听Receiver的receiveMessage方法。

注册监听者及消息发布者

Spring Data Redis提供了send和receive的Redis等组件，要想使用这些功能需要下面3个配置：

1. A connection factory

2. A message listener container

3. A redis template

使用Redis template发送消息，将Receiver注册到监听容器里面，用于监听消息。connection factory包含了template和message listener连接redis服务的链接。

下面的代码使用了Spring Boot的默认的RedisConnectionFactory，这个类其实就是基于JedisConnectionFactory，这个JedisConnectionFactory是基于Jedis Redis库。连接工厂会被注入message listener容器和Redis template。代码如下：

package cn.it1995.demo;
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.ConfigurableApplicationContext;
    import org.springframework.context.annotation.Bean;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.data.redis.listener.PatternTopic;
    import org.springframework.data.redis.listener.RedisMessageListenerContainer;
    import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
    
    @SpringBootApplication
    public class DemoApplication {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(DemoApplication.class);
    
        public static void main(String[] args) throws InterruptedException {
    
            ConfigurableApplicationContext ctx = SpringApplication.run(DemoApplication.class, args);
            StringRedisTemplate template = ctx.getBean(StringRedisTemplate.class);
            Receiver receiver = ctx.getBean(Receiver.class);
    
            while(receiver.getCount() == 0){
    
                LOGGER.info("Sending message...");
                template.convertAndSend("chat", "Hello From Redis");
                Thread.sleep(500L);
            }
        }
    
        @Bean
        StringRedisTemplate template(RedisConnectionFactory connectionFactory){
    
            return new StringRedisTemplate(connectionFactory);
        }
    
        @Bean
        RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter){
    
            RedisMessageListenerContainer container = new RedisMessageListenerContainer();
            container.setConnectionFactory(connectionFactory);
            container.addMessageListener(listenerAdapter, new PatternTopic("chat"));
            return container;
        }
    
        @Bean
        MessageListenerAdapter listenerAdapter(Receiver receiver){
    
            return new MessageListenerAdapter(receiver, "receiveMessage");
        }
    
        @Bean
        Receiver receiver(){
    
            return new Receiver();
        }
    }

listenrAdpter方法将Receiver类的receiveMessage方法注册到消息监听容器中，将会监听chat通道的数据。

application.properties：

# Redis服务器连接端口
    spring.redis.port=6379
    # Redis服务器地址
    spring.redis.host=127.0.0.1
    # Redis数据库索引（默认为0）
    spring.redis.database=0
    # Redis服务器连接密码（默认为空）
    spring.redis.password=xxxxx
    # 连接池最大连接数（使用负值表示没有限制）
    spring.redis.jedis.pool.max-active=8
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    spring.redis.jedis.pool.max-wait=30000ms
    # 连接池中的最大空闲连接
    spring.redis.jedis.pool.max-idle=8
    # 连接池中的最小空闲连接
    spring.redis.jedis.pool.min-idle=0
    # 连接超时时间（毫秒）
    spring.redis.timeout=5000ms

程序运行截图如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNzg0NDI3NjE_size_16_color_FFFFFF_t_70][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxNzg0NDI3NjE_size_16_color_FFFFFF_t_70]: /images/20221119/cbdced07af7545b4ac1f64a89919a3a0.png