学习之-JetCacheJava缓存框架最全详解

已于 2023-05-31 11:48:25 修改
阅读量8.3k 收藏 31
点赞数 12
分类专栏： 缓存 文章标签： 学习 缓存 java redis
于 2023-05-11 17:45:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alice_qixin/article/details/130621612
版权

目录

jetcache官方源码:

一、JetCache介绍

1.1 诞生

1.2 整合-开源界大放异彩

1.3 挑战-SpringCache江湖地位

1.4 JetCache核心特性和优势

2.1 使用要求

2.2 项目代码介绍

二、JetCache核心注解

@Cached注解说明

@CacheRefresh注解说明：

@CacheInvalidate注解说明：

@CacheUpdate注解说明：

@CachePenetrationProtect注解：

三、JetCache接入配置

1、依赖哪个jar？

2、官方-Springboot 项目配置

3、官方-未使用Springboot 的项目配置

本地缓存-LinkedHashMapCache

本地缓存-caffeine

统计

官网信息

官方配置

logback日志输出配置

4、适配公司sedis客户端-未使用Springboot 的项目配置

指标的解读

jetcache官方源码:

github：GitHub - alibaba/jetcache: JetCache is a Java cache framework.

官方文档：Home · alibaba/jetcache Wiki · GitHub

一、JetCache介绍

1.1 诞生

2013年

JetCache诞生于 [ 阿里彩票 ]，作者是 [ huangli ] 凭借得天独厚的Tair支持和丰富的Spring生态注解支持，赢得了大家的喜爱。
2015年随着SpringBoot的大热和集团内PandoraBoot的彻底铺开，JetCache以Starter的形式实现了扩展，优化了配置项，在架构设计和性能上更上一层楼。
2015年同年JetCache开源至Github，作为alibaba的开源缓存框架，其易用性和设计先进性吸引了大批国内外用户，截止当前在github上累计3.7k star，870 fork。
2018年JetCache最大版本更新，对整体的设计进行了调整，修改了默认的序列化方式，集成支持了SpringData，RedisLettuce，Redisson等更加高效以及功能更加灵活且高级的三方SDK。

1.2 整合-开源界大放异彩

支持范围方面JetCache原生支持的远程缓存是Tair，但是Tair在集团外并不可用。JetCache为了拥抱开源，实现了时下主流的GuavaCache, CaffeineCache,  Redis，MemCache基本覆盖了国内的主流缓存中间件
在功能性方面JetCache满足了用户一行注解解决Method缓存的刚需，同时也能通过叠加注解的方式非常高效的处理缓存穿透，缓存击穿，缓存雪崩，缓存失效等经典分布式缓存的问题，这让用户充分体验到了缓存框架的效率优势和设计先进性。
在扩展性方面JetCache满足了用户一行注解解决Method缓存的刚需，也提供了优秀的扩展能力。想要实现一个新的Cache类型，只需要实现AbstractEmbeddedCache或者AbstractExternalCache就可以以非常低廉的成本实现一个新的缓存框架。

1.3 挑战-SpringCache江湖地位

对比SpringCacheJetCache
出身

在2015年最火的框架是SpringBoot，SpringBoot提供了非常丰富的组件支持以及模块化的组件管理，其中就包括基于JSR-107–JCacheAPI实现的SpringCache框架。

JetCache是阿里推出的一套替代springcache的缓存方案。JetCache是对SpringCache进行了封装。在阿里实际业务应用实战后开源的缓存框架
依赖性SpringCache 是 Spring 框架自带的缓存框架JetCache 是独立的缓存框架，不依赖于任何框架。
使用方式SpringCache 集成于 Spring 框架中，使用起来比较简单，只需要在代码中添加注解即可JetCache 需要手动引入依赖并配置相关参数，使用起来相对复杂一些
分布式

SpringCache框架很好的实现了JCacheAPI，在当时占据了非常有力的位置，几乎所有的SpringBoot初创项目，都选择了使用SpringCache来作为他们的第一个缓存框架。但随着软件工程的规模越来越大，分布式场景的经典问题也接踵而至，显然SpringCache在应对分布式环境的经典问题时显得太过于稚嫩。

对于分布式场景， 分布式锁，缓存穿透，缓存击穿，缓存雪崩 等经典问题，缺少足够成熟的方案。

