使用Spring Cache和Redis实现查询数据缓存

@RestController("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;
    
    @Cacheable(value = "user", key = "#id")
    public User getUser(Long id) {
        // 获取用户的逻辑
        return userService.findById(id);
    }
}

@RestController("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;
    
    @CachePut(value = "user", key = "#user.id")
    public User updateUser(User user) {
        // 更新用户的逻辑
        return userService.save(user);
    }
}

@RestController("/users")
@RequiredArgsConstructor
public class UserController {

    private final UserService userService;
    
    @CacheEvict(value = "user", key = "#id")
    public void deleteUser(Long id) {
        // 删除用户的逻辑
        userService.deleteById(id);
    }
}

@Data
@AllArgsConstructor
public class Product implements Serializable {

    private Long id;

    private String name;

    private Integer category;

    private String description;

    private Integer stock;

}

@Getter
public enum ResultEnum {

    /* 成功状态码 */
    SUCCESS(1, "操作成功！"),

    /* 错误状态码 */
    FAIL(0, "操作失败！"),

    /* 参数错误：10001-19999 */
    PARAM_IS_INVALID(10001, "参数无效"),
    PARAM_IS_BLANK(10002, "参数为空"),
    PARAM_TYPE_BIND_ERROR(10003, "参数格式错误"),
    PARAM_NOT_COMPLETE(10004, "参数缺失"),

    /* 用户错误：20001-29999*/
    USER_NOT_LOGGED_IN(20001, "用户未登录，请先登录"),
    USER_LOGIN_ERROR(20002, "账号不存在或密码错误"),
    USER_ACCOUNT_FORBIDDEN(20003, "账号已被禁用"),
    USER_NOT_EXIST(20004, "用户不存在"),
    USER_HAS_EXISTED(20005, "用户已存在"),

    /* 系统错误：40001-49999 */
    FILE_MAX_SIZE_OVERFLOW(40003, "上传尺寸过大"),
    FILE_ACCEPT_NOT_SUPPORT(40004, "上传文件格式不支持"),

    /* 数据错误：50001-599999 */
    RESULT_DATA_NONE(50001, "数据未找到"),
    DATA_IS_WRONG(50002, "数据有误"),
    DATA_ALREADY_EXISTED(50003, "数据已存在"),
    AUTH_CODE_ERROR(50004, "验证码错误"),


    /* 权限错误：70001-79999 */
    PERMISSION_UNAUTHENTICATED(70001, "此操作需要登陆系统！"),

    PERMISSION_UNAUTHORIZED(70002, "权限不足，无权操作！"),

    PERMISSION_EXPIRE(70003, "登录状态过期！"),

    PERMISSION_TOKEN_EXPIRED(70004, "token已过期"),

    PERMISSION_LIMIT(70005, "访问次数受限制"),

    PERMISSION_TOKEN_INVALID(70006, "无效token"),

    PERMISSION_SIGNATURE_ERROR(70007, "签名失败");

    // 状态码
    int code;
    // 提示信息
    String message;

