JetCache简介以及配置说明

简介

JetCache是一个基于java的缓存系统封装，提供统一的API和注解简化缓存的使用。JetCache提供了比SpringCache更强大的注解，可以原生的支持TTL、两级缓存、分布式自动刷新，提供了Cache接口用于手工缓存操作。当前有四个实现，RedisCache、TairCache、CaffeineCache和一个简易的LinkedHashMapCache，要添加新的实现也是非常简单。它的特性：

• 通过统一的API访问Cache系统
• 通过注解实现声明式的方法缓存
• 通过注解创建并配置Cache实例
• 针对所有Cache实例和方法缓存的自动统计
• Key的生成策略和value的序列化策略是可以配置的
• 分布式缓存自动刷新，分布式锁
• 异步Cache API
• Spring Boot支持

要求

JetCache需要JDK1.8、Spring Framework4.0.8以上版本。Spring Boot为可选，需要1.1.9以上版本。如果不使用注解（仅使用jetcache-core），Spring Framework也是可选的，此时使用方式与Guava/Caffeine cache类似。

依赖jar包

• jetcache-anno-api：定义jetcache的注解和常量，不传递依赖。如果你想把Cached注解加到接口上，又不希望你的接口jar传递太多依赖，可以让接口jar依赖jetcache-anno-api。
• jetcache-core：核心api，完全通过编程来配置操作Cache，不依赖Spring。两个内存中的缓存实现LinkedHashMapCache和CaffeineCache也由它提供。
• jetcache-anno：基于Spring提供@Cached和@CreateCache注解支持。
• jetcache-redis：使用jedis提供Redis支持。
• jetcache-redis-lettuce（需要JetCache2.3以上版本）：使用lettuce提供Redis支持，实现了JetCache异步访问缓存的的接口。
• jetcache-starter-redis：Spring Boot方式的Starter，基于Jedis。
• jetcache-starter-redis-lettuce（需要JetCache2.3以上版本）：Spring Boot方式的Starter，基于Lettuce。

配置说明

（1）基于SpringBoot的yml配置文件案例

jetcache:
  statIntervalMinutes: 15                 //统一间隔
  areaInCacheName: false                  //设置不把areaName作为Key前缀
  hiddenPackages: com.alibaba   //如果@Cached和@CreateCache的name是自动生成的，会默认的将包
                              //名和方法名作为前缀，为了不让name太长，该设置时将制定的包名截掉
  local:
    default:
      type: caffeine                //缓存类型
      limit: 100                    //
      keyConvertor: fastjson        //Key转换器的全局变量
      expireAfterWriteInMillis: 100000
    otherArea:
      type: linkedhashmap
      limit: 100
      keyConvertor: none
      expireAfterWriteInMillis: 100000
  remote:
    default:
      type: redis
      keyConvertor: fastjson
      valueEncoder: java
      valueDecoder: java
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      host: ${redis.host}
      port: ${redis.port}
    otherArea:
      type: redis
      keyConvertor: fastjson
      valueEncoder: kryo
      valueDecoder: kryo
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      host: ${redis.host}
      port: ${redis.port}

配置说明如下： 

 

属性	默认值	说明
jetcache.statIntervalMinutes	0	间隔时间，0表示不统计
jetcache.areaInCacheName	true	jetcache-anno把cacheName作为远程缓存key前缀，2.4.3以前的版本总是把areaName加在cacheName中，因此areaName也出现在key前缀中。2.4.4以后可以配置，为了保持远程key兼容默认值为true，但是新项目的话false更合理些。
jetcache.hiddenPackages	无	@Cached和@CreateCache自动生成name的时候，为了不让name太长，hiddenPackages指定的包名前缀被截掉
jetcache.[local|remote].${area}.type	无	缓存类型，tair、redis为当前支持的远程缓存，linkedhashmap、caffeine为当前支持的本地缓存类型
jetcache.[local|remote].${area}.keyConvertor	无	key转换器的全局配置，当前只有一个已经实现的keyConvertor：fastjson。仅当使用@CreateCache且缓存类型为LOCAL是可以指定为none，此时通过equals方法来识别key。方法缓存必须指定keyConvertor
jetcache.[local|remote].${area}.valueEncoder	java	序列化器的全局配置。仅remote类型的缓存需要指定，可选java和kryo
jetcache.[local|remote].${area}.valueDecoder	java	序列化器的全局配置。仅remote类型的缓存需要指定，可选java和kryo
jetcache.[local|remote].${area}.limit	100	每个缓存实例的最大元素的全局配置，仅local类型的缓存需要指定。注意是每个缓存实例的限制，而不是全部
jetcache.[local|remote].${area}.expireAfterWriteInMillis	无穷大	以毫秒为单位指定超时时间的全局配置，以前为defaultExpireInMillis
jetcache.local.${area}.expireAfterAccessInMillis	0	需要jetcache2.2以上，以毫秒为单位，指定多长时间没有访问，就让缓存失效，当前只有本地缓存支持。0表示不使用这个功能。