在SpringCache基础上实现了多级缓存、缓存统计、自动刷新（防止某个缓存失效，突然访问量增大，导致数据库挂掉的缓存雪崩）、异步调用、数据报表等功能。

支持分布式锁，JetCache提供了分布式锁和分布式计数器等功能，以支持分布式环境下的并发控制。

缓存层级仅支持一级缓存，与提供了基本的缓存功能

支持多级缓存滑动窗口，缓存序列化，异步API支持等实际工作场景经常会需要用到的核心能力

支持多种缓存策略，包括基于时间的过期策略、基于LRU算法的自动清理策略、基于手动清理的策略等。此外，

扩展性方面对于扩展性上，设计的不够开放和正交，很难低成本的完成一些高级功能的扩展。在迁移缓存方面基本上可以做到换注解平替，所以一旦工程规模达到一定量级，很多架构师会选择从SpringCache的方式切换到JetCache上。
总体来说，如果需要更高级的缓存特性，或者需要更好的性能表现，可以选择 JetCache。如果只需要基本的缓存功能，或者已经使用了 Spring 框架，可以选择 SpringCache。

1.4 JetCache核心特性和优势

etCache设定了本地缓存与远程缓存的多级缓存方案：

提供统一的，类似jsr-107风格的API访问Cache，并可通过注解创建并配置Cache实例

支持多种缓存类型JetCache支持多种缓存类型，包括本地缓存、远程缓存和分布式缓存，可以根据业务需求选择合适的缓存类型。
支持多种缓存协议JetCache支持多种缓存协议，包括Redis、Memcached、Couchbase等，可以与多种缓存系统进行集成。可选择内存缓存、分布式缓存，或者同时存在，同时存在时优先访问内存
支持多种缓存策略JetCache支持多种缓存策略，包括FIFO、LRU、LFU等，可以根据业务需求选择合适的缓存策略。
支持注解和编程式缓存JetCache支持注解和编程式缓存，可以根据业务需求选择合适的缓存方式。
支持分布式事务JetCache支持分布式事务，可以保证缓存和数据库的一致性。分布式缓存自动刷新，分布式锁 (2.2+)
支持缓存监控和统计JetCache支持缓存监控和统计，可以实时查看缓存的使用情况和性能指标
易于使用和扩展JetCache具有简单易用的API和灵活的扩展机制，可以方便地集成到各种应用中。Key的生成策略和Value的序列化策略是可以定制的、支持异步Cache API

2.1 使用要求

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

2.2 项目代码介绍

JSR-107--缓存JCache标准抽象实

Java在2012的JSR-107协议中新增了关于缓存的抽象设计标准–JCache。

JetCache2.0的核心是com.alicp.jetcache.Cache接口（以下简写为Cache），它提供了部分类似于javax.cache.Cache（JSR107）的API操作。没有完整实现JSR107的原因包括：

  1. 希望维持API的简单易用。
  2. 对于特定的远程缓存系统来说，javax.cache.Cache中定义的有些操作无法高效率的实现，比如一些原子操作方法和类似removeAll()这样的方法。
  3. JSR107比较复杂，完整实现要做的工作很多。

丰富注解-无侵入抽象设计


二、JetCache核心注解

JetCache方法缓存和SpringCache比较类似，它原生提供了TTL支持，以保证最终一致，并且支持二级缓存。JetCache2.4以后支持基于注解的缓存更新和删除。

在spring环境下，使用@Cached注解可以为一个方法添加缓存，@CacheUpdate用于更新缓存，@CacheInvalidate用于移除缓存元素。注解可以加在接口上也可以加在类上，加注解的类必须是一个spring bean，例如：

public interface UserService {
    @Cached(name="userCache.", key="#userId", expire = 3600)
    User getUserById(long userId);
 
    @CacheUpdate(name="userCache.", key="#user.userId", value="#user")
    void updateUser(User user);
 
    @CacheInvalidate(name="userCache.", key="#userId")
    void deleteUser(long userId);
}

@Cached注解说明

  1. 在方法上添加 @Cached 注解，指定缓存的 key 和过期时间等参数。

  2. 当方法被调用时，JetCache 会先从缓存中查找对应的数据。

  3. 如果缓存中存在数据，则直接返回缓存中的数据，不再执行方法体。

  4. 如果缓存中不存在数据，则执行方法体，并将方法的返回值存入缓存中。

  5. 后续调用该方法时，将直接从缓存中获取数据，不再执行方法体。

  6. 缓存的过期时间到达后，缓存数据将被自动清除，下次调用该方法将重新执行方法体并更新缓存数据。

