springboot2.0 redis EnableCaching的配置和使用

最新推荐文章于 2024-05-13 19:34:12 发布

转载最新推荐文章于 2024-05-13 19:34:12 发布 · 1.2k 阅读

spring boot 同时被 3 个专栏收录

3 篇文章

订阅专栏

spring cloud

3 篇文章

订阅专栏

redis

2 篇文章

订阅专栏

本文介绍了Spring Cache的简单使用，包括引入cache模块的Maven依赖，常用注解如@Cacheable、@CacheEvict等。还对比了基于Jedis和Lettuce的RedisCacheManager配置，指出Jedis在多线程下的不足及Lettuce的优势，同时说明了不同缓存的过期时间和序列化、反序列化设置。

原文：https://www.cnblogs.com/hujunzheng/p/9660681.html

一、前言

关于EnableCaching最简单使用，个人感觉只需提供一个CacheManager的一个实例就好了。springboot为我们提供了cache相关的自动配置。引入cache模块，如下。

二、maven依赖

<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> <dependency> <groupId>org.springframework.integration</groupId> <artifactId>spring-integration-redis</artifactId> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency>

三、缓存类型

https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-caching.html

四、常用注解

@Cacheable 触发缓存填充

　　@CacheEvict 触发缓存驱逐

　　@CachePut 更新缓存而不会干扰方法执行

　　@Caching 重新组合要在方法上应用的多个缓存操作

　　@CacheConfig 在类级别共享一些常见的缓存相关设置

五、Spring cache 提供的Spel上下文数据

六、RedisCacheManager配置

1.基于jedis

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {

　　@Autowired
    private RedisProperties redisProperties;
    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory() {
        String[] serverArray = redisProperties.getClusterNodes().split(",");// 获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(Arrays.asList(serverArray));
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        // 最大空闲连接数, 默认8个
        poolConfig.setMaxIdle(100);
        // 最大连接数, 默认8个
        poolConfig.setMaxTotal(500);
        // 最小空闲连接数, 默认0
        poolConfig.setMinIdle(0);
        LettuceClientConfiguration lettuceClientConfiguration = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(15))
                .poolConfig(poolConfig)
                .shutdownTimeout(Duration.ZERO)
                .build();
        return new LettuceConnectionFactory(redisClusterConfiguration, lettuceClientConfiguration);
    }
    /**     * 注入redis template     *     * @return     */
    @Bean
    @Qualifier("redisTemplate")
    public RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory, Jackson2JsonRedisSerializer jackson2JsonRedisSerializer) {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(lettuceConnectionFactory);
        template.setKeySerializer(new JdkSerializationRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
    /**     * redis cache manager     *     * @return     */
    @Bean
    @Primary
    public RedisCacheManager redisCacheManager(LettuceConnectionFactory lettuceConnectionFactory, ObjectProvider<List<RedisCacheConfigurationProvider>> configurationProvider) {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = Maps.newHashMap();
        List<RedisCacheConfigurationProvider> configurations = configurationProvider.getIfAvailable();
        if (!CollectionUtils.isEmpty(configurations)) {
            for (RedisCacheConfigurationProvider configuration : configurations) {
                redisCacheConfigurationMap.putAll(configuration.resolve());
            }
        }
        RedisCacheManager cacheManager = RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(lettuceConnectionFactory)
                .cacheDefaults(resovleRedisCacheConfiguration(Duration.ofSeconds(300), JacksonHelper.genJavaType(Object.class)))
                .withInitialCacheConfigurations(redisCacheConfigurationMap)
                .build();
        return cacheManager;
    }
    private static RedisCacheConfiguration resovleRedisCacheConfiguration(Duration duration, JavaType javaType) {
        return RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(javaType)))
                .entryTtl(duration);
    }
    @Bean
    public RedisLockRegistry redisLockRegistry(LettuceConnectionFactory lettuceConnectionFactory) {
        return new RedisLockRegistry(lettuceConnectionFactory, "recharge-plateform", 60000 * 20);
    }

2.基于Lettuce

