JetCache是一个基于Java的缓存系统封装，提供统一的API和注解来简化缓存的使用。 JetCache提供了比SpringCache更加强大的注解，可以原生的支持TTL、两级缓存、分布式自动刷新，还提供了Cache接口用于手工缓存操作。
当前有四个实现，RedisCache、TairCache（此部分未在github开源）、CaffeineCache(in memory)和一个简易的LinkedHashMapCache(in memory)，要添加新的实现也是非常简单的。

全部特性:

  • 通过统一的API访问Cache系统
  • 通过注解实现声明式的方法缓存，支持TTL和两级缓存
  • 通过注解创建并配置Cache实例
  • 针对所有Cache实例和方法缓存的自动统计
  • Key的生成策略和Value的序列化策略是可以配置的
  • 分布式缓存自动刷新，分布式锁 (2.2+)
  • 异步Cache API (2.2+，使用Redis的lettuce客户端时)
  • Spring Boot支持

    创建缓存实例

    1. @CreateCache(expire = 100)
    2. private Cache<Long, UserDO> userCache;
    创建一个两级（内存+远程）的缓存，内存中的元素个数限制在50个。
    1. @CreateCache(name = "UserService.userCache", expire = 100, cacheType = CacheType.BOTH, localLimit = 50)
    2. private Cache<Long, UserDO> userCache;

    @CreateCache属性表

    | 属性 | 默认值 | 说明 | | —- | —- | —- | | area | “default” | 如果需要连接多个缓存系统，可在配置多个cache area，这个属性指定要使用的那个area的name | | name | 未定义 | 指定缓存的名称，不是必须的，如果没有指定，会使用类名+方法名。name会被用于远程缓存的key前缀。另外在统计中，一个简短有意义的名字会提高可读性。如果两个@CreateCache的name和area相同，它们会指向同一个Cache实例 | | expire | 未定义 | 该Cache实例的默认超时时间定义，注解上没有定义的时候会使用全局配置，如果此时全局配置也没有定义，则取无穷大 | | timeUnit | TimeUnit.SECONDS | 指定expire的单位 | | cacheType | CacheType.REMOTE | 缓存的类型，包括CacheType.REMOTE、CacheType.LOCAL、CacheType.BOTH。如果定义为BOTH，会使用LOCAL和REMOTE组合成两级缓存 | | localLimit | 未定义 | 如果cacheType为CacheType.LOCAL或CacheType.BOTH，这个参数指定本地缓存的最大元素数量，以控制内存占用。注解上没有定义的时候会使用全局配置，如果此时全局配置也没有定义，则取100 | | serialPolicy | 未定义 | 如果cacheType为CacheType.REMOTE或CacheType.BOTH，指定远程缓存的序列化方式。JetCache内置的可选值为SerialPolicy.JAVA和SerialPolicy.KRYO。注解上没有定义的时候会使用全局配置，如果此时全局配置也没有定义，则取SerialPolicy.JAVA | | keyConvertor | 未定义 | 指定KEY的转换方式，用于将复杂的KEY类型转换为缓存实现可以接受的类型，JetCache内置的可选值为KeyConvertor.FASTJSON和KeyConvertor.NONE。NONE表示不转换，FASTJSON通过fastjson将复杂对象KEY转换成String。如果注解上没有定义，则使用全局配置。 |

基本配置（使用Spring Boot）

  1. <dependency>
  2.     <groupId>com.alicp.jetcache</groupId>
  3.     <artifactId>jetcache-starter-redis</artifactId>
  4.     <version>2.6.4</version>
  5. </dependency>

配置一个spring boot风格的application.yml文件，把他放到资源目录中

  1. jetcache:
  2.   statIntervalMinutes: 15
  3.   areaInCacheName: false
  4.   local:
  5.     default:
  6.       type: linkedhashmap
  7.       keyConvertor: fastjson
  8.   remote:
  9.     default:
  10.       type: redis
  11.       keyConvertor: fastjson
  12.       valueEncoder: java
  13.       valueDecoder: java
  14.       poolConfig:
  15.         minIdle: 5
  16.         maxIdle: 20
  17.         maxTotal: 50
  18.       host: 127.0.0.1
  19.       port: 6379

