Springboot21 整合redis、利用redis实现消息队列

1 前提准备

1.1 创建一个springboot项目

　　　　技巧01：本博文基于springboot2.0创建

1.2 安装redis

1.2.1 linux版本

　　　　　　参考博文

1.2.2 windows版本

　　　　　　到redis官网下载windows版本的压缩包后，解压即可

1.3 redis使用

　　　　本博文以window版本为例子，linux版本请参见

1.3.1 开启服务端

　　　　　　》进入到解压后的redis根目录

Springboot21 整合redis、利用redis实现消息队列

　　　　　　　　》执行 redis-server.exe

Springboot21 整合redis、利用redis实现消息队列

1.3.2 开启客户端

　　　　　　进入到redis解压目录 -> 执行 redis-cli.exe

Springboot21 整合redis、利用redis实现消息队列

1.3.3 测试redis服务端和客户端的通信

　　　　　　在redis客户端执行 ping，如果返回了 PONG 就表明redis前后端通信正常

Springboot21 整合redis、利用redis实现消息队列

1.3.4 关闭

　　　　　　客户端和服务端都用 Ctrl + C 就可以关闭了

2 SpringBoot 集成 Redis

2.1 创建一个SpringBoot项目

　　　　技巧01：创建时引入 spring-boot-starter-web 和 spring-boot-starter-data-redis

Springboot21 整合redis、利用redis实现消息队列

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

    <groupId>cn.xiangxu</groupId>
    <artifactId>redis_pub_sub</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>redis_pub_sub</name>
    <description>Demo project for Spring Boot</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <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-data-redis-reactive</artifactId>-->
        <!--</dependency>-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.0</version>
        </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>
                    <fork>true</fork>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>

pom.xml

2.2 配置redis服务器

　　　　技巧01：springboot的启动包已经给我们配置好了redis相关的配置类，所以我们只需要在配置文件中对redis服务器进行相关的配置即可

Springboot21 整合redis、利用redis实现消息队列

2.3 使用redis服务器

　　　　坑01：外部的redis客户端在连接redis服务器时需要关闭redis服务器的守护进程，否则会出现连接失败；修改redis.conf配置文件即可，windows版本的redis配置文件在根目录下的 redis.windows.conf 中；将配置文件中protected-mode 配置值从 yes 改为 no 即可。

　　　　技巧01：因为springboot已经为我们配置好了一切，所以我们直接调用 RedisTemplate 或者 StringRedisTemplate 的相关API就可以对redis服务器进行相关的操作了

　　　　》依赖注入 RedisTemplate 或者 StringRedisTemplate

　　　　》利用依赖注入的 RedisTemplate 或者 StringRedisTemplate 对象进行操作即可

Springboot21 整合redis、利用redis实现消息队列

package cn.xiangxu.redis_pub_sub.web;

import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import static org.junit.Assert.*;

@RunWith(SpringRunner.class)
@SpringBootTest
@Slf4j
public class TestControllerTest {

    /**
     * 依赖注入RedisTemplate，直接利用RedisTemplate操作redis即可
     */
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Test
    public void test01(){
        log.info("Hello Boy");

        // 设置数据
        redisTemplate.opsForValue().set("age", "33");

        // 获取数据
        String result = redisTemplate.opsForValue().get("name");
        System.out.println(result.toString());
//        System.out.println(redisTemplate.getClientList());;
    }

}

View Code

3 SpringBoot 利用 Redis 实现队列的效果

3.1 流程介绍

　　　　参考博文

3.2 源代码

Springboot21 整合redis、利用redis实现消息队列

package cn.xiangxu.redis_pub_sub.domain;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.concurrent.CountDownLatch;

/**
 * @author 王杨帅
 * @create 2018-07-09 16:13
 * @desc
 **/
@Slf4j
public class Receiver {
    private CountDownLatch latch;
    @Autowired
    public Receiver(CountDownLatch latch) {
        this.latch = latch;
    }

    public void receiveMessage(String message) {
        log.info("Received <" + message + ">");
        latch.countDown();
    }


}

View Code

Springboot21 整合redis、利用redis实现消息队列

package cn.xiangxu.redis_pub_sub;

import cn.xiangxu.redis_pub_sub.domain.Receiver;
import lombok.extern.slf4j.Slf4j;
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.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
@Slf4j
public class RedisPubSubApplication {

    /*
     * Redis消息监听器容器
     * 这个容器加载了RedisConnectionFactory和消息监听器
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                            MessageListenerAdapter listenerAdapter){
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("sprinboot-redis-messaage"));
        return container;
    }

    /*
     * 将Receiver注册为一个消息监听器，并指定消息接收的方法（receiveMessage）
     * 如果不指定消息接收的方法，消息监听器会默认的寻找Receiver中的handleMessage这个方法作为消息接收的方法
     */
    @Bean
    MessageListenerAdapter listenerAdapter(Receiver receiver){
        return new MessageListenerAdapter(receiver, "receiveMessage");
    }

    /*
     * Receiver实例
     */
    @Bean
    Receiver receiver(CountDownLatch latch){
        return new Receiver(latch);
    }

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

    /*
     * Redis Template 用来发送消息
     */
    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory){
        return new StringRedisTemplate(connectionFactory);
    }

    public static void main(String[] args) {
        ApplicationContext ctx = SpringApplication.run(RedisPubSubApplication.class, args);

        StringRedisTemplate template = ctx.getBean(StringRedisTemplate.class);
//      CountDownLatch latch = ctx.getBean(CountDownLatch.class);

        log.info("Sending message......");
        template.convertAndSend("sprinboot-redis-messaage", "Hello, SpringBoot redis message!!!!");
//      latch.wait();

//        System.exit(0);
    }
}

View Code