【开发篇】十二、缓存框架JetCache

上篇完成了Spring Cache底层技术的各种切换，但各个技术有各自的优缺点，因此阿里的Jetcache框架出现。 注意Jetcache是一个框架，做的是一个整合和封装，自身不是像redis一样的缓存实现技术，Jetcache框架底层还得依靠具体的缓存实现技术，它是和Spring Cache同等级的，用来替换Spring Cache的。

0、介绍

JetCache对SpringCache进行了封装，在原有功能基础上实现了多级缓存、缓存统计、自动刷新、异步调用、数据报表等功能

JetCache设定了本地缓存与远程缓存的多级缓存解决方案，其中本地缓存（local）支持：

• LinkedHashMap
• Caffeine

远程缓存（remote）支持：

• Redis
• Tair

1、JetCache远程缓存

先引入依赖

<dependency>    
	<groupId>com.alicp.jetcachegroupId>   
	<artifactId>jetcache-starter-redisartifactId>    
	<version>2.6.2version>
dependency>
1
2
3
4
5

远程缓存的属性配置：

jetcache:  
  remote:    
    default:      
      type: redis      
      host: localhost      
      port: 6379   
      password: admin1234   
      poolConfig:        
        maxTotal: 50
    # 再定义一个缓存区域也行
    myArea:
      type: redis
      host: .......

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@EnableCreateCacheAnnotation启动用注解来创建缓存，开启后就可以用@CreateCache来创建一个缓存对象。

@SpringBootApplication

@EnableCreateCacheAnnotation

public class CacheApplication {    

