Redis缓存预热 - 技术栈

说明：项目中使用到Redis，正常情况，我们会在用户首次查询数据的同时把该数据按照一定命名规则，存储到Redis中，称为冷启动（如下图），这种方式在一些情况下可能会给数据库带来较大的压力。

因此，我们可以使用另一种方式，在项目启动的时候就提前把一些热点数据提前查询并保存到Redis中，称为缓存预热。

（冷启动）

环境准备

例如，现在我数据库中有以下用户的信息，我想在项目启动的时候就把这些数据存入到数据库中；

以下操作在CentOS系统中完成；

代码实现

第一步：安装OpenResty

OpenResty是基于Nginx的高性能Web平台，可方便地搭建能够超过并发、扩展性极高的动态Web应用、Web服务和动态网关。OpenResty具备以下特点：

Nginx的完整功能；
基于Lua语言，集成了大量精良的Lua库、第三方模块；
允许使用Lua自定义业务逻辑、自定义库；

可参考安装OpenResty，这不是本文的重点；

第二步：配置环境变量

安装完OpenResty之后，先配置一下Nginx的环境变量；

txt 复制代码

vi /etc/profile

在文件最下面，加入下面两行配置

txt 复制代码

export NGINX_HOME=/usr/local/openresty/nginx
export PATH=${NGINX_HOME}/sbin:$PATH

保存退出，在敲下面的命令，使配置生效

txt 复制代码

source /etc/profile

第三步：修改配置

OpenResty会默认安装在/usr/local/openresty路径下，可在该目录在看到一个Nginx目录，也就是说OpenResty拥有Nginx的功能。进入到Nginx目录，找到配置文件，进行自适应修改：

如下修改：

txt 复制代码

#user  nobody;
worker_processes  1;
error_log  logs/error.log;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    sendfile        on;
    keepalive_timeout  65;

    server {
        listen       8081;
        server_name  localhost;
        location / {
            root   html;
            index  index.html index.htm;
        }
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    # 设置捕捉的请求路径
	location  /user {
    	# 默认的响应类型
        default_type application/json;
   	    # 响应结果由lua/user.lua文件来决定，待会儿我们来编写这个文件
   	    content_by_lua_file lua/user.lua;
	}
    }
   #lua 模块
   lua_package_path "/usr/local/openresty/lualib/?.lua;;";
   #c模块     
   lua_package_cpath "/usr/local/openresty/lualib/?.so;;";  
   # 共享字典，就是本地缓存，名称为user_cache，大小150m
   lua_shared_dict user_cache 150m; 
}

第四步：启动测试

OpenResty启动、停止、重新加载配置的命令与Nginx基本一样，敲nginx启动OpenResty；

powershell 复制代码

# 启动服务
nginx

# 停止服务
ngxin -s stop

# 重新加载配置
ngxin -s stop

敲IP地址加端口号，看到以下内容，即为安装成功

第五步：启动MySQL、Redis服务

接下来，使用Docker启动mysql、redis服务，注意使用云服务器需要开放相关端口，使用虚拟机需要关闭防火墙；

在启动mysql之前，先在/tmp目录下创建一个mysql文件夹，用于挂载容器的数据和配置文件目录；

powershell 复制代码

# 进入/tmp目录
cd /tmp

# 创建文件夹
mkdir mysql

# 进入mysql目录
cd mysql

启动mysql服务，账号密码设置为：root、123456（注意以下命令需要在mysql目录下执行）

powershell 复制代码

docker run \
 -p 3306:3306 \
 --name mysql \
 -v $PWD/conf:/etc/mysql/conf.d \
 -v $PWD/logs:/logs \
 -v $PWD/data:/var/lib/mysql \
 -e MYSQL_ROOT_PASSWORD=123456 \
 --privileged \
 -d \
 mysql:5.7.25

敲下面的命令，使用docker启动redis服务；

powershell 复制代码

docker run --name redis -p 6379:6379 -d redis redis-server --appendonly yes

第六步：编写代码

服务启动后，来进行代码的编写，以下是一个简单的SpringBoot项目，DAO层使用的是Mybatis-plus，只有两个接口，一个查询所有用户信息，一个根据用户ID查询用户信息。

controller层代码

java 复制代码

import java.util.List;

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查询所有用户信息
     * @return
     */
    @GetMapping("list")
    public List<User> getUsers() {
        return userService.list();
    }

    /**
     * 根据ID查询用户信息
     * @param id
     * @return
     */
    @GetMapping("{id}")
    public User getUserById(@PathVariable Long id) {
        return userService.getById(id);
    }
}

pom.xml文件

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>org.hzy</groupId>
    <artifactId>caffeine_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/>
    </parent>

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

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!--druid数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.2.8</version>
        </dependency>

        <!--测试类-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--hutool工具包依赖-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.6</version>
        </dependency>
    </dependencies>

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

配置文件，注意IP地址和端口号，如果使用的是云服务器，注意MySQL连接时需要加上useSSL=false；

yaml 复制代码

server:
  port: 8081
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://IP地址:3306/db_user?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: 123456
  mvc:
    pathmatch:
      matching-strategy: ant_path_matcher
  redis:
    host: IP地址
