阿里一款非常不错的多级缓存框架如何使用？

目录

前言

1. jetcache简介

2. jetcache使用

2. jetcache使用

3. 测试

        3.1 方式一测试

        3.2 方式二测试

        3.3 方式三测试

4.缺点优点

5. 常见报错

---

前言

大家好，我是月夜枫~~

在很多大数据、高并发的业务中，像MySql等传统的关系型数据库已经不能适用于所有的业务场景，比如电商系统的秒杀场景，APP首页的访问流量高峰场景，很容易造成关系型数据库的瘫痪，随着缓存技术的出现很好的解决了这问题。

‌多级缓存的主要作用包括提高性能、降低成本、减少带宽压力。‌ 缓存提供了比主内存更快的访问速度，多级结构减少了数据访问延迟，从而提高了系统的整体性能。此外，通过分层缓冲，可以在性能和成本之间找到平衡，降低成本。多级缓存还可以减少主内存和处理器之间的数据传输频率，从而减轻带宽压力。‌

随着技术的不断进步，多级缓存有望得到进一步的改进和扩展。例如，通过引入更加智能的预取算法，可以提高缓存命中率；通过采用更高效的数据压缩技术，减少缓存占用的内存空间；通过结合新型的非易失性内存技术，实现更快速的数据访问等。这些改进将进一步优化内存管理，增强系统性能。‌

首先我们来了解一下什么是缓存？

缓存就是把访问量较高的热点数据从传统的关系型数据库中加载到内存中，当用户再次访问热点数据时是从内存中加载，减少了对数据库的访问量，解决了高并发场景下容易造成数据库宕机的问题。

缓存的分类有哪些？

缓存基本上分为三类：本地缓存、分布式缓存、多级缓存。根据缓存和应用程序是否属于同一个进程，将缓存分为本地缓存和分布式缓存。基于本地缓存和分布式缓存都有各自的优点和缺点，后面又出现了多级缓存的概念。

1、本地缓存

本地缓存的概念：

本地缓存是指和应用程序在同一个进程内的内存空间去存储数据，数据的读写都是在同一个进程内完成的。

本地缓存优点：

读取速度快，但是不能进行大数据量存储。

本地缓存不需要远程网络请求去操作内存空间，没有额外的性能消耗，所以读取速度快。

本地缓存缺点：

应用程序集群部署时，会存在数据更新问题（数据更新不一致）

本地缓存一般只能被同一个应用进程的程序访问，不能被其他应用程序进程访问。在单体应用集群部署时，如果数据库有数据需要更新，就要同步更新不同服务器节点上的本地缓存的数据来保证数据的一致性，但是这种操作的复杂度高，容易出错。可以基于redis的发布/订阅机制来实现各个部署节点的数据同步更新。

数据会随着应用程序的重启而丢失

因为本地缓存的数据是存储在应用进程的内存空间的，所以当应用进程重启时，本地缓存的数据会丢失。

本地缓存的实现：

（1）、缓存存储的数据一般都是key-value键值对的数据结构。

（2）、除了上面说的实现方式以外，也可以用Guava、Ehcache以及Caffeine等封装好的工具包来实现本地缓存。

2、分布式缓存

分布式缓存概念：

分布式缓存是独立部署的服务进程，并且和应用程序没有部署在同一台服务器上。所以是需要通过远程网络请求来完成分布式缓存的读写操作，并且分布式缓存主要应用在应用程序集群部署的环境下。

分布式缓存优点：支持大数据量存储

分布式缓存是独立部署的进程，拥有自身独自的内存空间，不需要占用应用程序进程的内存空间，并且还支持横向扩展的集群方式部署，所以可以进行大数据量存储。

数据不会随着应用程序重启而丢失。

分布式缓存和本地缓存不同，拥有自身独立的内存空间，不会受到应用程序进程重启的影响，在应用程序重启时，分布式缓存的存储数据仍然存在。

数据集中存储，保证数据的一致性。

当应用程序采用集群方式部署时，集群的每个部署节点都有一个统一的分布式缓存进行数据的读写操作，所以不会存在像本地缓存中数据更新问题，保证了不同服务器节点的 数据一致性。

数据读写分离，高性能，高可用。

分布式缓存一般支持数据副本机制，实现读写分离，可以解决高并发场景中的数据读写性能问题。而且在多个缓存节点冗余存储数据，提高了缓存数据的可用性，避免某个缓存节点宕机导致数据不可用问题。

分布式缓存缺点：数据跨网络传输，读写性能不如本地缓存。

分布式缓存是一个独立的服务进程，并且和应用程序进程不在同一台机器上，所以数据的读写要通过远程网络请求，这样相对于本地缓存的数据读写，性能要低一些。