	public static void main(String[] args) {   
	    
		SpringApplication.run(CacheApplication.class, args);    
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13

使用@CreateCache注解声明一个缓存对象：

@Service
public class SMSCodeServiceImpl implements SMSCodeService {

    @CreateCache(area = "default", name = "smsCache::", expire = 3600, timeUnit = TimeUnit.SECONDS, cacheType = CacheType.REMOTE)  
    private Cache<String, String> jetSMSCache;
    //...

}

1
2
3
4
5
6
7
8
9

注意@CreateCache注解的属性：

• area：用哪块存储空间，默认值为default，即配置文件里的jetcache.remote.default及其下面的配置，可以再自己定义区域
• name：key的分组前缀，常用str::或者str_
• expire：过期时间，单位默认秒
• timeUnit：时间单位，默认值秒
• cacheType：缓存类型，local即本地缓存，remote即远程缓存，all即两个都写，默认远程缓存

操作缓存：使用缓存对象.put和get

@Service
public class SMSCodeServiceImpl implements SMSCodeService {    

	@Override   
	public String sendCodeToSMS(String tele) {     
	   
		String code = this.codeUtils.generator(tele);  
		      
		jetSMSCache.put(tele,code);    //put
		    
		return code;    
	}   
	
	@Override    
	public boolean checkCode(String tele,String code) {  
	      
		String value = jetSMSCache.get(tele);     //get
		   
		return code.equals(value);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

重启服务，调用之前的缓存接口查看效果。出现了一个莫名奇妙的循环依赖，先临时解决下，跳过了：

spring:
	main:
    	allow-circular-references: true

1
2
3
4

发现接口调用正常，启动日志也输出了相关信息：

2、JetCache本地缓存

和远程一样，引入依赖后，配置文件不同：

jetcache:  
  local:    
    default:     
      type: linkedhashmap      
      keyConvertor: fastjson # 即key不是String时，用哪个转换器转为String

1
2
3
4
5
6

再后面一样的操作，开启缓存注解支持、声明缓存对象、put和get都一样，需要注意的是上面的CacheType属性改为Local

@CreateCache(name = "smsCache::", expire = 3600, cacheType = CacheType.LOCAL)  
private Cache<String, String> jetSMSCache;
1
2

3、标准配置文件

JetCache能同时支持本地和远程缓存，所以标准的配置文件写一起就行：

jetcache:  
  statIntervalMinutes: 15  
  areaInCacheName: false    # 即key里加不加area的名字，true时key形如default_myname::key
  
  local:    
    default:      
      type: linkedhashmap      
      keyConvertor: fastjson      
      limit: 100  
      
  remote:
    default:      
      host: localhost      
      port: 6379      
      type: redis      
      keyConvertor: fastjson      
      valueEncoder: java      
      valueDecoder: java      
      poolConfig:        
        minIdle: 5        
        maxIdle: 20       
        maxTotal: 50

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

关于配置的含义：

4、JetCache方法缓存注解–@Cached

上面写缓存得创建JetCache缓存对象后put和get，如何像@Cacheable注解一样，对整个方法的结果通过加注解来自动写查缓存？

答案是在@EnableCreateCacheAnnotation的基础上，再加注解@EnableMethodCache(basePackages = "com.mydemo")，开启对方法缓存注解的支持，basePackeages属性写需要用到方法缓存注解的包路径。

@SpringBootApplication
@EnableCreateCacheAnnotation  ####！
@EnableMethodCache(basePackages = "com.mydemo") ####！
public class JetCacheApplication {  
  
	public static void main(String[] args) { 
	       
		SpringApplication.run(JetCacheApplication.class, args);    
		
	}
}

1
2
3
4
5
6
7
8
9
10
11
12

@Cached注解加需要缓存的方法上，如此查到的Book对象就被缓存到default的Area，且是远程缓存

@Service
public class BookServiceImpl implements BookService {    

	@Autowired    
	private BookDao bookDao;   
	 
	@Cached(name = "smsCache_", key = "#id", expire = 3600) 
	@Override      
	public Book getById(Integer id) {
		return bookDao.selectById(id);    
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面@Cache注解的cacheType属性没写，那就是默认的远程缓存。此时，调用接口返回正常，但接口日志有异常：

需要加一个配置，指定key的转换器给本地和远程缓存：

再重启，接口正常，但日志仍有报错NotSerializableException，这个就很明确了，Java对象存进缓存时，要转为json，而要存的对象的实体类没去实现序列化接口，实现下Serializable接口就行。

实现序列化接口后，别忘了要在配置中加：

valueEncoder: java      
valueDecoder: java    
1
2

即，编码时的是java对象，解码时，也要转汇Java对象。

5、@Cached

重新整理下@Cached注解，它的属性和@CreateCache的一样，但多了几个，放一起整理了：

整体有点像@Cacheable注解。重点注意下area，一块一块的缓存区域。

4、@CacheUpdate

方法上加了@Cached后，方法返回值被写进缓存，但如果持久层被update，再查数据时。从缓存中拿到的数据就不对了，可通过在更新持久层的方法上加@CacheUpdate注解解决。先看这个注解属性：

@Service
public class BookServiceImpl implements BookService {

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

}
1
2
3
4
5
6
7
8
9

对照上面的@Cached注解的key来看这个@CacheUpdate的key。此时，调用查询接口，返回更新后的数据，且不会查持久层，因为缓存已被更新，到不了持久层。

5、@CacheInvalidate

和更新一样，如果持久层数据被删除，如何通知到缓存呢，答案是@CacheInvalidate注解。

@Service
public class BookServiceImpl implements BookService {

	@CacheInvalidate(name = "smsCache_", key = "#id")    
	public boolean delete(Integer id) {        
		return bookDao.deleteById(id) > 0;    
	}
}
1
2
3
4
5
6
7
8

这样，当delete方法执行，持久层数据被删除时，缓存也就被删掉了。此时，调用查询接口，会去查持久层！！查持久层才合理，缓存里都没数据了，不去持久层看看停在缓存层干嘛 。这个注解属性和更新缓存注解一样，少了value，参照上文。

6、@CacheRefresh

以上，不管是更新还是删除，总在我的服务中，我自己掌握，我自己加了注解去通知缓存跟着变。但如果持久层更新的操作是在别的部门管理的服务里呢？即在缓存层无感知，如何保证数据最新，答案是@CacheRefresh，每隔一定间隔去查数据库，刷新缓存值。 先看注解属性：

以上即，查到的Book对象缓存起来，且没10秒去数据库查一下，然后刷新缓存里的Book值

7、缓存统计报告

在服务配置文件application.yaml中加以下配置：

jetcache:
  statIntervalMinutes: 15
  # statInterval即统计间隔，也就是15分钟一统计
1
2
3

重启服务，控制台每隔15分钟输出一次统计数据，值为0时即不统计，（直接不写就行，不用写了又给个0值），效果如下：

查询26次，命中缓存21次。