    ResultEnum(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int code() {
        return code;
    }

    public String message() {
        return message;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

@Data
@NoArgsConstructor
public class Result<T> implements Serializable {

    // 操作代码
    Integer code;

    // 提示信息
    String message;

    // 结果数据
    T data;

    public Result(ResultEnum resultCode) {
        this.code = resultCode.code();
        this.message = resultCode.message();
    }

    public Result(ResultEnum resultCode, T data) {
        this.code = resultCode.code();
        this.message = resultCode.message();
        this.data = data;
    }
    public Result(String message) {
        this.message = message;
    }
    //成功返回封装-无数据
    public static Result<String> success() {
        return new Result<String>(ResultEnum.SUCCESS);
    }
    //成功返回封装-带数据
    public static <T> Result<T> success(T data) {
        return new Result<T>(ResultEnum.SUCCESS, data);
    }
    //失败返回封装-使用默认提示信息
    public static Result<String> error() {
        return new Result<String>(ResultEnum.FAIL);
    }
    //失败返回封装-使用返回结果枚举提示信息
    public static Result<String> error(ResultEnum resultCode) {
        return new Result<String>(resultCode);
    }
    //失败返回封装-使用自定义提示信息
    public static Result<String> error(String message) {
        return new Result<String>(message);

    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring:
  data:
    redis:
      # Redis服务器地址
      host: ${shijun.redis.host}
      # Redis服务器端口
      port: ${shijun.redis.port}
      # Redis服务器认证密码
      password: ${shijun.redis.password}
      # Redis数据库索引
      database: ${shijun.redis.database}

/**
 * 配置类，用于设置缓存管理器及相关配置，以启用缓存功能
 *
 * @author shijun
 * @date 2024/06/13
 */
@EnableCaching
@Configuration
public class CacheConfig extends CachingConfigurerSupport {

    /**
     * 配置Redis键的序列化方式
     *
     * @return StringRedisSerializer，用于序列化和反序列化Redis中的键
     */
    private RedisSerializer<String> keySerializer() {
        return new StringRedisSerializer();
    }

    /**
     * 配置Redis值的序列化方式
     *
     * @return GenericJackson2JsonRedisSerializer，使用Jackson库以JSON格式序列化和反序列化Redis中的值
     */
    private RedisSerializer<Object> valueSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }

    /**
     * 缓存前缀，用于区分不同的缓存命名空间，一般以模块名或者服务名命名，这里暂时写cache
     */
    public static final String CACHE_PREFIX = "cache:";

    /**
     * 配置缓存管理器，使用Redis作为缓存后端
     *
     * @param redisConnectionFactory Redis连接工厂，用于创建Redis连接
     * @return RedisCacheManager，Redis缓存管理器实例
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 配置序列化，解决乱码的问题，设置缓存名称的前缀和缓存条目的默认过期时间
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                // 设置键的序列化器
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                // 设置值的序列化器
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
                // 设置缓存名称的前缀
                .computePrefixWith(name -> CACHE_PREFIX + name + ":")
                // 设置缓存条目的默认过期时间为300秒
                .entryTtl(Duration.ofSeconds(300));

        // 创建非锁定的Redis缓存写入器
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(Objects.requireNonNull(redisConnectionFactory));

        // 返回Redis缓存管理器实例，使用上述配置
        return new RedisCacheManager(redisCacheWriter, config);
    }

}

@Slf4j
@RestController("/products")
public class ProductController {


    /**
     * 根据ID获取产品信息
     * 通过@Cacheable注解，当请求的产品ID在缓存中存在时，直接从缓存中获取产品信息，减少数据库查询
     *
     * @param id 产品ID
     * @return 返回查询结果，包含指定ID的产品信息
     */
    @GetMapping("/getProductById")
    @Cacheable(value = "productsCache", key = "#id")
    public Result<Product> getProductById(Long id) {
        // 当从数据库获取数据时会打印，如果是从缓存中查询并不会执行到这里。
        log.info("从数据库获取产品: id = {}", id);
        Product product = new Product(id, "product", 100, "课本", 10);
        return Result.success(product);
    }

    /**
     * 更新产品信息
     * 通过@CacheEvict注解，当更新产品时，清除缓存中对应产品的数据，确保获取到最新的数据
     * 设置allEntries为true，表示清除整个缓存中的所有产品数据
     *
     * @param product 产品对象，包含更新后的详细信息
     * @return 返回更新结果，成功更新时返回成功标志
     */
    @PutMapping("/updateProduct")
    @CacheEvict(value = "productsCache", key = "#product.id")
    public Result updateProduct(@RequestBody Product product) {
        // 更新操作
        return Result.success();
    }

    /**
     * 删除指定ID的产品
     * 通过@CacheEvict注解，当删除产品时，清除缓存中对应产品的数据
     *
     * @param id 待删除产品的ID
     * @return 返回删除结果，成功删除时返回成功标志
     */
    @DeleteMapping("/deleteProductById")
    @CacheEvict(value = "productsCache", key = "#id")
    public Result deleteProductById(Long id) {
        // 删除操作
        return Result.success();
    }


}