上表中${area}对应@Cached和@CreateCache的area属性。注意如果注解上没有指定area，默认值是"default"。

关于缓存的超时时间，有多个地方指定，澄清说明一下：

1. put等方法上指定了超时时间，则以此时间为准
2. put等方法上未指定超时时间，使用Cache实例的默认超时时间
3. Cache实例的默认超时时间，通过在@CreateCache和@Cached上的expire属性指定，如果没有指定，使用yml中定义的全局配置，例如@Cached(cacheType=local)使用jetcache.local.default.expireAfterWriteInMillis，如果仍未指定则是无穷大

keyConvertor：是将key的值转换成Json格式显示,代码实现如下：

AbstractEmbeddedCache.java

 public Object buildKey(K key) {
        if (key == null) {
            return null;
        }
        Object newKey = key;
        Function keyConvertor = config.getKeyConvertor();
        if (keyConvertor != null) {
            newKey = keyConvertor.apply(key);
        }
        return newKey;
    }


FastjsonKeyConvertor.java

 public Object apply(Object originalKey) {
        if (originalKey == null) {
            return null;
        }
        if (originalKey instanceof String) {
            return originalKey;
        }
        return JSON.toJSONString(originalKey);
    }

（2）不使用springBoot，基于Spring的配置如下：

直接创建JetCacheConfig类对属性进行配置

package com.company.mypackage;

import java.util.HashMap;
import java.util.Map;

import com.alicp.jetcache.anno.CacheConsts;
import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;
import com.alicp.jetcache.anno.config.EnableMethodCache;
import com.alicp.jetcache.anno.support.GlobalCacheConfig;
import com.alicp.jetcache.anno.support.SpringConfigProvider;
import com.alicp.jetcache.embedded.EmbeddedCacheBuilder;
import com.alicp.jetcache.embedded.LinkedHashMapCacheBuilder;
import com.alicp.jetcache.redis.RedisCacheBuilder;
import com.alicp.jetcache.support.FastjsonKeyConvertor;
import com.alicp.jetcache.support.JavaValueDecoder;
import com.alicp.jetcache.support.JavaValueEncoder;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.util.Pool;

@Configuration
@EnableMethodCache(basePackages = "com.company.mypackage")
@EnableCreateCacheAnnotation
public class JetCacheConfig {

    @Bean
    public Pool pool(){
        GenericObjectPoolConfig pc = new GenericObjectPoolConfig();
        pc.setMinIdle(2);
        pc.setMaxIdle(10);
        pc.setMaxTotal(10);
        return new JedisPool(pc, "localhost", 6379);
    }

    @Bean
    public SpringConfigProvider springConfigProvider() {
        return new SpringConfigProvider();
    }

    @Bean
    public GlobalCacheConfig config(SpringConfigProvider configProvider, Pool pool){
        Map localBuilders = new HashMap();
        EmbeddedCacheBuilder localBuilder = LinkedHashMapCacheBuilder
                .createLinkedHashMapCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE);
        localBuilders.put(CacheConsts.DEFAULT_AREA, localBuilder);

        Map remoteBuilders = new HashMap();
        RedisCacheBuilder remoteCacheBuilder = RedisCacheBuilder.createRedisCacheBuilder()
                .keyConvertor(FastjsonKeyConvertor.INSTANCE)
                .valueEncoder(JavaValueEncoder.INSTANCE)
                .valueDecoder(JavaValueDecoder.INSTANCE)
                .jedisPool(pool);
        remoteBuilders.put(CacheConsts.DEFAULT_AREA, remoteCacheBuilder);

        GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
        globalCacheConfig.setConfigProvider(configProvider);
        globalCacheConfig.setLocalCacheBuilders(localBuilders);
        globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
        globalCacheConfig.setStatIntervalMinutes(15);
        globalCacheConfig.setAreaInCacheName(false);

        return globalCacheConfig;
    }
}

如何快速使用：https://blog.csdn.net/m0_37637141/article/details/82417230

详细内容可以查看jetCache 官方wiki文档：https://github.com/alibaba/jetcache/wiki