然后创建一个App类放在业务包的根下，EnableMethodCache，EnableCreateCacheAnnotation这两个注解分别激活Cached和CreateCache注解，其他和标准的Spring Boot程序是一样的。这个类可以直接main方法运行。

  1. package com.company.mypackage;
  3. import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
  4. import com.alicp.jetcache.anno.config.EnableMethodCache;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  8. @SpringBootApplication
  9. @EnableMethodCache(basePackages = "com.company.mypackage")
  10. @EnableCreateCacheAnnotation
  11. public class MySpringBootApp {
  12.     public static void main(String[] args) {
  13.         SpringApplication.run(MySpringBootApp.class);
  14.     }
  15. }

未使用SpringBoot的配置方式

pom

  1. <dependency>
  2.     <groupId>com.alicp.jetcache</groupId>
  3.     <artifactId>jetcache-anno</artifactId>
  4.     <version>2.6.4</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.alicp.jetcache</groupId>
  8.     <artifactId>jetcache-redis</artifactId>
  9.     <version>2.6.4</version>
  10. </dependency>

配置了这个JetCacheConfig类以后，可以使用@CreateCache和@Cached注解。

  1. package com.company.mypackage;
  3. import java.util.HashMap;
  4. import java.util.Map;
  6. import com.alicp.jetcache.anno.CacheConsts;
  7. import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
  8. import com.alicp.jetcache.anno.config.EnableMethodCache;
  9. import com.alicp.jetcache.anno.support.GlobalCacheConfig;
  10. import com.alicp.jetcache.anno.support.SpringConfigProvider;
  11. import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
  12. import com.alicp.jetcache.embedded.LinkedHashMapCacheBuilder;
  13. import com.alicp.jetcache.redis.RedisCacheBuilder;
  14. import com.alicp.jetcache.support.FastjsonKeyConvertor;
  15. import com.alicp.jetcache.support.JavaValueDecoder;
  16. import com.alicp.jetcache.support.JavaValueEncoder;
  17. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  18. import org.springframework.context.annotation.Bean;
  19. import org.springframework.context.annotation.Configuration;
  20. import redis.clients.jedis.Jedis;
  21. import redis.clients.jedis.JedisPool;
  22. import redis.clients.util.Pool;
  24. @Configuration
  25. @EnableMethodCache(basePackages = "com.company.mypackage")
  26. @EnableCreateCacheAnnotation
  27. public class JetCacheConfig {
  29.     @Bean
  30.     public Pool<Jedis> pool(){
  31.         GenericObjectPoolConfig pc = new GenericObjectPoolConfig();
  32.         pc.setMinIdle(2);
  33.         pc.setMaxIdle(10);
  34.         pc.setMaxTotal(10);
  35.         return new JedisPool(pc, "localhost", 6379);
  36.     }
  38.     @Bean
  39.     public SpringConfigProvider springConfigProvider() {
  40.         return new SpringConfigProvider();
  41.     }
  43.     @Bean
  44.     public GlobalCacheConfig config(Pool<Jedis> pool){
  45.     // public GlobalCacheConfig config(SpringConfigProvider configProvider, Pool<Jedis> pool){ // for jetcache 2.5 
  46.         Map localBuilders = new HashMap();
  47.         EmbeddedCacheBuilder localBuilder = LinkedHashMapCacheBuilder
  48.                 .createLinkedHashMapCacheBuilder()
  49.                 .keyConvertor(FastjsonKeyConvertor.INSTANCE);
  50.         localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);
  52.         Map remoteBuilders = new HashMap();
  53.         RedisCacheBuilder remoteCacheBuilder = RedisCacheBuilder.createRedisCacheBuilder()
  54.                 .keyConvertor(FastjsonKeyConvertor.INSTANCE)
  55.                 .valueEncoder(JavaValueEncoder.INSTANCE)
  56.                 .valueDecoder(JavaValueDecoder.INSTANCE)
  57.                 .jedisPool(pool);
  58.         remoteBuilders.put(CacheConsts.DEFAULT_AREA, remoteCacheBuilder);
  60.         GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
  61.         // globalCacheConfig.setConfigProvider(configProvider); // for jetcache 2.5
  62.         globalCacheConfig.setLocalCacheBuilders(localBuilders);
  63.         globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
  64.         globalCacheConfig.setStatIntervalMinutes(15);
  65.         globalCacheConfig.setAreaInCacheName(false);
  67.         return globalCacheConfig;
  68.     }
  69. }