JetCache 支持多种缓存类型，包括本地内存缓存、Redis 缓存、Caffeine 缓存等，可以根据实际需求进行配置。同时，JetCache 还提供了缓存预热、缓存穿透、缓存雪崩等解决方案，以提高缓存的效率和稳定性。

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

属性默认值备注
area“default”如果在配置中配置了多个缓存area，在这里指定使用哪个area
name未定义指定缓存的唯一名称，不是必须的，如果没有指定，会使用类名+方法名。name会被用于远程缓存的key前缀。另外在统计中，一个简短有意义的名字会提高可读性。
key未定义使用SpEL指定key，如果没有指定会根据所有参数自动生成。
expire未定义超时时间。如果注解上没有定义，会使用全局配置，如果此时全局配置也没有定义，则为无穷大
timeUnitTimeUnit.SECONDS指定expire的单位
cacheTypeCacheType.REMOTE缓存的类型，包括CacheType.REMOTE、CacheType.LOCAL、CacheType.BOTH。如果定义为BOTH，会使用LOCAL和REMOTE组合成两级缓存
localLimit未定义

如果cacheType为LOCAL或BOTH，这个参数指定本地缓存的最大元素数量，以控制内存占用。如果注解上没有定义，会使用全局配置，如果此时全局配置也没有定义，则为100，参数 localLimit 表示本地缓存的最大条目限制。当使用 JetCache 的本地缓存功能时，localLimit 参数可以控制本地缓存中最多缓存的条目数量，如果超过了这个数量，将会按照 LRU（Least Recently Used）算法删除最近最少使用的缓存条目，以保持缓存的大小在限制范围内。localLimit 默认值为 100条，可以通过设置该值来优化缓存性能和内存使用。

备注：当type为LOCAL时，配置localLimit，当key值超出限制条件，会删除最少使用的条目，重新请求缓存过的，会走到db再缓存一次。

当type为BOTH时，虽然配置了localLimit 当key值超出限制条件，本地会删除使用最少得条目，但是远程还有缓存，查询缓存时是优先查询本地，没有再去远程，都没有再走db，将查询结果进行一次缓存。如果配置BOTH时，可以配置该项减少本地内存使用，但是不影响缓存整体使用因为有远程兜底。

localExpire未定义仅当cacheType为BOTH时适用，为内存中的Cache指定一个不一样的超时时间，通常应该小于expire
serialPolicy未定义指定远程缓存的序列化方式。可选值为SerialPolicy.JAVA和SerialPolicy.KRYO。如果注解上没有定义，会使用全局配置，如果此时全局配置也没有定义，则为SerialPolicy.JAVA
keyConvertor未定义指定KEY的转换方式，用于将复杂的KEY类型转换为缓存实现可以接受的类型，当前支持KeyConvertor.FASTJSON和KeyConvertor.NONE。NONE表示不转换，FASTJSON可以将复杂对象KEY转换成String。如果注解上没有定义，会使用全局配置。
enabledtrue是否激活缓存。例如某个dao方法上加缓存注解，由于某些调用场景下不能有缓存，所以可以设置enabled为false，正常调用不会使用缓存，在需要的地方可使用CacheContext.enableCache在回调中激活缓存，缓存激活的标记在ThreadLocal上，该标记被设置后，所有enable=false的缓存都被激活
cacheNullValuefalse当方法返回值为null的时候是否要缓存
condition未定义使用SpEL指定条件，如果表达式返回true的时候才去缓存中查询
postCondition未定义使用SpEL指定条件，如果表达式返回true的时候才更新缓存，该评估在方法执行后进行，因此可以访问到#result

@CacheRefresh注解说明：

（强制刷新即使缓存结果未到时效时间）

属性

默认值

说明

refresh未定义刷新间隔
timeUnitTimeUnit.SECONDS时间单位
stopRefreshAfterLastAccess未定义指定该key多长时间没有访问就停止刷新，如果不指定会一直刷新
refreshLockTimeout60秒类型为BOTH/REMOTE的缓存刷新时，同时只会有一台服务器在刷新，这台服务器会在远程缓存放置一个分布式锁，此配置指定该锁的超时时间

@CacheInvalidate注解说明：

属性

默认值

说明