@Configuration
@EnableCaching
public class RedisCacheConfig extends CachingConfigurerSupport {

　　@Autowired
    private RedisProperties redisProperties;
    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory() {
        String[] serverArray = redisProperties.getClusterNodes().split(",");// 获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(Arrays.asList(serverArray));
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        // 最大空闲连接数, 默认8个
        poolConfig.setMaxIdle(100);
        // 最大连接数, 默认8个
        poolConfig.setMaxTotal(500);
        // 最小空闲连接数, 默认0
        poolConfig.setMinIdle(0);
        LettuceClientConfiguration lettuceClientConfiguration = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofSeconds(15))
                .poolConfig(poolConfig)
                .shutdownTimeout(Duration.ZERO)
                .build();
        return new LettuceConnectionFactory(redisClusterConfiguration, lettuceClientConfiguration);
    }
    /**     * 注入redis template     *     * @return     */
    @Bean
    @Qualifier("redisTemplate")
    public RedisTemplate redisTemplate(LettuceConnectionFactory lettuceConnectionFactory, Jackson2JsonRedisSerializer jackson2JsonRedisSerializer) {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(lettuceConnectionFactory);
        template.setKeySerializer(new JdkSerializationRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
    /**     * redis cache manager     *     * @return     */
    @Bean
    @Primary
    public RedisCacheManager redisCacheManager(LettuceConnectionFactory lettuceConnectionFactory, ObjectProvider<List<RedisCacheConfigurationProvider>> configurationProvider) {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = Maps.newHashMap();
        List<RedisCacheConfigurationProvider> configurations = configurationProvider.getIfAvailable();
        if (!CollectionUtils.isEmpty(configurations)) {
            for (RedisCacheConfigurationProvider configuration : configurations) {
                redisCacheConfigurationMap.putAll(configuration.resolve());
            }
        }
        RedisCacheManager cacheManager = RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(lettuceConnectionFactory)
                .cacheDefaults(resovleRedisCacheConfiguration(Duration.ofSeconds(300), JacksonHelper.genJavaType(Object.class)))
                .withInitialCacheConfigurations(redisCacheConfigurationMap)
                .build();
        return cacheManager;
    }
    private static RedisCacheConfiguration resovleRedisCacheConfiguration(Duration duration, JavaType javaType) {
        return RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer<>(javaType)))
                .entryTtl(duration);
    }
    @Bean
    public RedisLockRegistry redisLockRegistry(LettuceConnectionFactory lettuceConnectionFactory) {
        return new RedisLockRegistry(lettuceConnectionFactory, "recharge-plateform", 60000 * 20);
    }
    /**     * 配置一个序列器, 将对象序列化为字符串存储, 和将对象反序列化为对象     */
    @Bean
    public Jackson2JsonRedisSerializer jackson2JsonRedisSerializer() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }
    public static abstract class RedisCacheConfigurationProvider {
        // key = 缓存名称， value = 缓存时间 和 缓存类型
        protected Map<String, Pair<Duration, JavaType>> configs;
        protected abstract void initConfigs();
        public Map<String, RedisCacheConfiguration> resolve() {
            initConfigs();
            Assert.notEmpty(configs, "RedisCacheConfigurationProvider 配置不能为空...");
            Map<String, RedisCacheConfiguration> result = Maps.newHashMap();
            configs.forEach((cacheName, pair) -> result.put(cacheName, resovleRedisCacheConfiguration(pair.getKey(), pair.getValue())));
            return result;
        }
    }

}

Jedis和Lettuce比较

　Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，如果想要在多线程环境下使用 Jedis，需要使用连接池，

　　每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。

　　Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，

　　所以，一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。通过异步的方式可以让我们更好的利用系统资源，而不用浪费线程等待网络或磁盘I/O。

　　只在基于Lettuce的配置中，加入了RedisLockRegistry对应bean的配置，由于在集群的模式下，基于Jedis的配置下，通过RedisLockRegistry 获取分布式锁的时候报错：

EvalSha is not supported in cluster environment

　　具体的解决方案就是切换至基于Lettuce的配置，请参考

