springboot 2+redis 2 的cacheable用法与配置

用法
类上(最好是放在服务层)加
@CacheConfig(cacheNames = “default”,keyGenerator = “keyGenerator”)
方法上加
@Cacheable(keyGenerator = “keyGenerator”,cacheNames=“default”)

引入包

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>
		<!--连接redis-->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
		</dependency>

配置文件，根据时间配置三个缓存名，并且把它们的序列化方式，设定序列化

package ca.citylinkiot.battery_charging.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.*;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.time.Duration;
import java.util.*;

/**
 * Created by admin on 2019/9/24.
 */
@Configuration
@EnableCaching
public class CacheConfig {
//    @Bean
//    RedisTemplate redisTemplate(){
//        return
//    }
//    @Resource
//    RedisTemplate redisTemplate;
//    @Resource
//    StringRedisTemplate stringRedisTemplate;
    /*@Bean
    @ConfigurationProperties(prefix = "spring.redis")
    RedisConnectionFactory redisConnectionFactory(){
//        return new JedisConnectionFactory();
        LettuceConnectionFactory lettuceConnectionFactory=new LettuceConnectionFactory();
        lettuceConnectionFactory.
    }*/
//    @Resource
//    LettuceConnectionFactory lettuceConnectionFactory;
    @Bean
    @ConfigurationProperties(prefix = "spring.redis")
    RedisConnectionFactory lettuceConnectionFactory(){//LettuceConnectionFactory是RedisConnectionFactory的实现
        return new LettuceConnectionFactory();
    }

    @Bean
    RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1)) // 设置缓存有效期一小时
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json()));

//        RedisCacheManager redisCacheManager = RedisCacheManager
//                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
//                .cacheDefaults(redisCacheConfiguration).build();
        Map<String, RedisCacheConfiguration> initialCacheConfigurations=new HashMap<>();
        initialCacheConfigurations.put("sixHoursCache",RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(6))
//                     这一行代码会导致空置针，但是上面设置这一项，却没有控制真错误
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json())));;
        initialCacheConfigurations.put("fiveMinutesCache",RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(5))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.json())));;
        RedisCacheManager redisCacheManager=new RedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                redisCacheConfiguration,
                initialCacheConfigurations);
        return redisCacheManager;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
                StringRedisTemplate template = new StringRedisTemplate(factory);
                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);
                template.setValueSerializer(jackson2JsonRedisSerializer);
                template.setHashValueSerializer(jackson2JsonRedisSerializer);
                template.afterPropertiesSet();
                return template;
            }

    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                String className = target.getClass().getName();//.replace("com.duia.home.service.impl.","").replace("ServiceImpl","");
                sb.append(className + ".");
                sb.append(method.getName() + ".");
                                /*for (Object obj : params) {
//                                        if (obj instanceof Date){
//                                                sb.append( DateUtils.format((Date) obj,"yyyy-MM-dd"));
//                                            }else {
//                                                sb.append (obj.toString());
//                                            }

                                    }*/
//                                sb.append(Collections.)
                String paraStr = Arrays.asList(params).toString();
                sb.append(paraStr);
                return sb.toString();
            }
        };
    }
}

yml 配置

spring:
 redis:
#    nodes: localhost # 192.168.1.81:7000,192.168.1.81:7001,192.168.1.81:7002
    host: localhost
#    url
    password: 667
    timeout: 20000
#    pool:
#      max-idle: 100
#      min-idle: 1
#      max-active: 1000
#      max-wait: -1
    lettuce: # 这里标明使用lettuce配置
          pool:
            max-active: 8   #连接池最大连接数（使用负值表示没有限制）
            max-wait: -1ms  #连接池最大阻塞等待时间（使用负值表示没有限制）
            max-idle: 5     #连接池中的最大空闲连接
            min-idle: 0     #连接池中的最小空闲连接