mybatis-plus:
  type-aliases-package: com.hzy.pojo
  config-locations: classpath/mapper/*.xml

第七步：启动测试

这些环境搭建完成后，应该启动一下项目，看是否能正常跑起来；

（启动正常）

（测试接口，也没问题）

第八步：缓存预热实现

创建一个RedisHandler类，该类的作用是，在项目启动时访问数据库，查询所有用户信息并存入到数据库中；

java 复制代码

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.hzy.pojo.User;
import com.hzy.service.UserService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class RedisHandler implements InitializingBean {

    @Autowired
    private StringRedisTemplate redisTemplate;

    @Autowired
    private UserService userService;

    private static final ObjectMapper MAPPER = new ObjectMapper();

    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化缓存
        // 1.查询所有用户信息
        List<User> userList = userService.list();

        // 2.放入缓存
        for (User user : userList) {

            // 2.1.将user对象序列化为JSON
            String json = MAPPER.writeValueAsString(user);

            // 2.2.设置key前缀，存入redis
            redisTemplate.opsForValue().set("user:id:" + user.getId(), json);
        }
    }
}

第九步：编写lua文件

接下来，需要编写两个lua文件，一个是通用操作（common.lua），一个是redis的查询操作（user.lua），内容分别如下：

common.lua文件在 /usr/local/openresty/lualib/common.lua 里面，使用以下命令编辑，如下：

powershell 复制代码

vi /usr/local/openresty/lualib/common.lua

内容如下，不需要修改可以直接复制使用：

lua 复制代码

-- 导入redis
local redis = require('resty.redis')
-- 初始化redis
local red = redis:new()
red:set_timeouts(1000, 1000, 1000)

-- 关闭redis连接的工具方法，其实是放入连接池
local function close_redis(red)
    local pool_max_idle_time = 10000 -- 连接的空闲时间，单位是毫秒
    local pool_size = 100 --连接池大小
    local ok, err = red:set_keepalive(pool_max_idle_time, pool_size)
    if not ok then
        ngx.log(ngx.ERR, "放入redis连接池失败: ", err)
    end
end

-- 查询redis的方法 ip和port是redis地址，key是查询的key
local function read_redis(ip, port, key)
    -- 获取一个连接
    local ok, err = red:connect(ip, port)
    if not ok then
        ngx.log(ngx.ERR, "连接redis失败 : ", err)
        return nil
    end
    -- 查询redis
    local resp, err = red:get(key)
    -- 查询失败处理
    if not resp then
        ngx.log(ngx.ERR, "查询Redis失败: ", err, ", key = " , key)
    end
    --得到的数据为空处理
    if resp == ngx.null then
        resp = nil
        ngx.log(ngx.ERR, "查询Redis数据为空, key = ", key)
    end
    close_redis(red)
    return resp
end

-- 封装函数，发送http请求，并解析响应
local function read_http(path, params)
    local resp = ngx.location.capture(path,{
        method = ngx.HTTP_GET,
        args = params,
    })
    if not resp then
        -- 记录错误信息，返回404
        ngx.log(ngx.ERR, "http查询失败, path: ", path , ", args: ", args)
        ngx.exit(404)
    end
    return resp.body
end
-- 将方法导出
local _M = {  
    read_http = read_http,
    read_redis = read_redis
}  
return _M

user.lua文件是自定义的，我们在openresty目录下创建一个lua文件夹，用于存放该文件夹

powershell 复制代码

cd /usr/local/openresty

mkdir lua

user.lua文件内容如下，需要自适应修改：

lua 复制代码

-- 导入common函数库
local common = require('common')
local read_http = common.read_http
local read_redis = common.read_redis
-- 导入cjson库
local cjson = require('cjson')
-- 导入共享词典，本地缓存
local user_cache = ngx.shared.user_cache

-- 封装查询函数
function read_data(key, expire, path, params)
    -- 查询本地缓存
    local val = user_cache:get(key)
    if not val then
        ngx.log(ngx.ERR, "本地缓存查询失败，尝试查询Redis， key: ", key)
        -- 查询redis
        val = read_redis("127.0.0.1", 6379, key)
        -- 判断查询结果
        if not val then
            ngx.log(ngx.ERR, "redis查询失败，尝试查询http， key: ", key)
            -- redis查询失败，去查询http
            val = read_http(path, params)
        end
    end
    -- 查询成功，把数据写入本地缓存
    user_cache:set(key, val, expire)
    -- 返回数据
    return val
end

-- 获取路径参数
local id = ngx.var[1]

-- 查询商品信息
local userJSON = read_data("user:id:" .. id, 1800,  "/user/" .. id, nil)

-- JSON转化为lua的table
local user = cjson.decode(userJSON)

-- 把user序列化为json 返回结果
ngx.say(cjson.encode(user))

第十步：重启项目

此时在云服务器上进入redis容器，打开redis客户端，查看数据内容；

powershell 复制代码

# 进入redis容器
docker exec -it redis bash

powershell 复制代码

# 打开redis客户端
redis-cli

powershell 复制代码

# 查看redis所有的键值
keys *

什么都没有，nothing；

此时，我们重启项目；

再敲命令，查看redis所有值，可以看到所有的数据都已经存入了，可根据key查询到每一条用户的信息；

到此，Redis缓存预热已完成；

总结

Redis缓存预热的执行是与项目启动一起的，不需要用户发送请求，是在项目启动时自发的操作。