area“default”如果在配置中配置了多个缓存area，在这里指定使用哪个area，指向对应的@Cached定义。
name未定义指定缓存的唯一名称，指向对应的@Cached定义。
key未定义使用SpEL指定key
condition未定义使用SpEL指定条件，如果表达式返回true才执行删除，可访问方法结果#result

@CacheUpdate注解说明：

属性

默认值

说明

area“default”如果在配置中配置了多个缓存area，在这里指定使用哪个area，指向对应的@Cached定义。
name未定义指定缓存的唯一名称，指向对应的@Cached定义。
key未定义使用SpEL指定key
value未定义使用SpEL指定value
condition未定义

使用SpEL指定条件，如果表达式返回true才执行更新，可访问方法结果#result

使用@CacheUpdate和@CacheInvalidate的时候，相关的缓存操作可能会失败（比如网络IO错误），所以指定缓存的超时时间是非常重要的。

@CachePenetrationProtect注解：

当缓存访问未命中的情况下，对并发进行的加载行为进行保护。 当前版本实现的是单JVM内的保护，即同一个JVM中同一个key只有一个线程去加载，其它线程等待结果。

对于以上未定义默认值的参数，如果没有指定，将使用yml中指定的全局配置，全局配置请参考配置说明。

三、JetCache接入配置

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

项目需要使用二级缓存（远程使用redis），用注解加到接口的方式实现，选用jetcache-anno-api、jetcache-redis 两个jar包

2、官方-Springboot 项目配置

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>${jetcache.latest.version}</version>
</dependency>

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

jetcache:
  statIntervalMinutes: 15
  areaInCacheName: false
  local:
    default:
      type: linkedhashmap
      keyConvertor: fastjson
  remote:
    default:
      type: redis
      keyConvertor: fastjson2
      broadcastChannel: projectA
      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);
    }
}

3、官方-未使用Springboot 的项目配置

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

<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-anno</artifactId>
    <version>${jetcache.latest.version}</version>
</dependency>

官方配置文档

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.Fastjson2KeyConvertor;
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 // deprecated in jetcache 2.7, 如果不用@CreateCache注解可以删除
@Import(JetCacheBaseBeans.class) //need since jetcache 2.7+
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 for jetcache <=2.6
    //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(Fastjson2KeyConvertor.INSTANCE)
                .valueEncoder(JavaValueEncoder.INSTANCE)
                .valueDecoder(JavaValueDecoder.INSTANCE)
                .broadcastChannel("projectA")
                .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); for jetcache <=2.6
 
        return globalCacheConfig;
    }
}

本地缓存-LinkedHashMapCache

本地缓存当前有两个实现。如果自己用jetcache-core的Cache API，可以不指定keyConvertor，此时本地缓存使用equals方法来比较key。 如果使用jetcache-anno中的@Cached、@CreateCache等注解，必须指定keyConvertor。

LinkedHashMapCache是JetCache中实现的一个最简单的Cache，使用LinkedHashMap做LRU方式淘汰。

Cache<Long, OrderDO> cache = LinkedHashMapCacheBuilder.createLinkedHashMapCacheBuilder()
                .limit(100)
                .expireAfterWrite(200, TimeUnit.SECONDS)
                .buildCache();

本地缓存-caffeine

caffeine cache的介绍看这里，它是guava cache的后续作品。

Cache<Long, OrderDO> cache = CaffeineCacheBuilder.createCaffeineCacheBuilder()
                .limit(100)
                .expireAfterWrite(200, TimeUnit.SECONDS)
                .buildCache();

4、统计

官网信息

jetcache/Stat.md at master · alibaba/jetcache · GitHub

当yml中的jetcache.statIntervalMinutes大于0时，通过@CreateCache和@Cached配置出来的Cache自带监控。JetCache会按指定的时间定期通过logger输出统计信息。默认输出信息类似如下：

只有使用computeIfAbsent方法或者@Cached注解才会统计loadTime。用get方法取缓存，没有命中的话自己去数据库load，显然是无法统计到的。

官方配置

如果需要定制输出，可以这样做:,按下文配置会在hotdog.debug.log文件中展示统计图，如果要制定输出到某日志需要配置logback，配置信息下文有

@Bean
    
public Consumer<StatInfo> statCallback() {
   return new StatInfoLogger(false);
  // ... 或实现自己的Consumer<StatInfo>
}

