【JetCache】JetCache的使用方法与步骤

快来打我* 2023-09-30 14:14 15阅读 0赞

**本文目录**

一、背景描述

二、JetCache特点与要求

2.1 JetCache的特点

2.2 JetCache的要求

三、使用步骤

3.1 spring boot 项目

3.1.1 引入依赖

3.1.2 application.yml配置

3.1.3 启动类注解

3.1.4 方法上添加注解

3.2 未使用 Spring boot 的项目

3.2.1 引入依赖

3.2.2 编写配置类

3.3 属性表

四、依赖哪个Jar？

--------------------

## 一、背景描述 ##

今天来介绍一下由 **Alibaba** 开源的一款缓存框架 **JetCache**。其号称比 **Spring Cache** 用起来更加好用，在我使用之后发现确实比较好用，步骤也非常简单。

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

## 二、JetCache特点与要求 ##

### 2.1 JetCache的特点 ###

以下简单描述一下JetCache的特点，方便在使用之前做些简单的了解：

*  通过一致的 Cache API 操作缓存。
 *  在方法上面使用注解，就可以实现 TTL 和两级缓存。
 *  使用注释创建和配置 Cache 实例。
 *  自动收集 Cache 实例和方法缓存的访问统计信息。
 *  key 生成和 value 序列化的策略可以定制。
 *  分布式缓存自动刷新和分布式锁定。（2.2）
 *  使用 Cache API 进行异步访问。（2.2版本以上，redis客户端）
 *  支持 Spring Boot。

### 2.2 JetCache的要求 ###

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

## 三、使用步骤 ##

以下案例分别为使用 spring boot 的项目，另外一个是未使用 spring boot 的项目：

### 3.1 spring boot 项目 ###

使用步骤以 **spring boot** 项目为例：

#### 3.1.1 引入依赖 ####

现在目前最新的版本是 2.7.0.M1，以后还会继续更新，如果想使用最新版本的可以去 maven 的中央仓库下载哈

<dependency>
                <groupId>com.alicp.jetcache</groupId>
                <artifactId>jetcache-starter-redis</artifactId>
                <version>2.7.0.M1</version>
            </dependency>

#### 3.1.2 application.yml配置 ####

先来张图记录一下配置，当然也可以直接从图下面的配置里粘贴，哈哈

![6225d6dc13f645c1a604de1a81b89b95.png][]

如果想直接复制粘贴的话，从下面的文本框中 cv 一下（记得修改redis的地址和用户名密码哈）即可。

jetcache:
      statIntervalMinutes: 15
      areaInCacheName: false
      local:
        default:
          type: linkedhashmap
          keyConvertor: fastjson
          limit: 1000
      remote:
        default:
          type: redis
          keyConvertor: fastjson
          valueEncoder: java
          valueDecoder: java
          poolConfig:
            minIdle: 5
            maxIdle: 20
            maxTotal: 50
          database: 16 # 连接工厂使用的数据库索引
          host: xxx # 此处需要修改哈
          port: xxx # 此处需要修改哈
          password: xxx # 此处需要修改哈

#### 3.1.3 启动类注解 ####

@EnableMethodCache(basePackages = "com.iot.back.message")

![d2546a64ddab4c1894cdae15248d79a5.png][]

#### 3.1.4 方法上添加注解 ####

expire表示返回值User对象，将在3600秒后过期，JetCache默认使用所有入参生成缓存的key。

![3e8569e06f0247b3931789f84e24f1c7.png][]

### 3.2 未使用 Spring boot 的项目 ###

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

#### 3.2.1 引入依赖 ####

<dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-anno</artifactId>
        <version>2.6.4</version>
    </dependency>
    <dependency>
        <groupId>com.alicp.jetcache</groupId>
        <artifactId>jetcache-redis</artifactId>
        <version>2.6.4</version>
    </dependency>

#### 3.2.2 编写配置类 ####

配置了这个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<Jedis> 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(Pool<Jedis> pool){
        // public GlobalCacheConfig config(SpringConfigProvider configProvider, Pool<Jedis> pool){ // for jetcache 2.5 
            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); // for jetcache 2.5
            globalCacheConfig.setLocalCacheBuilders(localBuilders);
            globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
            globalCacheConfig.setStatIntervalMinutes(15);
            globalCacheConfig.setAreaInCacheName(false);
    
            return globalCacheConfig;
        }
    }

### 3.3 属性表 ###

关于配置文件和注解里的每个字段含义详情请移步另一篇文章，特别详细的说明解释[【JetCache】JetCache的配置说明和注解属性说明][JetCache_JetCache]

