springboot,redis,caffeine二级缓存搭建_springboot caffie redi-优快云博客

本文链接：https://blog.youkuaiyun.com/zhenghuasheng/article/details/110668067

本文介绍了如何在SpringBoot项目中搭建二级缓存，包括Caffeine本地缓存和Redis远程缓存的集成。首先，进行SpringBoot项目的准备工作和Redis的集成，然后引入Caffeine作为本地缓存，详细讲述了Caffeine的Maven依赖和配置。通过Redis的消息通知机制，实现了当远程缓存变化时清除本地缓存，确保数据一致性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

准备工作

1，springboot项目搭建（open）
2，redis 集成

redis服务redis.conf 修改配置 notify-keyspace-events Ex
或使用客户端命令设置：config set notify-keyspace-events Ex

redis maven依赖

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

redis相关配置

spring:
  redis:
    database: 0
    host: 127.0.0.1
    password: 123566
    jedis:
      pool:
        max-active: 20
        max-idle: 8
        max-wait: 6000
        min-idle: 0
    port: 6379
    timeout: 10000

/**
 * @author zhenghuasheng
 * @date 2016/5/9
 */

@Configuration
public class RedisConfig extends CachingConfigurerSupport {
   

    @Bean
    public KeyGenerator localKeyGenerator() {
   
        return (target, method, params) -> {
   
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName() + "#");
            sb.append(method.getName() + ":");
            for (Object obj : params) {
   
                if (obj != null) {
   
                    sb.append(obj.toString());
                }
            }
            return sb.toString();
        };
    }

    /**
     * 因加入二级缓存，本地缓存采用caffeine，cacheManage不能重复定义
     * @return
     */
//    @Bean
//    public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisConnectionFactory connectionFactory) {
   
//        /* 默认配置， 默认超时时间为30s */
//        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration
//                .defaultCacheConfig()
//                .entryTtl(Duration.ofMinutes(30))// 设置缓存的默认过期时间，也是使用Duration设置.对注解形式生效
//                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
//                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
//                .disableCachingNullValues();     // 不缓存空值
//
//        RedisCacheManager cacheManager = RedisCacheManager.builder(RedisCacheWriter.lockingRedisCacheWriter
//                (connectionFactory)).cacheDefaults(defaultCacheConfig).transactionAware().build();
//        return cacheManager;
//    }


    //redis键序列化使用StrngRedisSerializer
    private RedisSerializer<String> keySerializer() {
   
        return new StringRedisSerializer();
    }


    //redis值序列化使用json序列化器
    private RedisSerializer<Object> valueSerializer() {
   
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        om.configure(SerializationFeature.WRAP_ROOT_VALUE, false);

        return new GenericJackson2JsonRedisSerializer(om);
    }

    private RedisSerializer<Object> jackson2JonSerializer() {
   
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance ,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        om.configure(SerializationFeature.WRAP_ROOT_VALUE, false);

        jackson2JsonRedisSerializer.setObjectMapper(om);
        return jackson2JsonRedisSerializer;
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
   
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        //Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
//        JdkSerializationRedisSerializer jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
        template.setKeySerializer(keySerializer());
        template.setHashKeySerializer(keySerializer());
        template.setValueSerializer(valueSerializer());
        template.setHashValueSerializer(valueSerializer());
        template.afterPropertiesSet();
        return template;
    }
//    @Bean
//    public JedisConnectionFactory redisConnectionFactory() {
   
//        JedisConnectionFactory factory = new JedisConnectionFactory();
//        factory.setPassword(redisPassword);
//        factory.setPoolConfig(new JedisPoolConfig());
        factory.setHostName(host);
        factory.setPort(port);