JetCache按statIntervalMinutes指定的周期，定期调用statCallback返回着这个Consumer，传入的StatInfo是已经统计好的数据。这个方法默认的实现是：

return new StatInfoLogger(false);

StatInfoLogger的构造参数设置为true会有更详细的统计信息，包括put等操作的统计。StatInfoLogger输出的是给人读的信息，你也可以自定义logger将日志输出成特定格式，然后通过日志系统统一收集和统计。

自定义统计示例： jetCache会自动回调这个方法，回调周期按照setStatIntervalMinutes(2);配置的时间

logback日志输出配置

如果想要让jetcache的日志输出到独立的文件中，在使用logback的情况下可以这样配置：（如果需要独立打印，不要配置上述自定义统计埋点）如果需要打印日志+埋点可以自定义类，具体请看文章最后

<appender name="JETCACHE_LOGFILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>jetcache.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>jetcache.log.%d{yyyy-MM-dd}</fileNamePattern>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
 
    <encoder>
        <pattern>%-4relative [%thread] %-5level %logger{35} - %msg%n</pattern>
    </encoder>
</appender>
 
<logger name="com.alicp.jetcache" level="INFO" additivity="false">
    <appender-ref ref="JETCACHE_LOGFILE" />
</logger>

统计日志:

5、适配公司sedis客户端-未使用Springboot 的项目配置

@Configuration
@EnableMethodCache(basePackages = "应用范围包名路径")
@Import(JetCacheBaseBeans.class)
public class JetCacheConfig {

    private static final Logger LOGGER = LoggerFactory.getLogger(JetCacheConfig.class);

    protected int maxNameLength = 65;


    @Bean
    public Consumer<StatInfo> statCallback() {
        //自定义Logger，实现自定义埋点+统计日志打印
        return new JetCacheLogger();
    }

    @Bean
    public GlobalCacheConfig config(@Qualifier("jetCacheSedis") AdvancedSedis3 jetCacheSedis) {
        //这里参数的 jetCacheSedis 为本项目自己封装的redis，使用自己项目封装好的redis即可，
        //或者照着官网示例代码的redis pool 配置也可以       

        Map localBuilders = new HashMap();
        CaffeineCacheBuilder.CaffeineCacheBuilderImpl caffeineCacheBuilder = CaffeineCacheBuilder.createCaffeineCacheBuilder()
                .keyConvertor(Fastjson2KeyConvertor.INSTANCE);
        localBuilders.put(CacheConsts.DEFAULT_AREA, caffeineCacheBuilder);

        Map remoteBuilders = new HashMap();
        SedisJetCacheBuilder.SedisDataCacheBuilderImpl builder = SedisJetCacheBuilder.createBuilder()
                .keyConvertor(Fastjson2KeyConvertor.INSTANCE)
                .valueEncoder(Kryo5ValueEncoder.INSTANCE)
                .valueDecoder(Kryo5ValueDecoder.INSTANCE)
                .broadcastChannel("t_desert_feed")
                .keyPrefix("jetCache-")
                .sedisClient(jetCacheSedis);//放入redis

        remoteBuilders.put(CacheConsts.DEFAULT_AREA, builder);
        GlobalCacheConfig globalCacheConfig = new GlobalCacheConfig();
        globalCacheConfig.setRemoteCacheBuilders(remoteBuilders);
        globalCacheConfig.setLocalCacheBuilders(localBuilders);
        globalCacheConfig.setStatIntervalMinutes(1);//设置每次间隔多久统计
        return globalCacheConfig;
    }


}

自定义Logger处理埋点和统计日志打印

public class JetCacheLogger implements Consumer<StatInfo> {
    private static final String JETCACHE_MONITOR_PREFIX = "jetcache.moniter.";
    private static Logger logger = LoggerFactory.getLogger(StatInfoLogger.class);//此处logger类需要StatInfoLogger这个
 
    protected int maxNameLength = 65;
 
