简介

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支持

要求

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

创建缓存实例

通过@CreateCache注解创建一个缓存实例，默认超时时间是100秒

@CreateCache(expire = 100)

private Cache userCache;

用起来就像map一样

UserDO user = userCache.get(123L);

userCache.put(123L, user);

userCache.remove(123L);

创建一个两级（内存+远程）的缓存，内存中的元素个数限制在50个。

@CreateCache(name = "UserService.userCache", expire = 100, cacheType = CacheType.BOTH, localLimit = 50)

private Cache userCache;

name属性不是必须的，但是起个名字是个好习惯，展示统计数据的使用，会使用这个名字。如果同一个area两个@CreateCache的name配置一样，它们生成的Cache将指向同一个实例。

创建方法缓存

使用@Cached方法可以为一个方法添加上缓存。JetCache通过Spring AOP生成代理，来支持缓存功能。注解可以加在接口方法上也可以加在类方法上，但需要保证是个Spring bean。

public interface UserService {

@Cached(name="UserService.getUserById", expire = 3600)

User getUserById(long userId);

}

基本配置（使用Spring Boot）

如果使用Spring Boot，可以按如下的方式配置（这里使用了jedis客户端连接redis，如果需要集群、读写分离、异步等特性支持请使用lettuce客户端）。

POM

com.alicp.jetcache

jetcache-starter-redis

2.5.11

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

jetcache:

statIntervalMinutes: 15

areaInCacheName: false

local:

default:

type: linkedhashmap

keyConvertor: fastjson

remote:

default:

type: redis

keyConvertor: fastjson

valueEncoder: java

valueDecoder: java

poolConfig:

minIdle: 5

maxIdle: 20

maxTotal: 50

host: 127.0.0.1

port: 6379

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

package com.company.mypackage;

import com.alicp.jetcache.anno.config.EnableCreateCacheAnnotation;

import com.alicp.jetcache.anno.config.EnableMethodCache;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

@EnableMethodCache(basePackages = "com.company.mypackage")

@EnableCreateCacheAnnotation

public class MySpringBootApp {

public static void main(String[] args) {

SpringApplication.run(MySpringBootApp.class);

}

}

未使用SpringBoot的配置方式

如果没有使用spring boot，可以按下面的方式配置（这里使用jedis客户端连接redis为例）。

com.alicp.jetcache

jetcache-anno

2.5.11

com.alicp.jetcache

jetcache-redis

2.5.11

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

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;

}

}