[SpingBoot guides系列翻译]Redis的消息订阅发布

Redis的消息

部分参考链接

原文

CountDownLatch

概述

目的

这节讲的是用Redis来实现消息的发布和订阅，这里会使用Spring Data Redis来完成。

这里会用到两个东西，StringRedisTemplate和MessageListenerAdapter。分别用来发布String类型的消息和订阅接收这些消息。

你需要的准备的

大概15min(实际用下来应该不够)
喜欢的ide或者文本编辑器(我使用intellij)
Jdk1.8+
Gradle4+ 或者 Maven3.2+(这里用Maven)

如何通过Maven来完成

新建maven项目

创建pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<!--

  ~ Copyright (c) 2019.

  ~ lou

  -->

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <groupId>org.springframework</groupId>

    <artifactId>gs-messaging-redis</artifactId>

    <version>1.0-SNAPSHOT</version>

    <parent>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter-parent</artifactId>

        <version>2.1.4.RELEASE</version>

    </parent>

    <properties>

        <java.version>1.8</java.version>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter</artifactId>

            <version>2.1.4.RELEASE</version>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-data-redis</artifactId>

            <version>1.5.2.RELEASE</version>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>

</project>

Spring Boot Maven Plugin 有以下几个作用

把项目打包成一个可执行的jar文件。
搜索并标记public static void main()为可执行类。
使用内置的依赖管理

需要一个Redis Server

这里还需要一个Redis Server，搭设过程就不演示了，假设已经搭好，server: localhost:6379, password:xxxxxx。

创建一个Redis 消息接收类

src/main/java/hello/Receiver.java

/*

 * Copyright (c) 2019.

 * lou

 */

package hello;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import java.util.concurrent.CountDownLatch;

public class Receiver {

    private static final Logger logger = LoggerFactory.getLogger(Receiver.class);

    private CountDownLatch latch;

    @Autowired

    public Receiver(CountDownLatch latch) {

        this.latch = latch;

    }

    public void receiveMessage(String message){

        logger.info("接收到消息"+message);

        latch.countDown();

    }

}

CountDownLatch用来阻塞当前进程，调用countDown方法一次减少1，到0释放。。CountDownLatch 无法重置，如有需要，使用CyclicBarrier。

创建一个Redis配置类

Redis的配置应该是放在配置文件中的，所以需要创建一个redis配置类，来读取resource/application.properties中的配置并赋值给相应的connectionFactory。

先添加一下application.properties

spring.redis.password=xxxxx

spring.redis.port=6379

spring.redis.host=localhost

然后创建一个hello/RedisStandaloneConfigurationPropertySource.java

/*

 * Copyright (c) 2019.

 * lou

 */

package hello;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.PropertySource;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.RedisStandaloneConfiguration;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

//配置RedisConnectionFactory

@Configuration

@PropertySource(value = "application.properties",encoding = "utf-8")

public class RedisStandaloneConfigurationPropertySource {

    private Logger logger = LoggerFactory.getLogger(RedisStandaloneConfigurationPropertySource.class);

    @Value("${spring.redis.host}")

    private String hostName;

    @Value("${spring.redis.port}")

    private int port;

    @Value("${spring.redis.password}")

    private String password;

    @Override

    public String toString() {

        return "RedisStandaloneConfigurationPropertySource{" +

                "hostName='" + hostName + '\'' +

                ", port=" + port +

                ", password='" + password + '\'' +

                '}';

    }

    @Bean

    RedisConnectionFactory getRedisConnectionFactory() {

      	//日志记录一下

        logger.info("redis的配置为："+this.toString());

        JedisConnectionFactory factory = new JedisConnectionFactory();

        RedisStandaloneConfiguration configuration = factory.getStandaloneConfiguration();

        configuration.setHostName(hostName);

        configuration.setPort(port);

        configuration.setPassword(password);

        return factory;

    }

}

这个类的功能就是读取配置文件，并且定义一个RedisConnectionFactory的Bean，后面会用到。

注册这个消息接收类并发送消息

Spring Data Redis提供了发送和接收消息的所有组件。重点需要配置以下几个东西

一个Connection Factory(连接管理工厂)
一个 Message Listener Container(消息接收容器)
一个Redis Template

使用Redis Template来发送消息，然后把Receiver注册到Message Listener Container中。Connection Factory驱动Template和Container，让他们可以连接到redis server。

例子中使用Spring boot的RedisConnectionFactory，它是基于Jedis的JedisConnectionFactory的实例。Connection Factory会同时注入到container和template中。

src/main/java/hello/Application.java

/*

 * Copyright (c) 2019.

 * lou

 */

package hello;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.Bean;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

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;

import java.util.concurrent.CountDownLatch;

@SpringBootApplication

public class Application {

    private static final Logger logger = LoggerFactory.getLogger(Application.class);

    //Container 由RedisConnectionFactory 和MessageListenerAdapter实例化

    @Bean

    RedisMessageListenerContainer container(@Qualifier("getRedisConnectionFactory") RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {

        RedisMessageListenerContainer container = new RedisMessageListenerContainer();

        container.setConnectionFactory(connectionFactory);

        container.addMessageListener(listenerAdapter, new PatternTopic("chat"));

        return container;

    }

    @Bean

    MessageListenerAdapter listenerAdapter(Receiver receiver) {

        //通过Receiver实例化Adapter，设置默认listen方法，receiveMessage

        return new MessageListenerAdapter(receiver, "receiveMessage");

    }

    @Bean

    Receiver receiver(CountDownLatch latch) {

        return new Receiver(latch);

    }

    @Bean

    CountDownLatch latch() {

        return new CountDownLatch(100);//设置上限100

    }

    //StringRedisTemplate由RedisConnectionFactory实例化

    @Bean

    StringRedisTemplate template(@Qualifier("getRedisConnectionFactory") RedisConnectionFactory connectionFactory) {

        return new StringRedisTemplate(connectionFactory);

    }

    public static void main(String[] args) throws InterruptedException {

        ApplicationContext ctx = SpringApplication.run(Application.class, args);

        CountDownLatch latch = ctx.getBean(CountDownLatch.class);

        latch.await();

        System.exit(0);

    }

}

这样Application就完成了。

RedisMessageListenerContainer由container方法返回。
MessageListenerAdapter 由listenAdapter方法返回，构造函数里面第二个参数表示调用的方法receiveMessage，这个在receiver类中已经定义。
StringRedisTemplate 由template方法返回，这个类关注于操作key和value都是String类型的数据。

创建一个webapi来测试这个功能

src/main/java/hello/controller/TestController.java

/*

 * Copyright (c) 2019.

 * lou

 */

package hello.controller;

import org.springframework.data.redis.core.StringRedisTemplate;

import org.springframework.data.redis.core.ValueOperations;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import java.util.Random;

@RestController

public class TestController {

    Random random = new Random();

    StringRedisTemplate template;

    public TestController(StringRedisTemplate template) {

        this.template = template;

    }

    @GetMapping("test")

    public int TestMethod(@RequestParam(name = "t", defaultValue = "hello") String t) {

        ValueOperations operations = template.opsForValue();

        //测试读写redis

      	operations.set("t", t);

      	//发送消息

        template.convertAndSend("chat", "消息" + t);

        return random.nextInt(100);

    }

}

test方法里面调用convertAndSend方法，发送消息，启动后访问http://localhost:8080/test?t=2432，可以看到日志上有返回内容。

构建可执行jar

打包 mvn package。

运行 java -jar ./target/xxx.jar。看到可以运行起来。

小结

这个demo教了我们如何通过配置文件配置redis连接，然后实现发布和订阅。