jetcache缓存方案

梦里梦外; 2024-04-03 12:58 55阅读 0赞

#### 文章目录 ####

*   *   *  十六.jetcache远程缓存方案
         *  十七.jetcache本地缓存方案
         *   *   *  纯本地方案
                 *  本地+远程方案
             *  小结:
         *  十八.jetcache方法缓存
         *   *   *  远程方案的数据同步
                 *  数据报表
         *  总结:
         *  十九-j2cache基本操作
         *   *  总结:

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

#### 十六.jetcache远程缓存方案 ####

jetCache对SpringCache进行了封装，在原有功能基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能  
jetCache设定了本地缓存与远程缓存的多级缓存解决方案  
**本地缓存（Local）**  
LinkedHashMap  
Caffeine

**远程缓存（Remote）**  
Redis  
Tair  
步骤①：导入springboot整合jetcache对应的坐标starter，当前坐标默认使用的远程方案是redis

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

**步骤②**：远程方案基本配置

jetcache:
      remote:
        default:
          type: redis
          host: localhost
          port: 6379
          poolConfig:
            maxTotal: 50

其中poolConfig是必配项，否则会报错

**步骤③**：启用缓存，在引导类上方标注注解@EnableCreateCacheAnnotation配置springboot程序中可以使用注解的形式创建缓存

@SpringBootApplication
    //jetcache启用缓存的主开关
    @EnableCreateCacheAnnotation
    public class Springboot20JetCacheApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(Springboot20JetCacheApplication.class, args);
        }
    }

**步骤④**：创建缓存对象Cache，并使用注解@CreateCache标记当前缓存的信息，然后使用Cache对象的API操作缓存，put写缓存，get读缓存。

@Service
    public class SMSCodeServiceImpl implements SMSCodeService {
        
        @Autowired
        private CodeUtils codeUtils;
        
        @CreateCache(name="jetCache_",expire = 10,timeUnit = TimeUnit.SECONDS)
        private Cache<String ,String> jetCache;
    
        public String sendCodeToSMS(String tele) {
        
            String code = codeUtils.generator(tele);
            jetCache.put(tele,code);
            return code;
        }
    
        public boolean checkCode(SMSCode smsCode) {
        
            String code = jetCache.get(smsCode.getTele());
            return smsCode.getCode().equals(code);
        }
    }

过上述jetcache使用远程方案连接redis可以看出，jetcache操作缓存时的接口操作更符合开发者习惯，使用缓存就先获取缓存对象Cache，放数据进去就是put，取数据出来就是get，更加简单易懂。并且jetcache操作缓存时，可以为某个缓存对象设置过期时间，将同类型的数据放入缓存中，方便有效周期的管理。

上述方案中使用的是配置中定义的default缓存，其实这个default是个名字，可以随便写，也可以随便加。例如再添加一种缓存解决方案，参照如下配置进行：

jetcache:
      remote:
        default:
          type: redis
          host: localhost
          port: 6379
          poolConfig:
            maxTotal: 50
        sms:
          type: redis
          host: localhost
          port: 6379
          poolConfig:
            maxTotal: 50

如果想使用名称是sms的缓存，需要再创建缓存时指定参数area，声明使用对应缓存即可

@Service
    public class SMSCodeServiceImpl implements SMSCodeService {
        
        @Autowired
        private CodeUtils codeUtils;
        
        @CreateCache(area="sms",name="jetCache_",expire = 10,timeUnit = TimeUnit.SECONDS)
        private Cache<String ,String> jetCache;
    
        public String sendCodeToSMS(String tele) {
        
            String code = codeUtils.generator(tele);
            jetCache.put(tele,code);
            return code;
        }
    
        public boolean checkCode(SMSCode smsCode) {
        
            String code = jetCache.get(smsCode.getTele());
            return smsCode.getCode().equals(code);
        }
    }

设置 spring.main.allow-circular-references 为 true 打破循环

spring:
      main:
        allow-circular-references: true

#### 十七.jetcache本地缓存方案 ####

###### 纯本地方案 ######

远程方案中，配置中使用remote表示远程，换成local就是本地，只不过类型不一样而已。

**步骤①**：导入springboot整合jetcache对应的坐标starter

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

**步骤②**：本地缓存基本配置

jetcache:
      local:
        default:
          type: linkedhashmap
          keyConvertor: fastjson

