【redis缓存】redis缓存预热

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

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

（冷启动）

环境准备

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

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

第一步：启动Redis服务

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

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

docker安装redis详细见文章《【docker】全网最详细Docker安装Redis》

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

docker run --name mysql-container -e MYSQL_ROOT_PASSWORD=your_new_password -p 3306:3306 -d mysql:5.7

第二步：编写代码

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

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

    <groupId>com.hanson.datapreheat</groupId>
    <artifactId>data_preheating</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</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>

controller层代码

import com.hanson.datapreheat.entity.User;
import com.hanson.datapreheat.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @author hanson
 * @date 2024/7/11 0:33
 */
@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);
    }
}

entity层代码

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * @author hanson
 * @date 2024/7/11 0:35
 */
@Data
@TableName("db_user")
public class User {

    @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    @TableField("username")
    private String username;

    @TableField("password")
    private String password;

    @TableField("name")
    private String name;

    @TableField("gender")
    private String gender;

    @TableField("image")
    private String image;

    @TableField("job")
    private String job;

    @TableField("entrydate")
    private String entrydate;

    @TableField("dept_id")
    private Integer deptId;

    @TableField("create_time")
    private String createTime;

    @TableField("update_time")
    private String updateTime;

    @TableField("is_del")
//    @TableLogic
    private String isDel;
}

mapper层

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.hanson.datapreheat.entity.User;
import org.apache.ibatis.annotations.Mapper;

/**
 * @author hanson
 * @date 2024/7/11 0:43
 */
@Mapper
public interface UserMapper extends BaseMapper<User> {
}

service层

import com.baomidou.mybatisplus.extension.service.IService;
import com.hanson.datapreheat.entity.User;

/**
 * @author hanson
 * @date 2024/7/11 0:34
 */
public interface UserService extends IService<User> {
}

impl

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hanson.datapreheat.entity.User;
import com.hanson.datapreheat.mapper.UserMapper;
import com.hanson.datapreheat.service.UserService;
import org.springframework.stereotype.Service;

/**
 * @author hanson
 * @date 2024/7/11 0:44
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

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

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.hanson.datapreheat.entity
  config-locations: classpath/mapper/*.xml

第三步：启动测试

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

（启动正常）

（测试接口，也没问题）

第四步：缓存预热实现

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

import com.fasterxml.jackson.databind.ObjectMapper;
import com.hanson.datapreheat.entity.User;
import com.hanson.datapreheat.service.UserService;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * @author hanson
 * @date 2024/7/11 0:59
 */
@Component
public class RedisHandler implements InitializingBean {

    @Resource
    private StringRedisTemplate redisTemplate;

    @Resource
    private UserService userService;

    private static final ObjectMapper objectMapper = 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 = objectMapper.writeValueAsString(user);

            // 2.2 设置key前缀，并将过期时间设置为24小时
            redisTemplate.opsForValue().set("user:" + user.getId(), json, 1, TimeUnit.DAYS);
        }

    }
}

第五步：重启项目

查看redis，什么数据都没有

此时，我们重启项目；

重启项目，查看redis数据

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

总结

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

项目github地址