Introduction
JetCache 是由阿里巴巴开源的一款通用缓存访问框架。上篇文章介绍过了 Spring Cache 的基本使用，下面我们再来了解下这款更好用的 JetCache。
引用下官方文档说明，JetCache 提供的核心能力包括：
- 提供统一的，类似jsr-107风格的API访问Cache，并可通过注解创建并配置Cache实例
- 通过注解实现声明式的方法缓存，支持TTL和两级缓存
- 分布式缓存自动刷新，分布式锁 (2.2+)
- 支持异步Cache API
- Spring Boot支持
- Key的生成策略和Value的序列化策略是可以定制的
- 针对所有Cache实例和方法缓存的自动统计
目前支持的缓存系统包括以下4个：
- Caffeine（基于本地内存）
- LinkedHashMap（基于本地内存，JetCache自己实现的简易LRU缓存）
- Alibaba Tair（相关实现未在Github开源，在阿里内部Gitlab上可以找到）
- Redis
来看个简单的使用示例：
public interface UserService {
@Cached(name="user", key="#userId", expire = 3600, cacheType = CacheType.REMOTE)
@CacheRefresh(refresh = 1800, stopRefreshAfterLastAccess = 3600, timeUnit = TimeUnit.SECONDS)
@CachePenetrationProtect
User getById(long userId);
}
是不是和 Spring Cache 很像，不过这里原生支持了细粒度的 TTL（超时时间，而 Spring Cache Redis 默认只支持配置全局的），CacheType 还有 LOCAL/REMOTE/BOTH 三种选择， 分别代表本地内存/远程 Cache Server（如Redis）/两级缓存。下面，结合 Redis 的使用，来看看更复杂的一些使用场景：
Example
首先，使用 JetCache 的环境需求包括如下：
- JDK：必须 Java 8+
- Spring Framework：v4.0.8 以上，如果不使用注解就不需要
- Spring Boot：v1.1.9 以上（可选）
- 依赖部分，示例中使用的是基于 Lettuce Redis 客户端的 Spring Boot 方式的 Starter
<dependencies>
<!-- https://mvnrepository.com/artifact/com.alicp.jetcache/jetcache-redis -->
<dependency>
<groupId>com.alicp.jetcache</groupId>
<artifactId>jetcache-starter-redis-lettuce</artifactId>
<version>2.6.0.M1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
插件这部分的配置是必需的，参考下方引用：
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.7.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<compilerArgument>-parameters</compilerArgument>
</configuration>
</plugin>
</plugins>
</build>
- 全局配置
spring:
jpa:
database-platform: org.hibernate.dialect.H2Dialect
hibernate:
ddl-auto: create
# 开启 SQL 输出，方便查看结果是否走了缓存
show-sql: true
# @see com.alicp.jetcache.autoconfigure.JetCacheProperties
jetcache:
# 统计间隔，默认0：表示不统计
statIntervalMinutes: 1
# areaName是否作为缓存key前缀，默认True
areaInCacheName: false
local:
default:
# 已支持可选：linkedhashmap、caffeine
type: linkedhashmap
# key转换器的全局配置，当前只有：fastjson, @see com.alicp.jetcache.support.FastjsonKeyConvertor
keyConvertor: fastjson
# 每个缓存实例的最大元素的全局配置，仅local类型的缓存需要指定
limit: 100
# jetcache2.2以上，以毫秒为单位，指定多长时间没有访问，就让缓存失效，当前只有本地缓存支持。0表示不使用这个功能
expireAfterAccessInMillis: 30000
remote:
default:
# 已支持可选：redis、tair
type: redis.lettuce
# 连接格式@see：https://github.com/lettuce-io/lettuce-core/wiki/Redis-URI-and-connection-details
uri: redis://localhost:6379/1?timeout=5s
keyConvertor: fastjson
# 序列化器的全局配置。仅remote类型的缓存需要指定，可选java和kryo
valueEncoder: java
valueDecoder: java
# 以毫秒为单位指定超时时间的全局配置
expireAfterWriteInMillis: 5000
- 编写实体
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Coffee implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
private String name;
private Float price;
}
public interface CoffeeRepository extends JpaRepository<Coffee, Integer> {
}
JetCache 提供了两种实现缓存的方式，可以通过 @CreateCache 注解创建 Cache 实例，这种灵活性比较高；其次是通过纯注解的方式来实现缓存。
4.1 通过 @CreateCache 注解创建 Cache 实例
@Slf4j
@Service
public class CoffeeCreateCacheService {
private static final String CACHE_NAME = "CoffeeCreateCache:";
@Resource
private CoffeeRepository coffeeRepository;
/**
* 使用 @CreateCache 注解创建Cache实例;
* 未定义默认值的参数，将使用yml中指定的全局配置;
* 缓存在 Local，也可以配置成 both 开启两级缓存
*/
@CreateCache(name = CACHE_NAME, expire = 1, localLimit = 10,
timeUnit = TimeUnit.MINUTES, cacheType = CacheType.LOCAL)
private Cache<Integer, Coffee> coffeeCache;
@Transactional
public void add(Coffee coffee) {
coffeeRepository.save(coffee);
coffeeCache.put(coffee.getId(), coffee, 3, TimeUnit.SECONDS);
}
public Optional<Coffee> get(int id) {
Coffee coffee = coffeeCache.get(id);
log.info("CoffeeCreateCache get {} res {}", id, coffee);
if (Objects.isNull(coffee)) {
Optional<Coffee> coffeeOptional = coffeeRepository.findById(id);
if (coffeeOptional.isPresent()) {
coffee = coffeeOptional.get();
boolean res = coffeeCache.putIfAbsent(id, coffee);
log.info("CoffeeCreateCache putIfAbsent {} res {}", id, res);
}
}
return Optional.ofNullable(coffee);
}
@Transactional
public Coffee update(Coffee coffee) {
Coffee c = coffeeRepository.save(coffee);
coffeeCache.put(c.getId(), c, 60, TimeUnit.SECONDS);
return c;
}
@Transactional
public void delete(int id) {
coffeeRepository.deleteById(id);
boolean res = coffeeCache.remove(id);
log.info("CoffeeCreateCache delete {} res {}", id, res);
}
}
4.2 通过注解实现方法缓存，主要是：@Cached(缓存新增)、@CacheUpdate(缓存更新)、@CacheInvalidate(缓存删除)，还有用于配置自动刷新和加载保护的“大杀器”：@CacheRefresh、@CachePenetrationProtect
@Slf4j
@Service
public class CoffeeMethodCacheService {
private static final String CACHE_NAME = "CoffeeMethodCache:";
@Resource
private CoffeeRepository coffeeRepository;
@Transactional
public Coffee add(Coffee coffee) {
return coffeeRepository.save(coffee);
}
/**
* 缓存在 Remote 的 Redis，也可以配置成 both 开启两级缓存
*/
@Cached(name = CACHE_NAME, key = "#id", cacheType = CacheType.REMOTE, serialPolicy = SerialPolicy.KRYO,
condition = "#id>0", postCondition = "result!=null")
public Coffee get(int id) {
return coffeeRepository.findById(id).orElse(null);
}
@CacheUpdate(name = CACHE_NAME, key = "#coffee.id", value = "result", condition = "#coffee.id!=null")
@Transactional
public Coffee update(Coffee coffee) {
return coffeeRepository.save(coffee);
}
@CacheInvalidate(name = CACHE_NAME, key = "#id")
@Transactional
public void delete(int id) {
coffeeRepository.deleteById(id);
}
}
- 简单测试
/**
* 这里 @EnableMethodCache，@EnableCreateCacheAnnotation 分别用于激活 @Cached 和 @CreateCache 注解
*/
@Slf4j
@EnableMethodCache(basePackages = "cn.mariojd.jetcache")
@EnableCreateCacheAnnotation
@SpringBootApplication
public class SpirngBootJetcacheApplication implements ApplicationRunner {
public static void main(String[] args) {
new SpringApplicationBuilder()
.sources(SpirngBootJetcacheApplication.class)
.bannerMode(Banner.Mode.OFF)
.web(WebApplicationType.NONE)
.run(args);
}
@Resource
private CoffeeCreateCacheService coffeeCreateCacheService;
@Resource
private CoffeeMethodCacheService coffeeMethodCacheService;
@Override
public void run(ApplicationArguments args) throws InterruptedException {
// Test Coffee create cache
Coffee latte = Coffee.builder().name("Latte").price(20.0f).build();
coffeeCreateCacheService.add(latte);
log.info("Reading from cache... {}", coffeeCreateCacheService.get(latte.getId()));
TimeUnit.SECONDS.sleep(3);
log.info("Cache expire... ");
coffeeCreateCacheService.get(latte.getId());
latte.setPrice(25.0f);
latte = coffeeCreateCacheService.update(latte);
coffeeCreateCacheService.delete(latte.getId());
// Test Coffee method cache
Coffee cappuccino = Coffee.builder().name("Cappuccino").price(30.0f).build();
coffeeMethodCacheService.add(cappuccino);
coffeeMethodCacheService.get(cappuccino.getId());
log.info("Reading from cache... {}", coffeeMethodCacheService.get(cappuccino.getId()));
cappuccino.setPrice(25.0f);
cappuccino = coffeeMethodCacheService.update(cappuccino);
coffeeMethodCacheService.delete(cappuccino.getId());
}
}
具体的可以自行运行测试，最后来看看 Redis 的 Monitor，图中红框部分说明该查询走了缓存：
Redis Monitor
参考阅读
最后，如果在使用中遇到问题，在下方的参考阅读中可以寻求答案。
JetCache wiki
JetCache introduce
示例源码
欢迎关注我的个人公众号：超级码里奥
如果这对您有帮助，欢迎点赞和分享，转载请注明出处
