SpringBoot集成Redis学习笔记

1、首先引入maven依赖

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

2、配置信息

 

 

redis:
    host: localhost
    port: 6379
    max-wait: 30000
    max-active: 100
    max-idle: 20
    min-idle: 0
    timeout: 3000
    password: 12345

3、配置类：

@Configuration
@EnableCaching //开启注解
public class RedisConfig extends CachingConfigurerSupport {
    public static final String EMPTY_KEY = "'DEFAULT'";
    private static final SimpleKeyGenerator SIMPLE_KEY_GENERATOR = new SimpleKeyGenerator();
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;
    @Autowired
    private ApplicationContext applicationContext;

    @Override
    @Bean
    public CacheManager cacheManager() {
        RedisSerializer redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        //解决读取报错开始
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.configure(MapperFeature.USE_ANNOTATIONS, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        //解决读取报错结束
        //日期序列化开始
        objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        objectMapper.registerModule(new Jdk8Module())
                .registerModule(new JavaTimeModule())
                .registerModule(new ParameterNamesModule());
        //日期序列化结束
        serializer.setObjectMapper(objectMapper);
        RedisSerializationContext.SerializationPair val = RedisSerializationContext.SerializationPair.fromSerializer(serializer);
        //乱码开始
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(300))
                //使用冒号做key的连接符, 默认的是::
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer)).disableCachingNullValues();
        //乱码结束
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(defaultCacheConfig)
                .withInitialCacheConfigurations(initRedisCacheConfig(val)).build();
    }

    public HashMap<String, RedisCacheConfiguration> initRedisCacheConfig(RedisSerializationContext.SerializationPair ser) {
        HashMap<String, RedisCacheConfiguration> cacheConfigMap = new HashMap<>();
        for (String bean : applicationContext.getBeanNamesForType(Object.class)) {
            Class<?> clazz = applicationContext.getType(bean);
            if (Objects.isNull(clazz)) {
                continue;
            }
            ReflectionUtils.doWithMethods(clazz, method -> {
                ReflectionUtils.makeAccessible(method);
                method.getAnnotation(CacheExpire.class);
                CacheExpire cacheExpire = AnnotationUtils.findAnnotation(method, CacheExpire.class);
                if (Objects.isNull(cacheExpire)) {
                    return;
                }

                Cacheable cacheable = AnnotationUtils.findAnnotation(method, Cacheable.class);
                if (Objects.nonNull(cacheable)) {
                    for (String cacheName : cacheable.cacheNames()) {
                        if (StringUtil.isEmpty(cacheName)) {
                            continue;
                        }
                        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                                .entryTtl(Duration.ofMillis(cacheExpire.type().toMillis(cacheExpire.expire())))
                                .disableCachingNullValues().serializeValuesWith(ser);
                        cacheConfigMap.put(cacheName, config);
                    }
                }
            });
        }
        return cacheConfigMap;
    }

    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return (o, m, params) -> {
            CacheEvict cacheEvict = m.getAnnotation(CacheEvict.class);
            if (Objects.nonNull(cacheEvict) && EMPTY_KEY.equals(cacheEvict.key())) {
                return EMPTY_KEY;
            }
            if (params.length == 0) {
                return EMPTY_KEY;
            }
            return SIMPLE_KEY_GENERATOR.generate(o, m, params);
        };
    }
}

4、启动类

添加@EnableCaching注解

5、自定义过期时间注解

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface CacheExpire {

    @AliasFor("expire")
    long value() default 60L;

    @AliasFor("value")
    long expire() default 60L;

    TimeUnit type() default TimeUnit.SECONDS;

}

6、测试代码

@Override
    @Cacheable(value = "dictValue",key = "#typeId+'-'+#value")
    @CacheExpire(value = 360)
    public DictValue get(Integer typeId, Integer value) {
        List<DictValue> dictValueList = dictMapper.selectByTypeAndValue(typeId, value);
        if (!CollectionUtils.isEmpty(dictValueList)) {
            return dictValueList.get(0);
        }
        return null;
    }