    @Override
    public void accept(StatInfo statInfo) {
 
        //埋点
        List<CacheStat> stats = statInfo.getStats();
        if (stats != null && stats.size() > 0) {
            for (CacheStat c : stats) {
                String monitorKey = JETCACHE_MONITOR_PREFIX + c.getCacheName();
                long get = c.getGetCount();
                long hit = c.getGetHitCount();
                long fail = c.getGetFailCount();
                long expire = c.getGetExpireCount();
                double avgLoadTime = c.avgLoadTime() * 100;
                double maxLoadTime = c.getMaxLoadTime() * 100;
                //此处为项目封装的埋点方法，需要替换为自己项目埋点监控方法
                Monitor.recordMany(monitorKey + ".get", get, 0);
                Monitor.recordMany(monitorKey + ".hit", hit, 0);
                Monitor.recordMany(monitorKey + ".fail", fail, 0);
                Monitor.recordMany(monitorKey + ".expire", expire, 0);
                Monitor.recordQuantile(monitorKey + ".avgLoadTime", (long) avgLoadTime);
                Monitor.recordQuantile(monitorKey + ".maxLoadTime", (long) maxLoadTime);
            }
        }
        //日志，此处为复制StatInfoLogger 中的方法
        Collections.sort(stats, (o1, o2) -> {
            if (o1.getCacheName() == null) {
                return -1;
            } else if (o2.getCacheName() == null) {
                return 1;
            } else {
                return o1.getCacheName().compareTo(o2.getCacheName());
            }
        });
        StringBuilder sb;
        sb = logStatSummary(statInfo);//只使用总结统计，明细统计使用logVerbose这个方法且需要复制logVerbose方法的实现
        logger.info(sb.toString());
    }
 
    private StringBuilder logTitle(int initSize, StatInfo statInfo) {
        StringBuilder sb = new StringBuilder(initSize);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS");
        sb.append("jetcache stat from ").append(sdf.format(new Date(statInfo.getStartTime())))
                .append(" to ").append(sdf.format(statInfo.getEndTime())).append("\n");
        return sb;
    }
 
    private void printSepLine(StringBuilder sb, String title) {
        title.chars().forEach((c) -> {
            if (c == '|') {
                sb.append('+');
            } else {
                sb.append('-');
            }
        });
        sb.append('\n');
    }
 
    private StringBuilder logStatSummary(StatInfo statInfo) {
        StringBuilder sb = logTitle(2048, statInfo);
 
        List<CacheStat> stats = statInfo.getStats();
        OptionalInt maxCacheNameLength = stats.stream().mapToInt((s) -> getName(s.getCacheName()).length()).max();
        int len = Math.max(5, maxCacheNameLength.orElse(0));
 
        String title = String.format("%-" + len + "s|%10s|%7s|%14s|%14s|%14s|%14s|%11s|%11s", "cache", "qps", "rate", "get", "hit", "fail", "expire", "avgLoadTime", "maxLoadTime");
        sb.append(title).append('\n');
        printSepLine(sb, title);
        for (CacheStat s : stats) {
            sb.append(String.format("%-" + len + "s", getName(s.getCacheName()))).append('|');
            sb.append(String.format("%,10.2f", s.qps())).append('|');
            sb.append(String.format("%6.2f%%", s.hitRate() * 100)).append('|');
            sb.append(String.format("%,14d", s.getGetCount())).append('|');
            sb.append(String.format("%,14d", s.getGetHitCount())).append('|');
            sb.append(String.format("%,14d", s.getGetFailCount())).append('|');
            sb.append(String.format("%,14d", s.getGetExpireCount())).append('|');
            sb.append(String.format("%,11.1f", s.avgLoadTime())).append('|');
            sb.append(String.format("%,11d", s.getMaxLoadTime())).append('\n');
        }
        printSepLine(sb, title);
        return sb;
    }
 
    private String getName(String name) {
        if (name == null) {
            return null;
        }
        if (name.length() > maxNameLength) {
            return "..." + name.substring(name.length() - maxNameLength + 3);
        } else {
            return name;
        }
    }
}

还需要配置logback，看上文

6、指标的解读

以下是 JetCache 的各项统计指标的解读：

  1. 缓存命中率（Hit Rate）：表示缓存中已经存在的数据占总请求次数的比例。命中率越高，说明缓存效果越好，反之则说明缓存效果较差。

  2. 缓存请求次数（Request Count）：表示系统对缓存的请求总次数，包括读取和写入操作。

  3. 缓存命中次数（Hit Count）：表示系统从缓存中读取数据的次数。

  4. 缓存未命中次数（Miss Count）：表示系统从缓存中读取数据失败的次数，需要从数据库或其他数据源中获取数据。

  5. 缓存写入次数（Put Count）：表示系统向缓存中写入数据的次数。

  6. 缓存删除次数（Remove Count）：表示系统从缓存中删除数据的次数。

  7. 缓存平均读取时间（Average Read Time）：表示系统从缓存中读取数据的平均时间。

  8. 缓存平均写入时间（Average Write Time）：表示系统向缓存中写入数据的平均时间。

  9. 缓存平均删除时间（Average Remove Time）：表示系统从缓存中删除数据的平均时间。

