Springboot cache框架应用Caffeine/redis

需求描述：Springboot cache框架+Caffeine/redis（可切换或共用）

配置文件：

pom依赖：

CacheConfig：所有的装配动作都在此，各类型缓存装配，keygenerator，超时，等。

@Autowired
private RedisConnectionFactory factory;
@Autowired
private CaffeineSpec spec;
@Autowired
private CacheResolves cacheresolves;

@Bean
public CacheResolver setResolver(){
    cacheresolves.setType("redis");
    cacheresolves.setCaffeineMan(caffeineManager());
    cacheresolves.setRedisMan(redisManager());
    return cacheresolves;
}

@Bean
public CacheManager caffeineManager(){
    CaffeineCacheManager manager=new CaffeineCacheManager();
    manager.setCaffeineSpec(spec);
    manager.setCacheNames(CacheNameConfig.getCaffeineCacheName());
    return manager;
}
@Bean
public CacheManager redisManager(){
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
    redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
            RedisSerializationContext
                    .SerializationPair
                    .fromSerializer(jackson2JsonRedisSerializer)
    ).entryTtl(Duration.ofSeconds(3600));// 默认超时时间
   return RedisCacheManager.builder().cacheDefaults(redisCacheConfiguration)
           .withInitialCacheConfigurations(CacheNameConfig.getExpressCacheName())
           .initialCacheNames(CacheNameConfig.getRedisCacheName()).build();//根据cachename自定义过期时间
}

@Bean
public RedisTemplate<String, Object> redisTemplate() {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(factory);
    return template;
}
@Bean("prefixKeyGenerator")
public PrefixKeyGenerator initPrefixKeyGenerator(){
    PrefixKeyGenerator prefixKeyGenerator = new PrefixKeyGenerator("prefix");
    return prefixKeyGenerator;
}

CacheNameConfig配置类：

public static final String REDIS_CACHE_NAME="redisCacheName";
public static final String CAFFEINE_CACHE_NAME="caffeineCacheName";

public static Set<String> getCaffeineCacheName(){
    Set<String> cacheName=new HashSet<>();
    cacheName.add(CAFFEINE_CACHE_NAME);
    return cacheName;
}

public static Set<String> getRedisCacheName(){
    Set<String> cacheName=new HashSet<>();
    cacheName.add(REDIS_CACHE_NAME);
    return cacheName;
}
public static Map<String, RedisCacheConfiguration> getExpressCacheName(){
    Map<String, RedisCacheConfiguration> map=new HashMap<>();
    map.put(REDIS_CACHE_NAME,RedisCacheConfiguration.
            defaultCacheConfig().entryTtl(Duration.ofSeconds(3600)));
    return map;
}

CacheResolver实现类，这里提供了切换机制，核心是给resolve装配多个cachemanager，然后通过名字来切换，使用的时候resolve和name共同使用

private String type;
private CacheManager redisMan;
private CacheManager caffeineMan;
private NoOpCacheManager noOpCacheManager =new NoOpCacheManager();
@Override
public Collection<? extends Cache> resolveCaches(CacheOperationInvocationContext<?> context) {
    Collection<Cache> caches = new ArrayList<>();
    CacheManager manager =getCacheManager();
    Collection<String>  collection=manager.getCacheNames();
    String cacheName = context.getOperation().getCacheNames().iterator().next();//获取到当前执行的name
    for (String str:collection){//这里可以通过控制name来控制resolve，因为可以放入不同的cache（如果你想要共用）
        if (cacheName.equals(str)){
            caches.add(manager.getCache(str));
        }
    }
    return caches;
}
public CacheManager getCacheManager(){
    if (type.equals("redis")){
        return redisMan;
    }else if (type.equals("caffeine")){
        return caffeineMan;
    }else {
        return noOpCacheManager;
    }
}

keygenerator实现类，这个自由发挥

public class PrefixKeyGenerator implements KeyGenerator {

    private String module;
    public PrefixKeyGenerator(){}
    public PrefixKeyGenerator(String module) {
        this.module = module;
    }

    @Override
    public Object generate(Object target, Method method, Object... params) {

        StringBuilder key = new StringBuilder();
        key.append(this.module).append(":").append(target.getClass().getClass())
                .append(".")
                .append(params[0]);
        return key.toString();
    }

业务类：

@CacheConfig(cacheResolver = "cacheResolves",cacheNames = CacheNameConfig.REDIS_CACHE_NAME)
public class RedisCacheTest {
    private Map<String,Object> map=new HashMap<>();
    @CachePut(keyGenerator = "prefixKeyGenerator")
    public EntryData setData(EntryData data){
        map.put("user::"+data.getName(),data);
        return data;
    }

    @Cacheable(key = "#data")
    public EntryData getData(String data){
        return (EntryData) map.get("user::"+data);
    }
}

@Configuration
@CacheConfig(cacheResolver = "cacheResolves",cacheNames = CacheNameConfig.CAFFEINE_CACHE_NAME)
public class CaffineCacheTest {

    @CachePut(key = "#data.name")
    public EntryData setData(EntryData data){
        return data;
    }
}

这里的区分点在于各个manager初始化的时候装载了不同的name，在调用的时候会在resolve类中进行寻找，可以断点跟踪这块。