为了加速数据获取时key的匹配速度，jetcache要求指定key的类型转换器。简单说就是，如果你给了一个Object作为key的话，我先用key的类型转换器给转换成字符串，然后再保存。等到获取数据时，仍然是先使用给定的Object转换成字符串，然后根据字符串匹配。由于jetcache是阿里的技术，这里推荐key的类型转换器使用阿里的fastjson。

步骤③：启用缓存

**步骤④**：创建缓存对象Cache时，标注当前使用本地缓存

@Service
    public class SMSCodeServiceImpl implements SMSCodeService {
        
        @CreateCache(name="jetCache_",expire = 1000,timeUnit = TimeUnit.SECONDS,cacheType = CacheType.LOCAL)
        private Cache<String ,String> jetCache;
    
        public String sendCodeToSMS(String tele) {
        
            String code = codeUtils.generator(tele);
            jetCache.put(tele,code);
            return code;
        }
    
        public boolean checkCode(SMSCode smsCode) {
        
            String code = jetCache.get(smsCode.getTele());
            return smsCode.getCode().equals(code);
        }
    }

cacheType控制当前缓存使用本地缓存还是远程缓存，配置cacheType=CacheType.LOCAL即使用本地缓存。

###### 本地+远程方案 ######

本地和远程方法都有了，两种方案一起使用如何配置呢？其实就是将两种配置合并到一起就可以了。

jetcache:
      local:
        default:
          type: linkedhashmap
          keyConvertor: fastjson
      remote:
        default:
          type: redis
          host: localhost
          port: 6379
          poolConfig:
            maxTotal: 50
        sms:
          type: redis
          host: localhost
          port: 6379
          poolConfig:
            maxTotal: 50

在创建缓存的时候，配置cacheType为BOTH即则本地缓存与远程缓存同时使用。

##### 小结: #####

1.  jetcache简介
2.  jetcache远程缓存使用方式
3.  jetcache本地缓存使用方式

#### 十八.jetcache方法缓存 ####

etcache提供了方法缓存方案，只不过名称变更了而已。在对应的操作接口上方使用注解@Cached即可

**步骤①**：导入springboot整合jetcache对应的坐标starter

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

**步骤②**：配置缓存

jetcache:
      local:
        default:
          type: linkedhashmap
          keyConvertor: fastjson
      remote:
        default:
          type: redis
          host: localhost
          port: 6379
          keyConvertor: fastjson
          valueEncode: java
          valueDecode: java
          poolConfig:
            maxTotal: 50
        sms:
          type: redis
          host: localhost
          port: 6379
          poolConfig:
            maxTotal: 50

由于redis缓存中不支持保存对象，因此需要对redis设置当Object类型数据进入到redis中时如何进行类型转换。需要配置keyConvertor表示key的类型转换方式，同时标注value的转换类型方式，值进入redis时是java类型，标注valueEncode为java，值从redis中读取时转换成java，标注valueDecode为java。

注意，为了实现Object类型的值进出redis，需要保障进出redis的Object类型的数据必须实现序列化接口。

@Data
    public class Book implements Serializable {
        
        private Integer id;
        private String type;
        private String name;
        private String description;
    }

**步骤③**：启用缓存时开启方法缓存功能，并配置basePackages，说明在哪些包中开启方法缓存

@SpringBootApplication
    //jetcache启用缓存的主开关
    @EnableCreateCacheAnnotation
    //开启方法注解缓存
    @EnableMethodCache(basePackages="com.example")
    public class Springboot20JetCacheApplication {
        
        public static void main(String[] args) {
        
            SpringApplication.run(Springboot20JetCacheApplication.class, args);
        }
    }

**步骤④**：使用注解@Cached标注当前方法使用缓存

@Service
    public class BookServiceImpl implements BookService {
        
        @Autowired
        private BookDao bookDao;
        
        @Override
        @Cached(name="book_",key="#id",expire = 3600,cacheType = CacheType.REMOTE)
        public Book getById(Integer id) {
        
            return bookDao.selectById(id);
        }
    }

###### 远程方案的数据同步 ######

由于远程方案中redis保存的数据可以被多个客户端共享，这就存在了数据同步问题。jetcache提供了3个注解解决此问题，分别在更新、删除操作时同步缓存数据，和读取缓存时定时刷新数据

**更新缓存**

@CacheUpdate(name="book_",key="#book.id",value="#book")
    public boolean update(Book book) {
        
        return bookDao.updateById(book) > 0;
    }

**删除缓存**