@Cached注解和@CreateCache的属性非常类似，但是多几个：

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>默认值</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>area</td> 
   <td>“default”</td> 
   <td>如果在配置中配置了多个缓存area，在这里指定使用哪个area</td> 
  </tr> 
  <tr> 
   <td>name</td> 
   <td>未定义</td> 
   <td>指定缓存的唯一名称，不是必须的，如果没有指定，会使用类名+方法名。name会被用于远程缓存的key前缀。另外在统计中，一个简短有意义的名字会提高可读性。</td> 
  </tr> 
  <tr> 
   <td>key</td> 
   <td>未定义</td> 
   <td>使用<a href="https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/expressions.html" title="SpEL" rel="nofollow">SpEL</a>指定key，如果没有指定会根据所有参数自动生成。</td> 
  </tr> 
  <tr> 
   <td>expire</td> 
   <td>未定义</td> 
   <td>超时时间。如果注解上没有定义，会使用全局配置，如果此时全局配置也没有定义，则为无穷大</td> 
  </tr> 
  <tr> 
   <td>timeUnit</td> 
   <td>TimeUnit.SECONDS</td> 
   <td>指定expire的单位</td> 
  </tr> 
  <tr> 
   <td>cacheType</td> 
   <td>CacheType.REMOTE</td> 
   <td>缓存的类型，包括CacheType.REMOTE、CacheType.LOCAL、CacheType.BOTH。如果定义为BOTH，会使用LOCAL和REMOTE组合成两级缓存</td> 
  </tr> 
  <tr> 
   <td>localLimit</td> 
   <td>未定义</td> 
   <td>如果cacheType为LOCAL或BOTH，这个参数指定本地缓存的最大元素数量，以控制内存占用。如果注解上没有定义，会使用全局配置，如果此时全局配置也没有定义，则为100</td> 
  </tr> 
  <tr> 
   <td>localExpire</td> 
   <td>未定义</td> 
   <td>仅当cacheType为BOTH时适用，为内存中的Cache指定一个不一样的超时时间，通常应该小于expire</td> 
  </tr> 
  <tr> 
   <td>serialPolicy</td> 
   <td>未定义</td> 
   <td>指定远程缓存的序列化方式。可选值为SerialPolicy.JAVA和SerialPolicy.KRYO。如果注解上没有定义，会使用全局配置，如果此时全局配置也没有定义，则为SerialPolicy.JAVA</td> 
  </tr> 
  <tr> 
   <td>keyConvertor</td> 
   <td>未定义</td> 
   <td>指定KEY的转换方式，用于将复杂的KEY类型转换为缓存实现可以接受的类型，当前支持KeyConvertor.FASTJSON和KeyConvertor.NONE。NONE表示不转换，FASTJSON可以将复杂对象KEY转换成String。如果注解上没有定义，会使用全局配置。</td> 
  </tr> 
  <tr> 
   <td>enabled</td> 
   <td>true</td> 
   <td>是否激活缓存。例如某个dao方法上加缓存注解，由于某些调用场景下不能有缓存，所以可以设置enabled为false，正常调用不会使用缓存，在需要的地方可使用CacheContext.enableCache在回调中激活缓存，缓存激活的标记在ThreadLocal上，该标记被设置后，所有enable=false的缓存都被激活</td> 
  </tr> 
  <tr> 
   <td>cacheNullValue</td> 
   <td>false</td> 
   <td>当方法返回值为null的时候是否要缓存</td> 
  </tr> 
  <tr> 
   <td>condition</td> 
   <td>未定义</td> 
   <td>使用<a href="https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/expressions.html" title="SpEL" rel="nofollow">SpEL</a>指定条件，如果表达式返回true的时候才去缓存中查询</td> 
  </tr> 
  <tr> 
   <td>postCondition</td> 
   <td>未定义</td> 
   <td>使用<a href="https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/expressions.html" title="SpEL" rel="nofollow">SpEL</a>指定条件，如果表达式返回true的时候才更新缓存，该评估在方法执行后进行，因此可以访问到#result</td> 
  </tr> 
 </tbody> 
</table>

## 四、依赖哪个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。

参考文档：[《JetCache官方文档》][JetCache]

完结！

[6225d6dc13f645c1a604de1a81b89b95.png]: https://img-blog.csdnimg.cn/6225d6dc13f645c1a604de1a81b89b95.png
[d2546a64ddab4c1894cdae15248d79a5.png]: https://img-blog.csdnimg.cn/d2546a64ddab4c1894cdae15248d79a5.png
[3e8569e06f0247b3931789f84e24f1c7.png]: https://img-blog.csdnimg.cn/3e8569e06f0247b3931789f84e24f1c7.png
[JetCache_JetCache]: https://blog.csdn.net/weixin_44299027/article/details/125569910
[JetCache]: https://github.com/alibaba/jetcache/wiki/Home_CN