Spring Boot 整合 Redis 案例教程

🔥🔥 点击领取 ChatGPT Plus 正版账号

一、缓存的应用场景

什么是缓存？
在互联网场景下，尤其 2C 端大流量场景下，需要将一些经常展现和不会频繁变更的数据，存放在存取速率更快的地方。缓存就是一个存储器，在技术选型中，常用 Redis 作为缓存数据库。缓存主要是在获取资源方便性能优化的关键方面。

Redis 是一个高性能的 key-value 数据库。GitHub 地址： https://github.com/antirez/redis 。Github 是这么描述的：

Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of values are supported: Strings, Lists, Sets, Sorted Sets, Hashes, HyperLogLogs, Bitmaps.

缓存的应用场景有哪些呢？

比如常见的电商场景，根据商品 ID 获取商品信息时，店铺信息和商品详情信息就可以缓存在 Redis，直接从 Redis 获取。减少了去数据库查询的次数。但会出现新的问题，就是如何对缓存进行更新？这就是下面要讲的。

二、更新缓存的策略

参考《缓存更新的套路》 http://coolshell.cn/articles/17416.html ，缓存更新的模式有四种：Cache aside, Read through, Write through, Write behind caching。

这里我们使用的是 Cache Aside 策略，从三个维度：（摘自 耗子叔叔博客）

• 失效：应用程序先从cache取数据，没有得到，则从数据库中取数据，成功后，放到缓存中。
• 命中：应用程序从cache中取数据，取到后返回。
• 更新：先把数据存到数据库中，成功后，再让缓存失效。

大致流程如下：

获取商品详情举例
a. 从商品 Cache 中获取商品详情，如果存在，则返回获取 Cache 数据返回。
b. 如果不存在，则从商品 DB 中获取。获取成功后，将数据存到 Cache 中。则下次获取商品详情，就可以从 Cache 就可以得到商品详情数据。
c. 从商品 DB 中更新或者删除商品详情成功后，则从缓存中删除对应商品的详情缓存

三、运行 springboot-mybatis-redis 工程案例

git clone 下载工程 springboot-learning-example ，项目地址见 GitHub https://github.com/JeffLi1993/springboot-learning-example

下面开始运行工程步骤（Quick Start）：

1.数据库和 Redis 准备

a.创建数据库 springbootdb：

CREATE DATABASE springbootdb;

b.创建表 city ：

DROP TABLE IF EXISTS `city`;

CREATE TABLE `city`
(
    `id`          int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '城市编号',
    `province_id` int(10) unsigned NOT NULL COMMENT '省份编号',
    `city_name`   varchar(25) DEFAULT NULL COMMENT '城市名称',
    `description` varchar(25) DEFAULT NULL COMMENT '描述',
    PRIMARY KEY (`id`)

) ENGINE = InnoDB
  AUTO_INCREMENT = 1
  DEFAULT CHARSET = utf8;

c.插入数据

          INSERT city VALUES (1 ,1,
          '温岭市'
          ,
          'BYSocket 的家在温岭。'
          );

d.本地安装 Redis

2. springboot-mybatis-redis 工程项目结构介绍

springboot-mybatis-redis 工程项目结构如下图所示：

          org.spring.springboot.controller - Controller 层
          org.spring.springboot.dao - 数据操作层 DAO
          org.spring.springboot.domain - 实体类
          org.spring.springboot.service - 业务逻辑层
          Application - 应用启动类
          application.properties - 应用配置文件，应用启动会自动读取配置

3.改数据库配置

打开 application.properties 文件， 修改相应的数据源配置，比如数据源地址、账号、密码等。
（如果不是用 MySQL，自行添加连接驱动 pom，然后修改驱动名配置。）

4.编译工程

在项目根目录 springboot-learning-example，运行 maven 指令：

           mvn clean install

5.运行工程

右键运行 springboot-mybatis-redis 工程 Application 应用启动类的 main 函数。

项目运行成功后，这是个 HTTP OVER JSON 服务项目。所以用 postman 工具可以如下操作

根据 ID，获取城市信息
GET http://127.0.0.1:8080/api/city/1

再请求一次，获取城市信息会发现数据获取的耗时快了很多。服务端 Console 输出的日志：

         2017-04-13 18:29:00.273  INFO 13038 --- [nio-8080-
         exec
         -1] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 城市插入缓存 >> City{
         id
         =12, provinceId=3, cityName=
         '三亚'
         , description=
         '水好,天蓝'
         }
        
 
         2017-04-13 18:29:03.145  INFO 13038 --- [nio-8080-
         exec
         -2] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.findCityById() : 从缓存中获取了城市 >> City{
         id
         =12, provinceId=3, cityName=
         '三亚'
         , description=
         '水好,天蓝'
         }

可见，第一次是从数据库 DB 获取数据，并插入缓存，第二次直接从缓存中取。

更新城市信息
PUT http://127.0.0.1:8080/api/city

删除城市信息
DELETE http://127.0.0.1:8080/api/city/2

这两种操作中，如果缓存有对应的数据，则删除缓存。服务端 Console 输出的日志：

         2017-04-13 18:29:52.248  INFO 13038 --- [nio-8080-
         exec
         -9] o.s.s.service.impl.CityServiceImpl       : CityServiceImpl.deleteCity() : 从缓存中删除城市 ID >> 12