https://stackoverflow.com/questions/47092475/spring-boot-redistemplate-execute-sc

　　RedisCacheConfigurationProvider 作用为不同的cache提供特定的缓存时间以及key、value序列化和反序列化的方式。具体使用方式如下。

@Component

public class CouponRedisCacheConfigurationProvider extends RedisCacheConfig.RedisCacheConfigurationProvider {

    @Override
    protected void initConfigs() {
        this.configs = Maps.newHashMap();
        this.configs.put(CouponConstants.COUPON_ALL_CACHE, new Pair<>(Duration.ofHours(1), JacksonHelper.genMapType(HashMap.class, Integer.class, Coupon.class)));
        this.configs.put(CouponConstants.COUPON_GOOD_CACHE, new Pair<>(Duration.ofHours(1), JacksonHelper.genCollectionType(List.class, String.class)));

        this.configs.put(CouponConstants.COUPON_HANDLE_TELEPHONE_STATUS_CACHE, new Pair<>(Duration.ofMinutes(10), JacksonHelper.genCollectionType(List.class, CouponHandle.class)));
        this.configs.put(CouponConstants.COUPON_HANDLE_TELEPHONE_GOOD_CACHE, new Pair<>(Duration.ofMinutes(10), JacksonHelper.genCollectionType(List.class, CouponHandle.class)));
    }

}

JacksonHelper 作用是根据不同的类型的对象获取对应的JavaType对象，在构造RedisTempalte序列化和反序列化器Jackson2JsonRedisSerializer对象需要。具体代码如下。

public class JacksonHelper {
    private static Logger LOGGER = LoggerFactory.getLogger(JacksonHelper.class);

    private static final SimpleModule module = initModule();
    private static final ObjectMapper objectMapper;
    private static final ObjectMapper prettyMapper;

    public JacksonHelper() {
    }

    private static SimpleModule initModule() {
        return (new SimpleModule()).addSerializer(BigDecimal.class, new BigDecimalSerializer())
                .addSerializer(LocalTime.class, new LocalTimeSerializer())
                .addDeserializer(LocalTime.class, new LocalTimeDeserializer())
                .addSerializer(LocalDate.class, new LocalDateSerializer())
                .addDeserializer(LocalDate.class, new LocalDateDeserializer())
                .addSerializer(LocalDateTime.class, new LocalDateTimeSerializer())
                .addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer())
                .addSerializer(Date.class, new DateSerializer())
                .addDeserializer(Date.class, new DateDeserializer());
    }

    public static JavaType genJavaType(TypeReference<?> typeReference) {
        return getObjectMapper().getTypeFactory().constructType(typeReference.getType());
    }

    public static JavaType genJavaType(Class<?> clazz) {
        return getObjectMapper().getTypeFactory().constructType(clazz);
    }

    public static JavaType genCollectionType(Class<? extends Collection> collectionClazz, Class<?> javaClazz) {
        return getObjectMapper().getTypeFactory().constructCollectionType(collectionClazz, javaClazz);
    }

    public static JavaType genMapType(Class<? extends Map> mapClazz, Class<?> keyClass, Class<?> valueClazz) {
        return getObjectMapper().getTypeFactory().constructMapType(mapClazz, keyClass, valueClazz);
    }

    public static ObjectMapper getObjectMapper() {
        return objectMapper;
    }

    public static ObjectMapper getPrettyMapper() {
        return prettyMapper;
    }

    static {
        objectMapper = (new ObjectMapper()).registerModule(module).configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false).configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true).configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        prettyMapper = objectMapper.copy().configure(SerializationFeature.INDENT_OUTPUT, true);
    }

}



class LocalDateDeserializer extends JsonDeserializer<LocalDate> {

    public LocalDateDeserializer() {
    }

    public LocalDate deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        String dateString = ((JsonNode) jp.getCodec().readTree(jp)).asText();
        return LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE);
    }

}



class DateDeserializer extends JsonDeserializer<Date> {

    public DateDeserializer() {
    }

