基于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> T get(Object key, Class<T> type);

     // 通过key获取缓存值，可以使用valueLoader.call()来调使用@Cacheable注解的方法。当@Cacheable注解的sync属性配置为true时使用此方法。

     // 因此方法内需要保证回源到数据库的同步性。避免在缓存失效时大量请求回源到数据库

     <T> T get(Object key, Callable<T> 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<String> 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：最不经常使用。选择在一段时间内被使用次数最少的数据优先淘汰。

< dependency >

          < groupId >com.jincou</ groupId >

          < artifactId >redis-caffeine-cache-starter</ artifactId >

          < version >1.0.0</ version >

</ dependency >

# 二级缓存配置

# 注：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<String, UserDTO> 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;

     }

     /**

      * 获取或加载缓存项

      * <p>

      * 注：因底层是基于caffeine来实现一级缓存，所以利用的caffeine本身的同步机制来实现

      * sync=true 则表示并发场景下同步加载缓存项，

      * sync=true，是通过get(Object key, Callable<T> valueLoader)来获取或加载缓存项，此时valueLoader（加载缓存项的具体逻辑）会被缓存起来，所以CaffeineCache在定时刷新过期缓存时，缓存项过期则会重新加载。

      * sync=false，是通过get(Object key)来获取缓存项，由于没有valueLoader（加载缓存项的具体逻辑），所以CaffeineCache在定时刷新过期缓存时，缓存项过期则会被淘汰。

      * <p>

      */

     @Cacheable (value = "userCache" , key = "#userId" , sync = true )

     public List<UserDTO> queryUserSyncList(String userId) {

         UserDTO userDTO = userMap.get(userId);

         List<UserDTO> 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;

     }

}