四、springboot-mybatis-redis 工程代码配置详解

这里，我强烈推荐 注解 的方式实现对象的缓存。但是这里为了更好说明缓存更新策略。下面讲讲工程代码的实现。
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>

    <groupId>springboot</groupId>
    <artifactId>springboot-mybatis-redis-annotation</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatis-redis-annotation</name>

    <!-- Spring Boot 启动父依赖 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>

    <properties>
        <mybatis-spring-boot>1.2.0</mybatis-spring-boot>
        <mysql-connector>5.1.39</mysql-connector>
        <fastjson-version>1.2.32</fastjson-version>
    </properties>

    <dependencies>

        <!-- Spring Boot Data Cache 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <!-- Spring Boot Data Redis 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!-- Spring Boot Web 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Spring Boot Test 依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!-- Junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
</project>

包括了 Spring Boot Reids 依赖、 MySQL 依赖和 Mybatis 依赖。
在 application.properties 应用配置文件，增加 Redis 相关配置

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

详细解释可以参考注释。对应的配置类：org.springframework.boot.autoconfigure.data.redis.RedisProperties

CityRestController 控制层依旧是 Restful 风格的，详情可以参考《Springboot 实现 Restful 服务，基于 HTTP / JSON 传输》。 http://www.bysocket.com/?p=1627 domain 对象 City 必须实现序列化，因为需要将对象序列化后存储到 Redis。如果没实现 Serializable ，控制台会爆出以下异常：

          Serializable
     
          java.lang.IllegalArgumentException: DefaultSerializer requires a Serializable payload but received an object of  
          type

City.java 城市对象：

package org.spring.springboot.domain;

import java.io.Serializable;

/**
 * 城市实体类
 *
 * Created by bysocket on 07/02/2017.
 */
public class City implements Serializable {

    private static final long serialVersionUID = -1L;

    /**
     * 城市编号
     */
    private Long id;

    /**
     * 省份编号
     */
    private Long provinceId;

    /**
     * 城市名称
     */
    private String cityName;

    /**
     * 描述
     */
    private String description;

    public City(Long id, Long provinceId, String cityName, String description) {
        this.id = id;
        this.provinceId = provinceId;
        this.cityName = cityName;
        this.description = description;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Long getProvinceId() {
        return provinceId;
    }

    public void setProvinceId(Long provinceId) {
        this.provinceId = provinceId;
    }

    public String getCityName() {
        return cityName;
    }

    public void setCityName(String cityName) {
        this.cityName = cityName;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    @Override
    public String toString() {
        return "City{" +
                "id=" + id +
                ", provinceId=" + provinceId +
                ", cityName='" + cityName + '\'' +
                ", description='" + description + '\'' +
                '}';
    }
}

如果需要自定义序列化实现，只要实现 RedisSerializer 接口去实现即可，然后在使用 RedisTemplate.setValueSerializer 方法去设置你实现的序列化实现。
主要还是城市业务逻辑实现类 CityServiceImpl.java：

package org.spring.springboot.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.spring.springboot.domain.City;
import org.spring.springboot.service.CityService;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

/**
 * 城市业务逻辑实现类
 * <p>
 * Created by bysocket on 07/02/2017.
 */
@Service
public class CityServiceImpl implements CityService {


    // 模拟数据库存储
    private Map<String, City> cityMap = new HashMap<String, City>();

    public void saveCity(City city){
        // 模拟数据库插入操作
        cityMap.put(city.getCityName(), city);
    }

    @Cacheable(value = "baseCityInfo")
    public City getCityByName(String cityName){
        // 模拟数据库查询并返回
        return cityMap.get(cityName);
    }

    @CachePut(value = "baseCityInfo")
    public void updateCityDescription(String cityName, String description){
        City city = cityMap.get(cityName);
        city.setDescription(description);
        // 模拟更新数据库
        cityMap.put(cityName, city);
    }

}

首先这里注入了 RedisTemplate 对象。联想到 Spring 的 JdbcTemplate ，RedisTemplate 封装了 RedisConnection，具有连接管理，序列化和 Redis 操作等功能。还有针对 String 的支持对象 StringRedisTemplate。
Redis 操作视图接口类用的是 ValueOperations，对应的是 Redis String/Value 操作。还有其他的操作视图，ListOperations、SetOperations、ZSetOperations 和 HashOperations 。ValueOperations 插入缓存是可以设置失效时间，这里设置的失效时间是 10 s。
回到更新缓存的逻辑

a. findCityById 获取城市逻辑：
如果缓存存在，从缓存中获取城市信息
如果缓存不存在，从 DB 中获取城市信息，然后插入缓存

b. deleteCity 删除 / updateCity 更新城市逻辑：
如果缓存存在，删除
如果缓存不存在，不操作

其他不明白的，可以 git clone 下载工程 springboot-learning-example ，工程代码注解很详细。 https://github.com/JeffLi1993/springboot-learning-example 。

五、小结

本文涉及到 Spring Boot 在使用 Redis 缓存时，一个是缓存对象需要序列化，二个是缓存更新策略是如何的。

🔥🔥 点击领取 ChatGPT Plus 正版账号