    public Date deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        String dateTimeStr = ((JsonNode) jp.getCodec().readTree(jp)).asText();
        SimpleDateFormat sdf = new SimpleDateFormat(CouponConstants.DATE_TIME_FORMATER);
        ParsePosition pos = new ParsePosition(0);
        return sdf.parse(dateTimeStr, pos);
    }

}



class LocalDateTimeDeserializer extends JsonDeserializer<LocalDateTime> {

    public LocalDateTimeDeserializer() {
    }

    public LocalDateTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        String dateTimeStr = ((JsonNode) jp.getCodec().readTree(jp)).asText();
        return LocalDateTime.parse(dateTimeStr, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
    }

}



class LocalTimeDeserializer extends JsonDeserializer<LocalTime> {

    public LocalTimeDeserializer() {
    }

    public LocalTime deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
        String dateString = ((JsonNode) jp.getCodec().readTree(jp)).asText();
        return LocalTime.parse(dateString, DateTimeFormatter.ISO_LOCAL_TIME);
    }

}



class BigDecimalSerializer extends JsonSerializer<BigDecimal> {

    public BigDecimalSerializer() {
    }

    public void serialize(BigDecimal value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeString(value.toString());
    }

}



class LocalDateSerializer extends JsonSerializer<LocalDate> {

    public LocalDateSerializer() {
    }

    public void serialize(LocalDate value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeString(DateTimeFormatter.ISO_LOCAL_DATE.format(value));
    }

}



class LocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {

    public LocalDateTimeSerializer() {
    }

    public void serialize(LocalDateTime value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeString(DateTimeFormatter.ISO_LOCAL_DATE_TIME.format(value));
    }

}



class DateSerializer extends JsonSerializer<Date> {

    public DateSerializer() {
    }

    public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        SimpleDateFormat sdf = new SimpleDateFormat(CouponConstants.DATE_TIME_FORMATER);
        jgen.writeString(sdf.format(value));
    }

}



class LocalTimeSerializer extends JsonSerializer<LocalTime> {

    public LocalTimeSerializer() {
    }

    public void serialize(LocalTime value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
        jgen.writeString(DateTimeFormatter.ISO_LOCAL_TIME.format(value));
    }

}

业务代码

@Component
public class ServiceImpl {  

　　 @Override
    @CacheEvict(cacheNames = CouponConstants.COUPON_HANDLE_TELEPHONE_STATUS_CACHE, key = "#telephone+'#'+#status", beforeInvocation = true)
    public void evictCouponHandles(String telephone, Integer status) {

    }

    @Override
    @Cacheable(cacheNames = CouponConstants.COUPON_HANDLE_TELEPHONE_STATUS_CACHE, key = "#telephone+'#'+#status", sync = true)
    public List<CouponHandle> searchCouponHandles(String telephone, Integer status) {
    }

}

不同的缓存对应不同的存储类型，不同的存储类型对应着不同的序列化和反序列化器，这就保证了再调用注有@Cacheable注解的代码时获取到的对象不会发生类型转换错误。关于设置不同的cache下过期时间以及序列化和反序列器，请参考下面更直接明了的例子。

@Configuration

public class RedisCacheConfig {

    @Bean
    public KeyGenerator simpleKeyGenerator() {
        return (o, method, objects) -> {
            StringBuilder stringBuilder = new StringBuilder();
            stringBuilder.append(o.getClass().getSimpleName());
            stringBuilder.append(".");
            stringBuilder.append(method.getName());
            stringBuilder.append("[");
            for (Object obj : objects) {
                stringBuilder.append(obj.toString());
            }
            stringBuilder.append("]");

            return stringBuilder.toString();
        };
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl(600), // 默认策略，未配置的 cache 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 cache 策略
        );
    }

    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(3000));
        redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000));

        return redisCacheConfigurationMap;
    }

    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));

        return redisCacheConfiguration;
    }

}

@Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator") // 3000秒

@Cacheable(value = "UserInfoListAnother", keyGenerator = "simpleKeyGenerator") // 18000秒

@Cacheable(value = "DefaultKeyTest", keyGenerator = "simpleKeyGenerator") // 600秒，未指定的cache，使用默认策略