基于Spring Cache实现Caffeine+Redis二级缓存

    @Autowire private UserMapper userMapper; @Autowire private RedisCache redisCache; //查询用户 public User getUserById(Long userId) { //定义缓存key String cacheKey = "userId_" + userId; //先查询redis缓存 User user = redisCache.get(cacheKey); //如果缓存中有就直接返回，不再查询数据库 if (user != null) { return user; } //没有再查询数据库 user = userMapper.getUserById(userId); //数据存入缓存，这样下次查询就能到缓存中获取 if (user != null) { stringCommand.set(cacheKey, user); } return user; } 

@Mapper public interface UserMapper  { /** * 根据用户id获取用户信息 * * 如果缓存中有直接返回缓存数据，如果没有那么就去数据库查询，查询完再插入缓存中，这里缓存的key前缀为cache_user_id_，+传入的用户ID */ @Cacheable(key = "'cache_user_id_' + #userId") User getUserById(Long userId); } 

    @Autowire private UserMapper userMapper; //查询用户 public User getUserById(Long userId) { return userMapper.getUserById(userId); } 

package org.Springframework.cache; import java.util.concurrent.Callable; public interface Cache { // cacheName，缓存的名字，默认实现中一般是CacheManager创建Cache的bean时传入cacheName String getName(); //得到底层使用的缓存，如Ehcache Object getNativeCache(); // 通过key获取缓存值，注意返回的是ValueWrapper，为了兼容存储空值的情况，将返回值包装了一层，通过get方法获取实际值 ValueWrapper get(Object key); // 通过key获取缓存值，返回的是实际值，即方法的返回值类型  T get(Object key, Class type); // 通过key获取缓存值，可以使用valueLoader.call()来调使用@Cacheable注解的方法。当@Cacheable注解的sync属性配置为true时使用此方法。 // 因此方法内需要保证回源到数据库的同步性。避免在缓存失效时大量请求回源到数据库  T get(Object key, Callable valueLoader); // 将@Cacheable注解方法返回的数据放入缓存中 void put(Object key, Object value); // 当缓存中不存在key时才放入缓存。返回值是当key存在时原有的数据 ValueWrapper putIfAbsent(Object key, Object value); // 删除缓存 void evict(Object key); // 清空缓存 void clear(); // 缓存返回值的包装 interface ValueWrapper { // 返回实际缓存的对象 Object get(); } } 

package org.Springframework.cache; import java.util.Collection; public interface CacheManager { // 通过cacheName创建Cache的实现bean，具体实现中需要存储已创建的Cache实现bean，避免重复创建，也避免内存缓存 //对象（如Caffeine）重新创建后原来缓存内容丢失的情况 Cache getCache(String name); // 返回所有的cacheName Collection getCacheNames(); } 

public @interface Cacheable { // cacheNames，CacheManager就是通过这个名称创建对应的Cache实现bean @AliasFor("cacheNames") String[] value() default {}; @AliasFor("value") String[] cacheNames() default {}; // 缓存的key，支持SpEL表达式。默认是使用所有参数及其计算的hashCode包装后的对象（SimpleKey） String key() default ""; // 缓存key生成器，默认实现是SimpleKeyGenerator String keyGenerator() default ""; // 指定使用哪个CacheManager,如果只有一个可以不用指定 String cacheManager() default ""; // 缓存解析器 String cacheResolver() default ""; // 缓存的条件，支持SpEL表达式，当达到满足的条件时才缓存数据。在调用方法前后都会判断 String condition() default ""; // 满足条件时不更新缓存，支持SpEL表达式，只在调用方法后判断 String unless() default ""; // 回源到实际方法获取数据时，是否要保持同步，如果为false，调用的是Cache.get(key)方法；如果为true，调用的是Cache.get(key, Callable)方法 boolean sync() default false; } 

public @interface CacheEvict { // ...相同属性说明请参考@Cacheable中的说明 // 是否要清除所有缓存的数据，为false时调用的是Cache.evict(key)方法；为true时调用的是Cache.clear()方法 boolean allEntries() default false; // 调用方法之前或之后清除缓存 boolean beforeInvocation() default false; } 

FIFO：先进先出。选择最先进入的数据优先淘汰。 LRU：最近最少使用。选择最近最少使用的数据优先淘汰。 LFU：最不经常使用。选择在一段时间内被使用次数最少的数据优先淘汰。 

    com.jincouredis-caffeine-cache-starter1.0.0

# 二级缓存配置 # 注：caffeine 不适用于数据量大，并且缓存命中率极低的业务场景，如用户维度的缓存。请慎重选择。 l2cache: config: # 是否存储空值，默认true，防止缓存穿透 allowNullValues: true # 组合缓存配置 composite: # 是否全部启用一级缓存，默认false l1AllOpen: false # 是否手动启用一级缓存，默认false l1Manual: true # 手动配置走一级缓存的缓存key集合，针对单个key维度 l1ManualKeySet: - userCache:user01 - userCache:user02 - userCache:user03 # 手动配置走一级缓存的缓存名字集合，针对cacheName维度 l1ManualCacheNameSet: - userCache - goodsCache # 一级缓存 caffeine: # 是否自动刷新过期缓存 true 是 false 否 autoRefreshExpireCache: false # 缓存刷新调度线程池的大小 refreshPoolSize: 2 # 缓存刷新的频率(秒) refreshPeriod: 10 # 写入后过期时间(秒) expireAfterWrite: 180 # 访问后过期时间(秒) expireAfterAccess: 180 # 初始化大小 initialCapacity: 1000 # 最大缓存对象个数，超过此数量时之前放入的缓存将失效 maximumSize: 3000 # 二级缓存 redis: # 全局过期时间，单位毫秒，默认不过期 defaultExpiration: 300000 # 每个cacheName的过期时间，单位毫秒，优先级比defaultExpiration高 expires: {userCache: 300000,goodsCache: 50000} # 缓存更新时通知其他节点的topic名称 默认 cache:redis:caffeine:topic topic: cache:redis:caffeine:topic 

/** *  启动类 */ @EnableCaching @SpringBootApplication public class CacheApplication { public static void main(String[] args) { SpringApplication.run(CacheApplication.class, args); } } 

/** *  测试 */ @Service public class CaffeineCacheService { private final Logger logger = LoggerFactory.getLogger(CaffeineCacheService.class); /** * 用于模拟db */ private static Map userMap = new HashMap<>(); { userMap.put("user01", new UserDTO("1", "张三")); userMap.put("user02", new UserDTO("2", "李四")); userMap.put("user03", new UserDTO("3", "王五")); userMap.put("user04", new UserDTO("4", "赵六")); } /** * 获取或加载缓存项 */ @Cacheable(key = "'cache_user_id_' + #userId", value = "userCache") public UserDTO queryUser(String userId) { UserDTO userDTO = userMap.get(userId); try { Thread.sleep(1000);// 模拟加载数据的耗时 } catch (InterruptedException e) { e.printStackTrace(); } logger.info("加载数据:{}", userDTO); return userDTO; } /** * 获取或加载缓存项 * 
 * 注：因底层是基于caffeine来实现一级缓存，所以利用的caffeine本身的同步机制来实现 * sync=true 则表示并发场景下同步加载缓存项， * sync=true，是通过get(Object key, Callable valueLoader)来获取或加载缓存项，此时valueLoader（加载缓存项的具体逻辑）会被缓存起来，所以CaffeineCache在定时刷新过期缓存时，缓存项过期则会重新加载。 * sync=false，是通过get(Object key)来获取缓存项，由于没有valueLoader（加载缓存项的具体逻辑），所以CaffeineCache在定时刷新过期缓存时，缓存项过期则会被淘汰。 * 
 */ @Cacheable(value = "userCache", key = "#userId", sync = true) public List queryUserSyncList(String userId) { UserDTO userDTO = userMap.get(userId); List list = new ArrayList(); list.add(userDTO); logger.info("加载数据:{}", list); return list; } /** * 更新缓存 */ @CachePut(value = "userCache", key = "#userId") public UserDTO putUser(String userId, UserDTO userDTO) { return userDTO; } /** * 淘汰缓存 */ @CacheEvict(value = "userCache", key = "#userId") public String evictUserSync(String userId) { return userId; } }