配置springboot cache使用redis作为缓存

简介

springboot将缓存模块抽象成了一个组件，支持各种形式的缓存类型，如Generic、EhCache和redis等。不同的缓存类型实现原理和存储位置都不尽相同。

• Generic使用一个简单的 Map 结构来存储缓存数据，通常用于测试或简单的内存缓存场景。数据存储在 JVM 的堆内存中，通常在一个ConcurrentMap 实例中。
• ehcache 是一种高性能的、分布式的 Java缓存系统。支持多种缓存配置，如内存和磁盘缓存、缓存分区、缓存过期策略等。可以在单机或多节点集群环境中使用。数据主要存储在 JVM的堆内存中。可以配置为使用磁盘作为二级存储，以支持持久化缓存。在集群环境中，数据可以在多台服务器之间共享。
• redis是我们常用的一种缓存方案，相对于其他几种在性能、安全等方面都比较突出。下面开始配置在Cache模块使用redis保存数据。

实现

1.引入redis

首先将redis引入springboot框架

1.1引入依赖

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

1.2配置redis

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

1.3重写RedisTemplate的序列化方式

为什么要重写？

springboot通过自动配置会注册一个RedisTemplate的bean，使用RedisTemplate就可以直接操作redis了。RedisTemplate在写入和读取数据时都会进行序列化和反序列化，这是因为像对象类型的数据无法直接写入redis，需要进行序列化变成基本的字符串才能写入。反序列化就是可以把字符串还原成写入前的对象。

默认情况下RedisTemplate的序列化器是jdk的序列化器，序列化后的数据不利于阅读，所以重置RedisTemplate的序列化器可以让保存的数据更利于查看。

重写

经过下面的配置，使用RedisTemplate写入数据时键会按普通字符串的形式保存，值会以json格式保存。

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author manem
 */
@Configuration
@EnableCaching
public class RedisConfig {
    /**
     * 重新定义RedisTemplate，以string格式保存键、json格式保存值
     * @param redisConnectionFactory 自动注册的redis🔗配置
     * @return RedisTemplate<String, Object>
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> jsonSerializer = jsonSerializer();

        //设置value的序列化方式json
        redisTemplate.setValueSerializer(jsonSerializer);
        //设置key序列化方式String
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 定义json格式的序列化器
     * @return Jackson2JsonRedisSerializer<Object>
     */
    @Bean
    public Jackson2JsonRedisSerializer<Object> jsonSerializer() {
        Jackson2JsonRedisSerializer<Object> jsonSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jsonSerializer.setObjectMapper(mapper);
        return jsonSerializer;
    }
}

2.启用缓存模块

默认情况下缓存功能是未启用的，使用@EnableCaching启用springboot的缓存功能。这一步在上面的代码已有体现。

3.为不同业务配置缓存空间

json格式保存的数据不一定适用所有场景，通过cacheName可以为不同业务配置不同的缓存规则。

以spring-security为例，缓存UserDetails时，使用json反序列化会失败，因为SimpleGrantedAuthority没有公共构造函数，所以反序列化会失败。使用jdk默认的序列化方式就可以解决。

spring:
    cache:
      # 为缓存定义组件名，以区分不同业务
      cache-names:
        - product
        - user

除了可以配置不同的序列化器还可以设置不同的存活时间

import org.springframework.boot.autoconfigure.cache.RedisCacheManagerBuilderCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

import java.time.Duration;

/**
 * 配置springboot的缓存
 * @author manem
 */
@Configuration
public class CacheConfig {
    /**
     * 自定义多个不同业务的缓存配置
     * @param jsonRedisSerializer json序列化器
     * @return RedisCacheManagerBuilderCustomizer
     */
    @Bean
    public RedisCacheManagerBuilderCustomizer myRedisCacheManagerBuilderCustomizer(Jackson2JsonRedisSerializer<Object> jsonRedisSerializer) {
        return (builder) -> builder
                .withCacheConfiguration("product", RedisCacheConfiguration
                        .defaultCacheConfig()
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jsonRedisSerializer))
                        // 5min过期
                        .entryTtl(Duration.ofMinutes(5L))
                )
                // user缓存的数据是UserDetails对象，使用默认的jdk序列化可以较好的完成反序列化
                .withCacheConfiguration("user", RedisCacheConfiguration
                        .defaultCacheConfig()
                        .entryTtl(Duration.ofMinutes(5L))
                );
    }
}

4.使用缓存

在需要缓存数据的方法上使用@Cacheable注解标注，加上对应的缓存空间即可

@Cacheable(value = "product", key = "'product-' + #p0")
@Override
public ProductDetailDTO getProductDetail(long id){
    // ...业务代码
}