分布式缓存的实现：分布式缓存的典型实现包括 MemCached 和 Redis。

3、多级缓存

基于本地缓存和分布式缓存的优缺点，多级缓存应运而生，在实际的业务开发中一般也是采用多级缓存。

注意：本地缓存一般存储更新频率低，访问频率高数据，分布式缓存一般存储更新频率很高的数据。

多级缓存的请求流程： 本地缓存作为一级缓存，分布式缓存作为二级缓存；当用户获取数据时，先从一级缓存中获取数据，如果一级缓存有数据则返回数据，否则从二级缓存中获取数据。如果二级缓存中有数据则更新一级缓存，然后将数据返回客户端。如果二级缓存没有数据则去数据库查询数据，然后更新二级缓存，接着再更新一级缓存，最后将数据返回给客户端。

多级缓存的实现： 可以使用Guava或者Caffeine作为一级缓存，Redis作为二级缓存。

注意：在应用程序集群部署时，如果数据库的数据有更新的情况，一级缓存的数据更新容易出现数据不一致的情况。因为是集群部署，多个部署节点实现一级缓存数据更新难度比较大，不过我们可以通过Redis的消息发布/订阅机制来实现多个节点缓存数据一致性问题。

为什么要用缓存（为什么要用redis作为缓存）？

针对于这个问题要从两个方面去考虑，一个是应用系统的高并发场景，另一个就是应用系统的高性能情况。

1、高性能情况： 用户第一次访问数据时，缓存中没有数据，要从数据库中获取数据，因为是从磁盘中拿数据，读取数据的过程比较慢。拿到数据后将数据存储在缓存中，用户第二次访问数据时，可以从缓存中直接获取，因为缓存是直接操作内存的，访问数据速度比较快。

2、高并发场景下： 操作缓存能够承受的并发访问量是远远大于访问数据库的，比如redis，它的读的速度是110000次/s，写的速度是81000次/s。所以说将数据库中访问量高的数据存储到缓存中，用户请求的时候直接访问数据库，不必访问数据库，提高应用程序的并发量。

简单铺垫一下，好，开始今天的分享。。。。

其实在实际应用中，并不是单一的使用本地缓存或者redis，更多是组合使用来满足不同的业务场景，于是如何优雅的组合本地缓存和远程缓存就成了我们要研究的问题，而这一点，阿里开源的jetcache组件帮我们实现了。

1. jetcache简介

jetcache是阿里开源的基于java开发的缓存框架，支持多种缓存类型：本地缓存、分布式缓存、多级缓存。能够满足不同业务场景的缓存需求。

jetcache具有上手简单、性能高效、拓展性强的特点。支持缓存预热 、缓存key前缀等功能。结合spring-cache使用，可以实现十分优雅的缓存类型切换

官网地址：https://github.com/alibaba/jetcache

官方文档：https://github.com/alibaba/jetcache/tree/master/docs/CN

2. jetcache使用

2. jetcache使用

1、引入依赖，这里我们使用sringboot项目框架，同时使用redis作为远程缓存。于是我们引入jetcache-starter-redis依赖，这里我的springboot版本为2.6.13

如果是非springboot项目可以参考官网说明配置。

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

<!--        jetcache2.7.x版本需要额外添加该依赖-->
<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>4.3.1</version>
</dependency>

对应的版本说明如下：

https://github.com/alibaba/jetcache/blob/master/docs/CN/Compatibility.md

2、修改配置文件，配置redis地址和线程数

jetcache:
  # 统计间隔，0表示不统计，开启后定期在控制台输出缓存信息
  statIntervalMinutes: 15
  # 是否把cacheName作为远程缓存key前缀
  areaInCacheName: false
  # 本地缓存配置
  local:
    default: # default表示全部生效，也可以指定某个cacheName
      # 本地缓存类型，其他可选：caffeine/linkedhashmap
      type: linkedhashmap
      keyConvertor: fastjson
  # 远程缓存配置
  remote:
    default: # default表示全部生效，也可以指定某个cacheName
      type: redis
      # key转换器方式n
      keyConvertor: fastjson
      broadcastChannel: projectA
      # redis序列化方式
      valueEncoder: java
      valueDecoder: java
      # redis线程池
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      # redis地址与端口
      host: 127.0.0.1
      port: 6379

更详细的参数配置可参考官网说明：

3、启动类添加注解@EnableCreateCacheAnnotation，开启缓存，添加@EnableMethodCache(basePackages = "com.example.jetcachedemo")注解，配置缓存方法扫描路径。

4、使用缓存可以通过三种方式

• 方式一（推荐）AOP模式：通过@Cached,@CacheUpdate,@CacheInvalidate注解。

@RestController
@RequestMapping("user")
public class UserController {