@CacheInvalidate(name="book_",key = "#id")
    public boolean delete(Integer id) {
        
        return bookDao.deleteById(id) > 0;
    }

**定时刷新缓存**

@Cached(name="book_",key="#id",expire = 3600,cacheType = CacheType.REMOTE)
    @CacheRefresh(refresh = 5)
    public Book getById(Integer id) {
        
        return bookDao.selectById(id);
    }

###### 数据报表 ######

jetcache还提供有简单的数据报表功能，帮助开发者快速查看缓存命中信息，只需要添加一个配置即可

jetcache:
      statIntervalMinutes: 1

#### 总结: ####

1.jetcache是一个类似于springcache的缓存解决方案，自身不具有缓存功能，它提供有本地缓存与远程缓存多级共同使用的缓存解决方案  
2.jetcache提供的缓存解决方案受限于目前支持的方案，本地缓存支持两种，远程缓存支持两种  
3.注意数据进入远程缓存时的类型转换问题  
4.jetcache提供方法缓存，并提供了对应的缓存更新与刷新功能  
5.jetcache提供有简单的缓存信息命中报表方便开发者即时监控缓存数据命中情况

#### 十九-j2cache基本操作 ####

jetcache可以在限定范围内构建多级缓存，但是灵活性不足，不能随意搭配缓存，本节介绍一种可以随意搭配缓存解决方案的缓存整合框架，j2cache。下面就来讲解如何使用这种缓存框架，以Ehcache与redis整合为例：

步骤①：导入j2cache、redis、ehcache坐标

<dependency>
        <groupId>net.oschina.j2cache</groupId>
        <artifactId>j2cache-core</artifactId>
        <version>2.8.4-release</version>
    </dependency>
    <dependency>
        <groupId>net.oschina.j2cache</groupId>
        <artifactId>j2cache-spring-boot2-starter</artifactId>
        <version>2.8.0-release</version>
    </dependency>
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
    </dependency>

j2cache的starter中默认包含了redis坐标，官方推荐使用redis作为二级缓存，因此此处无需导入redis坐标

步骤②：配置一级与二级缓存，并配置一二级缓存间数据传递方式，配置书写在名称为j2cache.properties的文件中。如果使用ehcache还需要单独添加ehcache的配置文件

# 1级缓存
    j2cache.L1.provider_class = ehcache
    ehcache.configXml = ehcache.xml
    
    # 2级缓存
    j2cache.L2.provider_class = net.oschina.j2cache.cache.support.redis.SpringRedisProvider
    j2cache.L2.config_section = redis
    redis.hosts = localhost:6379
    
    # 1级缓存中的数据如何到达二级缓存
    j2cache.broadcast = net.oschina.j2cache.cache.support.redis.SpringRedisPubSubPolicy

此处配置不能乱配置，需要参照官方给出的配置说明进行。例如1级供应商选择ehcache，供应商名称仅仅是一个ehcache，但是2级供应商选择redis时要写专用的Spring整合Redis的供应商类名SpringRedisProvider，而且这个名称并不是所有的redis包中能提供的，也不是spring包中提供的。因此配置j2cache必须参照官方文档配置，而且还要去找专用的整合包，导入对应坐标才可以使用。

一级与二级缓存最重要的一个配置就是两者之间的数据沟通方式，此类配置也不是随意配置的，并且不同的缓存解决方案提供的数据沟通方式差异化很大，需要查询官方文档进行设置。

步骤③：使用缓存

@Service
    public class SMSCodeServiceImpl implements SMSCodeService {
        
        @Autowired
        private CodeUtils codeUtils;
    
        @Autowired
        private CacheChannel cacheChannel;
    
        public String sendCodeToSMS(String tele) {
        
            String code = codeUtils.generator(tele);
            cacheChannel.set("sms",tele,code);
            return code;
        }
    
        public boolean checkCode(SMSCode smsCode) {
        
            String code = cacheChannel.get("sms",smsCode.getTele()).asString();
            return smsCode.getCode().equals(code);
        }
    }

j2cache的使用和jetcache比较类似，但是无需开启使用的开关，直接定义缓存对象即可使用，缓存对象名CacheChannel。

##### 总结: #####

1.j2cache是一个缓存框架，自身不具有缓存功能，它提供多种缓存整合在一起使用的方案  
2.j2cache需要通过复杂的配置设置各级缓存，以及缓存之间数据交换的方式  
3.j2cache操作接口通过CacheChannel实现