Spring Boot：使用Redis儲存技術

朝雨憶輕塵發表於2019-07-01

綜合概述

Redis是一個開源免費的高效能key-value資料庫，讀取速度達110000次/s,寫入速度達81000次/s。Redis支援豐富的資料型別，如Lists, Hashes, Sets 及 Ordered Sets 資料型別。Redis的所有操作都是原子性的，要麼成功執行要麼失敗完全不執行。另外還可以通過MULTI和EXEC指令包起來支援事務。此外，Redis還具備豐富的特性，比如支援釋出/訂閱（publish/subscribe）模式,可以充當簡單的訊息中介軟體，還支援通知, key過期設定主從複製等等特性。

Redis主要以下三個特點：

1.支援資料的持久化，可以將記憶體中的資料儲存在磁碟中，重啟的時候可以再次載入進行使用。

2.支援豐富的資料型別，除了支援簡單的key-value型別，同時還提供list，set，zset，hash等資料結構的儲存。

3.支援資料的備份，即主從（master-slave）模式模式的資料備份。

接下來，我們就用一個簡單的案例來說明在Spring Boot中如何使用Redis技術。

實現案例

首先，需要安裝Redis，教程很多，這裡不再贅述。可以參考：Redis安裝教程。

生成專案模板

為方便我們初始化專案，Spring Boot給我們提供一個專案模板生成網站。

1. 開啟瀏覽器，訪問：https://start.spring.io/

2. 根據頁面提示，選擇構建工具，開發語言，專案資訊等。

3. 點選 Generate the project，生成專案模板，生成之後會將壓縮包下載到本地。

4. 使用IDE匯入專案，我這裡使用Eclipse，通過匯入Maven專案的方式匯入。

新增相關依賴

清理掉不需要的測試類及測試依賴，新增 Redis相關依賴。

<!-- spring boot redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- lettuce pool -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

Spring Boot框架中已經整合了redis，在1.x.x的版本中預設使用jedis客戶端，而在2.x.x版本中預設使用的lettuce客戶端。

兩種客戶端的區別如下：

Jedis和Lettuce都是Redis Client
Jedis 是直連模式，在多個執行緒間共享一個 Jedis 例項時是執行緒不安全的，
如果想要在多執行緒環境下使用 Jedis，需要使用連線池，
每個執行緒都去拿自己的 Jedis 例項，當連線數量增多時，物理連線成本就較高了。
Lettuce的連線是基於Netty的，連線例項可以在多個執行緒間共享，
所以，一個多執行緒的應用可以使用同一個連線例項，而不用擔心併發執行緒的數量。
當然這個也是可伸縮的設計，一個連線例項不夠的情況也可以按需增加連線例項。
通過非同步的方式可以讓我們更好的利用系統資源，而不用浪費執行緒等待網路或磁碟I/O。
Lettuce 是基於 netty 的，netty 是一個多執行緒、事件驅動的 I/O 框架，
所以 Lettuce 可以幫助我們充分利用非同步的優勢。

我的專案是使用的是Spring Boot 2.1.5.RELEASE，所以採用lettuce來進行配置。

pom.xml

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.louis.springboot</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</artifactId>
        </dependency>
        <!-- web -->
        <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- spring boot redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- lettuce pool -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

新增相關配置

1.新增swagger 配置

新增一個swagger 配置類，在工程下新建 config 包並新增一個 SwaggerConfig 配置類。

SwaggerConfig.java

package com.louis.springboot.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("Swagger API Doc")
                .description("This is a restful api document of Swagger.")
                .version("1.0")
                .build();
    }

}

2.修改application.properties檔名為application.yml，在其中新增Redis配置資訊。

application.yml

spring:
  redis:
    database: 0  # Redis資料庫索引（預設為0）
    host: localhost # Redis伺服器地址
    port: 6379  # Redis伺服器連線埠
    password:   # Redis伺服器連線密碼（預設為空）
    lettuce:
      pool:
       max-active: 8  # 連線池最大連線數（使用負值表示沒有限制） 預設 8
       max-wait: -1   # 連線池最大阻塞等待時間（使用負值表示沒有限制） 預設 -1
       max-idle: 8    # 連線池中的最大空閒連線 預設 8
       min-idle: 0    # 連線池中的最小空閒連線 預設 0

3.新增一個Redis配置類，使用@EnableCaching註解來開啟快取。

RedisConfig.java

package com.louis.springboot.demo.config;

import java.lang.reflect.Method;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
    
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

編寫業務邏輯

編寫一個簡單的使用者實體類，包含使用者名稱和密碼。

User.java

package com.louis.springboot.demo.model;

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    
    private String username;
    private String password;
    
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    @Override
    public String toString() {
        return "{username:" + getUsername() + ", password:" +getPassword() + "}";
    }
}

編寫一個業務控制器，分別編寫測試字串和物件的存取介面。

RedisController.java

package com.louis.springboot.demo.controller;

import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
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.RestController;
import com.louis.springboot.demo.model.User;

@RestController
public class RedisController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/testString")
    public String testString()  {
        stringRedisTemplate.opsForValue().set("name", "louis");
        String name = stringRedisTemplate.opsForValue().get("name");
        return "the value of key 'name' is : " + name ;
    }
    
    @GetMapping("/testObject")
    public String testObject()  {
        StringBuilder result = new StringBuilder();
        User user = new User("louis", "123");
        ValueOperations<String, User> operations = redisTemplate.opsForValue();
        operations.set("sys.user", user);
        operations.set("sys.user.timeout", user, 1, TimeUnit.SECONDS);    // 設定1秒後過期
        result.append("過期前：");
        result.append("sys.user=" + operations.get("sys.user"));
        result.append("sys.user.timeout=" + operations.get("sys.user.timeout"));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        result.append("過期後：");
        result.append("sys.user=" + operations.get("sys.user"));
        result.append("sys.user.timeout=" + operations.get("sys.user.timeout"));
        return result.toString();
    }
    
}