    @GetMapping("getRemote")
    @Cached(name="userCache:", key = "#id", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.REMOTE)
    public User getRemote(Long id){
        // 直接新建用户，模拟从数据库获取数据
        User user = new User();
        user.setId(id);
        user.setName("用户remote"+id);
        user.setAge(23);
        user.setSex(1);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

    @GetMapping("getLocal")
    @Cached(name="userCache:", key = "#id", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.LOCAL)
    public User getLocal(Long id){
        // 直接新建用户，模拟从数据库获取数据
        User user = new User();
        user.setId(id);
        user.setName("用户local"+id);
        user.setAge(23);
        user.setSex(1);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

    @GetMapping("getBoth")
    @Cached(name="userCache:", key = "#id", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.BOTH)
    public User getBoth(Long id){
        // 直接新建用户，模拟从数据库获取数据
        User user = new User();
        user.setId(id);
        user.setName("用户both"+id);
        user.setAge(23);
        user.setSex(1);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

    @PostMapping("updateUser")
    @CacheUpdate(name = "userCache:", key = "#user.id", value = "#user")
    public Boolean updateUser(@RequestBody User user){
        // TODO 更新数据库
        return true;
    }

    @PostMapping("deleteUser")
    @CacheInvalidate(name = "userCache:", key = "#id")
    public Boolean deleteUser(Long id){
        // TODO 从数据库删除
        return true;
    }

}

这里要注意实体类User一定要实现序列化，即声明Serializable。

@Data
public class User implements Serializable {

    private Long id;
    private String name;
    private Integer age;
    private Integer sex;
}

• 方式二 API模式：通过@CreateCache，注：在jetcache 2.7 版本CreateCache注解已废弃，不推荐使用。

@RestController
@RequestMapping("user2")
public class User2Controller {

    @CreateCache(name= "userCache:", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.BOTH)
    private Cache<Long, Object> userCache;

    @GetMapping("get")
    public User get(Long id){
        if(userCache.get(id) != null){
            return (User) userCache.get(id);
        }
        User user = new User();
        user.setId(id);
        user.setName("用户both"+id);
        user.setAge(23);
        user.setSex(1);
        userCache.put(id, user);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

    @PostMapping("updateUser")
    public Boolean updateUser(@RequestBody User user){
        // TODO 更新数据库
        userCache.put(user.getId(), user);
        return true;
    }

    @PostMapping("deleteUser")
    public Boolean deleteUser(Long id){
        // TODO 从数据库删除
        userCache.remove(id);
        return true;
    }

}

• 方式三 高级API模式：通过CacheManager，2.7 版本才可使用。

（1）添加依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.25</version>
</dependency>

（2）书写配置类

@Configuration
public class JetcacheConfig {

    @Autowired
    private CacheManager cacheManager;
    private Cache<Long, Object> userCache;

    @PostConstruct
    public void init(){
        QuickConfig qc = QuickConfig.newBuilder("userCache:")
                .expire(Duration.ofSeconds(3600))
                .cacheType(CacheType.BOTH)
                // 本地缓存更新后，将在所有的节点中删除缓存，以保持强一致性
                .syncLocal(false)
                .build();
        userCache = cacheManager.getOrCreateCache(qc);
    }

    @Bean
    public Cache<Long, Object> getUserCache(){
        return userCache;
    }
}

（3）调用代码

@RestController
@RequestMapping("user3")
public class User3Controller {

    @Autowired
    JetcacheConfig jetcacheConfig;
    @Autowired
    private Cache<Long, Object> userCache;

    @GetMapping("get")
    public User get(Long id){
        if(userCache.get(id) != null){
            return (User) userCache.get(id);
        }
        User user = new User();
        user.setId(id);
        user.setName("用户both"+id);
        user.setAge(23);
        user.setSex(1);
        userCache.put(id, user);
        System.out.println("第一次获取数据，未走缓存："+id);
        return user;
    }

    @PostMapping("updateUser")
    public Boolean updateUser(@RequestBody User user){
        // TODO 更新数据库
        userCache.put(user.getId(), user);
        return true;
    }

    @PostMapping("deleteUser")
    public Boolean deleteUser(Long id){
        // TODO 从数据库删除
        userCache.remove(id);
        return true;
    }

}

多级缓存的形式，会先从本地缓存获取数据，本地获取不到会从远程缓存获取；关注工众号：码猿技术专栏，回复关键词：1111 获取阿里内部Java性能调优手册！

5、启动redis，启动演示项目

注意，如果启动出现

NoClassDefFoundError: redis/clients/util/Pool或NoClassDefFoundError: redis/clients/jedis/UnifiedJedis报错，

说明springboot与jetcache版本不一致，对应关系可参考上述第一步中的说明 同时如果使用的是jetcache2.7.x版本，因为该版本中有jedis包的依赖，需要额外添加如下依赖，或者将jetcache版本将至2.6.5以下。

<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>4.3.1</version>
</dependency>

3. 测试

3.1 方式一测试

1、访问localhost:8088/user/getRemote?id=1

 因为配置的是远程缓存，在redis中也能看到对应的key。

2、访问localhost:8088/user/getLocal?id=1，这个方法是从本地缓存获取的，现在只有远程缓存上有数据，我们调用发现缓存数据还是拿到了，这说明当我们在配置文件中配置了本地缓存和远程缓存后，方式一中本地缓存和远程缓存会自动相互调用

比如本地缓存有这个key，redis中没有，通过远程缓存方式访问时，会先从redis获取，如果没有会自动获取本地缓存，但是数据还是存储在本地缓存，并不会同步到redis上，这样更加灵活的实现了多级缓存架构。

3.2 方式二测试

1、再测试下CreateCache的形式：localhost:8088/user2/get?id=4

正常获取了，并且redis中也有了对应的值。

而当我们把缓存方式更改为LOCAL后，再访问localhost:8088/user2/get?id=5

@CreateCache(name= "userCache:", expire = 3600, 
timeUnit = TimeUnit.SECONDS, cacheType = CacheType.LOCAL)

会发现redis中就没有对应缓存了，只在本地缓存存在，说明我们指定本地缓存的形式成功了。

3.3 方式三测试

1、调用localhost:8088/user3/get?id=11

redis中缓存设置成功！

4.缺点优点

‌‌JetCache的优点‌包括：

1. ‌灵活的存储策略‌：它支持设备每次上报一部分属性，以及支持读取部分属性数据，这种灵活性几乎可以满足任意场景下的属性数据存储需求。‌1
2. ‌可设置多级缓存‌：不需要每次缓存都走远端cache，提供了方便的设置选项。‌2
3. ‌注解使用‌：提供了方便的注解使用方式，使得开发人员能够更专注于开发本身。
4. ‌cache命中统计数据‌：提供了cache命中的统计数据，有助于优化缓存策略。

‌JetCache的缺点‌包括：

1. ‌数据量增长‌：当设备属性个数较多时，数据量会指数增长，可能导致性能下降。
2. ‌性能问题‌：在设备属性个数较多时，可能性能较低。

综上所述，JetCache作为一个缓存框架，提供了灵活的存储策略和多级缓存设置，方便了开发人员的使用。然而，随着数据量的增长，可能会面临性能下降和数据管理挑战。这些优缺点需要在具体应用场景中综合考虑。‌

5. 常见报错

JetCache是一个基于Java的缓存系统框架，用于简化缓存的使用。以下是一些常见的JetCache异常以及简要的解释和解决方法：

1、 ClassNotFoundException: com.alibaba.fastjson.JSON 解决：添加依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>2.0.25</version>
</dependency>

2、NoClassDefFoundError: redis/clients/jedis/UnifiedJedis 解决： 添加依赖

<dependency>
   <groupId>redis.clients</groupId>
   <artifactId>jedis</artifactId>
   <version>4.3.1</version>
</dependency>

或者将jetcache版本降低至2.6.5以下。

3、CacheInitException：

解释：缓存初始化异常，通常是因为配置错误或者缓存实例化失败。

解决方法：检查缓存配置信息，确保所有必要的参数都正确无误，并且缓存实例可以被正确创建。

4、CacheGetException：

解释：获取缓存数据时出现异常。

解决方法：检查是否有网络问题、序列化问题或者是缓存数据损坏。

5、CachePutException：

解释：缓存数据插入异常，可能是因为存储介质问题或者存储限制。

解决方法：检查存储介质状态，确保有足够的空间，并且没有写入限制。

6、CacheRemoveException：

解释：缓存数据移除异常，可能是因为缓存服务器宕机或者通信问题。

解决方法：检查缓存服务器状态，确保服务器正常运行，并且网络通信无障碍。

7、CacheInvokeException：

解释：自定义缓存操作函数执行异常。

解决方法：检查自定义函数的逻辑，确保没有抛出任何异常。

在处理JetCache异常时，应该首先查看异常的详细信息和堆栈跟踪，以确定异常的原因。根据具体的错误信息，采取相应的解决措施。如果是配置问题，修改配置文件；如果是代码问题，修改缓存操作代码；如果是硬件或网络问题，修复或替换硬件，检查网络连接。

最后说一句(求关注，别白嫖我)
如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下，您的支持是我坚持写作最大的动力。
求一键三连：点赞、转发、在看。
我从清晨走过，也拥抱夜晚的星辰，人生没有捷径，你我皆平凡，你好，陌生人，一起共勉。