Python3---Pytest框架-----Fixture函数详解（2）
Alien-Hu
07-30 3409
文章目录1.Fixture的定义2.fixture的用途一：装饰函数3.fixture的用途二：装饰类4.fixture的用途三：自己运行，不用装饰任何其他 1.Fixture的定义 fixture修饰器来标记固定的工厂函数,在其他函数，模块，类或整个工程调用它时会被激活并优先执行,通常会被用于完成预置处理和重复操作 fixture(scope="function", params=None...
《深度学习》之 目标检测 最全详解 （一）
热门推荐
DFCED的博客
03-22 4万+
目标检测 一.简介 目标检测，也叫目标提取，是一种基于目标几何和统计特征的图像分割，它将目标的分割和识别合二为一，其准确性和实时性是整个系统的一项重要能力。尤其是在复杂场景中，需要对多个目标进行实时处理时，目标自动提取和识别就显得特别重要。 随着计算机技术的发展和计算机视觉原理的广泛应用，利用计算机图像处理技术对目标进行实时跟踪研究越来越热门，对目标进行动态实时跟踪定位在智能化交通系统、智能监控...
SpringBoot 集成 JetCache-Alibaba 实现本地缓存
sco5282的博客
10-06 2019
官网地址官方文档JetCache是由阿里巴巴开源的一款基于 Spring 和 Redis 的分布式缓存框架，提供统一的 API 和注解来简化缓存的使用。JetCache提供了比更加强大的注解，可以原生的支持 TTL、两级缓存、分布式自动刷新，还提供了 Cache 接口用于手工缓存操作。当前有四个实现，RedisCacheTairCache（此部分未在 github 开源）、(in memory) 和一个简易的(in memory)，要添加新的实现也是非常简单的通过统一的 API 访问 Cache 系统。
JetCache是一个基于Java的缓存系统封装提供统一的API和注解来简化缓存的使用
08-06
JetCache 是一个基于 Java 的缓存系统封装，提供统一的 API 和注解来简化缓存的使用
Jetcache快速入门
最新发布
weixin_46425661的博客
03-04 1171
JetCache是一个基于Java的缓存系统封装，提供统一的API和注解来简化缓存的使用。 JetCache提供了比SpringCache更加强大的注解，可以原生的支持TTL、两级缓存、分布式自动刷新，还提供了Cache接口用于手工缓存操作。 当前有四个实现，RedisCache、TairCache（此部分未在github开源）、CaffeineCache(in memory)和一个简易的LinkedHashMapCache(in memory)，要添加新的实现也是非常简单的。
java 缓存框架
weixin_30888027的博客
01-20 104
OSCache 　　OSCache是个一个广泛采用的高性能的J2EE缓存框架，OSCache能用于任何Java应用程序的普通的缓存解决方案。 OSCache有以下特点：缓存任何对象，你可以不受限制的缓存部分jsp页面或HTTP请求，任何java对象都可以缓存。拥有全面的API--OSCache API给你全面的程序来控制所有的OSCache特性。永久缓存--缓存能随意的写入硬盘，因此允许昂贵的...
【JetCache】JetCache的配置说明和注解属性说明
No8g攻城狮的博客
07-02 6218
本文目录一、配置说明二、注解属性说明 yml配置文件案例（如果没使用springboot，直接配置GlobalCacheConfig是类似的，参考快速入门教程）： 配置通用说明如下：上表中${area}对应@Cached和@CreateCache的area属性。注意如果注解上没有指定area，默认值是"default"。关于缓存的超时时间，有多个地方指定，澄清说明一下：JetCache方法缓存和SpringCache比较类似，它原生提供了TTL支持，以保证最终一致，并且支持二级缓存。JetCache2.
JetCache-Alibaba缓存框架
lzc翻身博客
06-14 8564
JetCache 是一个高性能分布式缓存框架，可以为应用程序提供多种缓存模式和缓存管理功能。该框架支持本地缓存和分布式缓存，并提供了一系列缓存注解、缓存管理 API、缓存失效策略等特性来方便应用程序处理缓存数据。与其他缓存框架相比，JetCache 具有更好的性能、更灵活的配置以及更多的特性支持，可适用于各种场景的缓存需求。本篇文章介绍了 JetCache 的背景、设计理念、使用方式、示例等内容，旨在帮助开发者快速上手使用 JetCache 来提升应用程序的性能和可用性。
JetCache-的使用(入门教程)
xhmico的博客
07-03 5150
我不生产知识，我只是知识的搬运工，以下是我使用 spring-boot 整合 jetCache 的一些经验分享。github：https://github.com/alibaba/jetcache官方文档：https://github.com/alibaba/jetcache/wiki/Home_CN官网上是这么描述 JetCache的：JetCache是一个基于Java的缓存系统封装，提供统一的API和注解来简化缓存的使用。 JetCache提供了比SpringCache更加强大的注解，可以原生的支持TT
第22周-第15章节-Python3.5-Django之缓存实例详解2.avi
02-10
第22周-第15章节-Python3.5-Django之缓存实例详解2.avi
第22周-第14章节-Python3.5-Django之缓存实例详解1.avi
02-10
第22周-第14章节-Python3.5-Django之缓存实例详解1.avi
【目标检测-YOLO】YOLOv5-v6.0-网络架构详解（第二篇）
博观约取，厚积薄发
03-31 1万+
YOLOv5-v6.0-网络架构详解，包含架构图
【开发篇】十二、缓存框架JetCache
llg___的博客
09-29 1452
JetCache对SpringCache进行了封装，在原有功能基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能CaffeineRedisTair。
JetCache 使用教程
gitblog_00220的博客
08-07 490
JetCache 使用教程 jetcacheJetCache is a Java cache framework.项目地址:https://gitcode.com/gh_mirrors/je/jetcache 1. 项目的目录结构及介绍 JetCache 项目的目录结构如下： jetcache/ ├── docs/ ├── jetcache-anno-api/ ├── jetcache-anno...
Java中的缓存框架
cnzzs的博客
08-23 1067
一、JCache在Java编程中，有一套基于缓存的规范，名为JSR 107(JCACHE - Java Temporary Caching API)，该规范主要定义了以下几个关键类型1、javax.cache.Cache<K, V> 缓存是一种类似 Map 的数据结构，用于临时存储应用程序数据。 类似Map...
JetCache快速入门
weixin_33815613的博客
04-25 419
创建缓存实例 通过@CreateCache注解创建一个缓存实例，默认超时时间是100秒 @CreateCache(expire = 100) private Cache<Long, UserDO> userCache; 用起来就像map一样 UserDO user = userCache.get(123L); userCache.put(12...
SpringBoot中集成阿里开源缓存访问框架JetCache实现声明式实例和方法缓存
BADAO_LIUMANG_QIZHI的博客
07-11 1908
上面讲的通过自定义注解的方式实现查询数据库数据缓存，除此之外还有更好的轮子。
五号编程 | Java缓存框架 JetCache
wolf09311的专栏
03-08 306
前言 ​ 缓存在项目中一般都会运用，现有的项目大部分就是基于Spring boot框架搭建，大部分的缓存也是基于Spring boot自带的缓存来做。今天我们的主角不是Spring boot自带的缓存，是阿里缓存框架JetCache JetCache介绍 ​ JetCache是一个基于Java的缓存系统封装，支持API和注解来使用。可以支持原生的TTL、二级缓存、分布式自动刷新，当前有四个实现，RedisCache、TairCache（此部分未在 github 开源）、CaffeineCache(in.
JetCache源码解析——缓存处理
qq_16500963的博客
01-11 2842
在Java技术体系中，如果想要在不改变已有代码逻辑的情况下，对已有的函数进行功能增强，一般可以使用两种方式，如AOP（Aspect Oriented Programming），即面向切面编程，以及代理模式，如使用JDK 动态代理或 CGLIB 动态代理。例如Mybatis的源码中同时使用了JDK 动态代理或 CGLIB 动态代理，但是对于Mapper接口是使用JDK动态代理模式。
Logisim实现全相联缓存设计详解
这个文档提供了使用Logisim设计全相联Cache的框架，通过组合基本逻辑元素并理解它们的功能，可以逐步构建出高效的数据缓存系统。对于学习和理解计算机体系结构以及硬件实现来说，这是一个实用的实践教程。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值