一直以来对缓存都是一知半解，从没有正经的接触并使用一次，今天腾出时间研究一下缓存技术，开发环境为OpenJDK17与SpringBoot2.7.5
源代码下载地址：https://hanzhe.lanzoue.com/iK4AF0hjl3lc
SpringCache基础概念
首先看看SpringCache中提供的两个主要接口，第一个是CacheManager缓存管理器接口，在接口名的位置按F4(IDEA Eclipse快捷键)可查看接口的实现，其中最底下的ConcurrentMapCacheManager就是缓存管理器默认实现，在不进行任何配置的情况下直接使用缓存默认使用的就是基于Map集合的缓存
在ConcurrentMapCacheManager实现类中可以看到，该实现类主要维护Map类型的cacheMap属性，Value为Cache类型的接口，点进该接口可以发现他同样有基于Map的实现类ConcurrentMapCache，开启Debug调试后简单测试了一下，代码走到了这个位置也确定了使用的就是该类
Cache接口就是就是第二个要了解的接口，梳理一下，CacheManager为缓存管理器并且管理着Cache对象，而被管理的Cache提供了操作缓存数据的方法
上面介绍了SpringCache中两个接口，这里来了解一下缓存需要的注解，开发中最常用的就是基于注解的缓存
前三个注解用于对缓存数据进行增删改查操作，@Caching注解的作用就是将前三个注解组合使用，适用于有关联关系的缓存数据，@CacheConfig则是针对本类中的缓存做一些通用的配置
使用SpringCache
在写这篇文章之前也参考过一些其他博主的文章，好多文章都要求引用spring-boot-starter-cache启动器，但据我测试不引用该启动器也可以实现缓存功能，相关的类和注解在spring-context包中就已经存在了，我不太清楚为什么他们要引用spring-boot-starter-cache，如果您懂的话麻烦在评论区指点下
编写测试环境
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.10</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserEntity implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
}
@Repository
public class UserMapper {
public final List<UserEntity> users = CollUtil.newArrayList();
@PostConstruct
public void init() {
users.add(new UserEntity(1, "用户" + 1));
users.add(new UserEntity(2, "用户" + 2));
users.add(new UserEntity(3, "用户" + 3));
users.add(new UserEntity(4, "用户" + 4));
}
public List<UserEntity> list() {
return this.users;
}
public UserEntity getOne(Integer id) {
return this.users.stream()
.filter(user -> NumberUtil.equals(user.getId(), id))
.findFirst()
.orElse(null);
}
public void update(UserEntity entity) {
this.delete(entity.getId());
users.add(entity);
}
public void delete(Integer id) {
UserEntity entity = this.getOne(id);
if (ObjectUtil.isNotNull(entity)) {
users.remove(entity);
}
}
}
@Slf4j
@Service
public class UserService {
@Autowired
private UserMapper mapper;
public List<UserEntity> selectList() {
List<UserEntity> list = mapper.list();
log.info("list：{}", list.size());
return list;
}
public UserEntity getOne(Integer id) {
log.info("getOne：{}", id);
return mapper.getOne(id);
}
public UserEntity update(UserEntity entity) {
log.info("update：{}", entity);
mapper.update(entity);
return entity;
}
public void delete(Integer id) {
log.info("delete：{}", id);
mapper.delete(id);
}
public void clear() {}
}
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService service;
@GetMapping("selectList")
public Object selectList() {
return success(service.selectList());
}
@GetMapping("getOne")
public Object getOne(Integer id) {
return success(service.getOne(id));
}
@GetMapping("update")
public Object update(UserEntity entity) {
service.update(entity);
return success();
}
@GetMapping("delete")
public Object delete(Integer id) {
service.delete(id);
return success();
}
@GetMapping("clear")
public Object clear() {
service.clear();
return success();
}
/* ---------工具方法 --------- */
public Map<String, Object> success(Object obj) {
Map<String, Object> result = success();
result.put("data", obj);
return result;
}
public Map<String, Object> success() {
Map<String, Object> result = MapUtil.newHashMap();
result.put("code", 200);
result.put("msg", "success");
return result;
}
}
@EnableCaching
@SpringBootApplication
public class BootCacheApplication {
public static void main(String[] args) {
SpringApplication.run(BootCacheApplication.class, args);
}
}
测试环境的编写到此位置，可以试着请求一下接口看看是否搭建成功，以及控制台中是否有对应的日志打印
使用注解缓存
注解缓存主要是@Cacheable、@CachePut、@CacheEvict这三种，且参数都基本相同，用过一次的参数基本就不重复说了，接下来测试在Service层中添加缓存注解
@Cacheable
该注解适用于查询方法，将查询返回的结果放到缓存中，下次接收到请求直接返回缓存中的数据，先将注解按照下面的写法加到代码中，然后调用看看效果
// @Cacheable(cacheNames = "USERS", key = "#root.methodName")
@Cacheable(cacheNames = "USERS", key = "'selectList'")
public List<UserEntity> selectList() { ... }
// @Cacheable(cacheNames = "USERS", key = "#id")
@Cacheable(cacheNames = "USERS", key = "#root.args[0]")
public UserEntity getOne(Integer id) { ... }
注解加上后反复请求这两个接口，可以发现相同的请求Service日志只打印了一次，因为数据已经添加到缓存不会在执行Service代码了
现在来看一下@Cacheable注解中的参数，首先来看cacheNames，该参数可以理解为一个组，cacheNames相同的缓存会放到同一个Cache对象中进行管理，例如USERS中只维护与用户相关的缓存，DEPTHS中只维护部门相关的缓存，就是ConcurrentMapCacheManager中cacheMap的结构
第二个参数key代表的是缓存数据在该组中的唯一标识，通过观察Cache对象可以看出来
需要注意的是key的参数需要使用SpEL表达式，如果想直接使用字符串作为key的话需要用单引号括起来
- #root.methodName：获取方法名
- #id：获取参数列表中的id属性
- #root.args[0]：获取参数列表中第一个参数
- #result：返回结果对象
- 更多用法详见官方文档
除了上面用到的两个参数之外，这里在介绍一个bool类型参数condition，该参数的作用是做条件判断，只有判断结果为true注解才会生效，现在修改一下Service中的注解，添加condition条件
/**
* 只有ID为1时才进行缓存，其他数据直接执行Service代码
*/
@Cacheable(cacheNames = "USERS", key = "#root.args[0]", condition = "#id == 1")
public UserEntity getOne(Integer id) { ... }
condition的作用是只有判断结果为true结果才生效，同时有个与他相对的unless注解，判断结果为true时注解失效
/**
* 只有ID为1时不执行缓存，每次都会执行Service代码
* 其他数据正常缓存
*/
@Cacheable(cacheNames = "USERS", key = "#root.args[0]", unless = "#id == 1")
public UserEntity getOne(Integer id) { ... }
当系统中配置了多个缓存实现的时候，可以在注解中传入缓存管理器的bean名称来指定该缓存使用哪个实现，如下图所示，这里就不演示了
在多线程的情况下缓存数据可能会被重复操作多次，如果缓存数据比较敏感可以使用sycn属性将缓存数据设置为多线程安全，不过一般很少有人会将敏感数据存放到缓存中，所以sync默认为关闭状态，也很少会有人开启他，而且需要注意的是并不是所有缓存实现类都可以实现该功能，目前可以肯定的是Spring官方给出的所有CacheMapper实现类都支持这个属性，属性并不常用图省事儿这里也就不演示了
修改缓存key的生成规则，在注解中使用keyGenerator参数后就不能在使用key，缓存key的生成规则由keyGenerator来决定，如果想对某个接口使用自定义规则key，需要向ioc容器中注入SimpleKeyGenerator类型的bean，然后将bean的名称传入keyGenerator即可，如下图所示，这里就不演示了
@CachePut
在使用该注解之前先来做一个小测试，将getOne注解上的condition和unless条件清除，读取ID为1的用户数据，然后修改该用户的数据，修改过后在读取一次该用户的数据，看看效果如何
可以发现虽然我修改了ID为1的用户数据，但是查询该数据时返回的仍是旧数据，这时就需要使用@CachePut注解更新缓存数据，该注解会用方法的返回结果更新掉缓存中的旧数据
/**
* 在getOne中缓存数据的key为#root.args[0]，代表的是参数列表中第一位，也就是用户ID
* 那么在update方法中用来更新缓存数据的也应该是用户ID，也就是返回结果中的id： #result.id
*/
@CachePut(cacheNames = "USERS", key = "#result.id")
public UserEntity update(UserEntity entity) { ... }
@CacheEvict
@CacheEvict注解的作用就是删除缓存中的旧数据，通过参数key来指定删除的是哪一条，同时该注解还有allEntries参数，在不使用key的情况下设置allEntries为true可以清空该cacheNames下所有缓存
@CacheEvict(cacheNames = "USERS", key = "#id")
public void delete(Integer id) { ... }
@CacheEvict(cacheNames = "USERS", allEntries = true)
public void clear() {}
这里可以自行调用测试并查看日志打印情况，我就不上传截图了
@Caching
该注解的作用是组合其他注解使用，例如删除了该用户后，还需要删除该用户的登录信息，就可以使用到该注解
@Caching(evict= {
@CacheEvict(cacheNames = "USERS", key = "#id"),
@CacheEvict(cacheNames = "TOKENS", key = "#id")
})
public void delete(Integer id) { ... }
@CacheConfig
@CacheConfig可以针对当前类的所有缓存注解进行统一配置，例如之前在每个注解上都使用了cacheNames属性，在使用了@CacheConfig注解后只需要在该类上标注cacheNames那么类中的注解就可以省去该参数了
@Slf4j
@Service
@CacheConfig(cacheNames = "USERS")
public class UserService {
@Autowired
private UserMapper mapper;
@Cacheable(key = "'selectList'")
public List<UserEntity> selectList() { ... }
@Cacheable(key = "#root.args[0]")
public UserEntity getOne(Integer id) { ... }
@CachePut(key = "#result.id")
public UserEntity update(UserEntity entity) { ... }
@Caching(evict= {
@CacheEvict(key = "#id"),
@CacheEvict(cacheNames = "TOKENS", key = "#id")
})
public void delete(Integer id) { ... }
@CacheEvict(allEntries = true)
public void clear() {}
}
使用编程式缓存
编程式缓存，指在代码中操作缓存数据，之前提到过SpringCache中有提供Cache接口，我们通过代码操作缓存靠的就是这个接口，直接在Controller里演示一下
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private CacheManager cacheManager;
@GetMapping("/test")
public Object test() {
// 通过cacheManager获取维护用户缓存的Cache对象
Cache cache = cacheManager.getCache("USERS");
// 向缓存中添加数据
cache.put(8, new UserEntity(8, "用户8"));
cache.put(9, new UserEntity(9, "用户9"));
// 打印测试
System.out.println(cache.get(8, UserEntity.class));
System.out.println(cache.get(9, UserEntity.class));
// 移除其中一个缓存数据
cache.evict(8);
// 打印测试
System.out.println(cache.get(8, UserEntity.class));
System.out.println(cache.get(9, UserEntity.class));
// 清空缓存数据
cache.clear();
// 打印测试
System.out.println(cache.get(8, UserEntity.class));
System.out.println(cache.get(9, UserEntity.class));
return success();
}
// 省略多余代码 .....
}
整合Redis为缓存实现
整合Redis需要引用Redis的场景启动器
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
添加Redis场景启动器后刷新Maven依赖，然后在回过头来看CacheManager接口的实现类，会发现多了基于Redis的缓存实现
之后在配置文件中添加Redis的连接信息，重启项目就可以请求接口进行测试了
spring:
redis:
host: 192.168.1.34
port: 6379
password: redis
database: 1
修改配置文件
我们可以通过配置文件来对缓存进行一些设置，找到缓存的自动配置类CacheAutoConfiguration可以看到类中启用了CacheProperties
在CacheProperties类可以知道配置文件中可以设置哪些属性，例如指定使用Redis作为缓存实现，不过当我们引入Redis场景启动器后，缓存的默认实现已经被设置为Redis，所以这个设置也可以忽略
spring:
cache:
type: redis
指定cacheNames集
在缓存注解中使用的cacheNames的作用是对缓存数据进行分组，当缓存中没有这个组的时候会自动创建这个组，同时该属性可以在配置文件中设置，不过需要注意的是一旦在配置文件中指定cacheNames，那么缓存注解将不再提供自动创建的功能，使用不存在的cacheNames会报错
spring:
cache:
type: redis
cache-names:
- USERS
- DEPT
- ...
Redis配置项
配置项一个个介绍比较麻烦，这里直接将Redis的配置项列出来，配置项对应CacheProperties.redis属性
spring:
cache:
# 指定Redis作为缓存实现
type: redis
# 指定项目中的cacheNames
cache-names:
- USERS
redis:
# 缓存过期时间为10分钟，单位为毫秒
time-to-live: 600000
# 是否允许缓存空数据，当查询到的结果为空时缓存空数据到redis中
cache-null-values: true
# 为Redis的KEY拼接前缀
key-prefix: "BOOT_CACHE:"
# 是否拼接KEY前缀
use-key-prefix: true
# 是否开启缓存统计
enable-statistics: false
修改Redis缓存为JSON
缓存功能已经实现，但是根据之前的测试来看，存到Redis中的数据是一堆乱码不利于查看和维护，这里修改下Redis缓存的序列化
源码分析
源码分析部分比较枯燥，可跳过
在缓存的自动配置类CacheAutoConfiguration中可以看到使用@Import注解引用了CacheConfigurationImportSelector类，该类实现了ImportSelector接口，可以动态的向ioc容器中注入指定的bean
而在CacheConfigurationImportSelector类中遍历了CacheType枚举，这个CacheType正对应着一开始在配置文件中所写的spring.cache.type=redis，在代码结束的位置也看到了Redis的缓存配置类RedisCacheConfiguration
这里挑重点直接看RedisCacheConfiguration配置类，在该配置类中使用@Bean向ioc容器中添加了CacheManager的实现，被Bean标注的方法参数列表默认都是可以在ioc容器中找到的，而这个参数列表中包含RedisCacheConfiguration
需要注意当前所在的位置是autoconfigure.cache包，而参数列表中的RedisCacheConfiguration类是data.redis.cache包下的，这是两个不同的类
这里顺着该对象往下看调用，先是调用了determineConfiguration，而后调用了createConfiguration，在createConfiguration可以看出Redis默认使用的是JDK的序列化实现
回过头来看一眼，参数列表中好像并不是RedisCacheConfiguration对象，而是RedisCacheConfiguration类型的ObjectProvider对象，这里解释一下ObjectProvider是对象提供者，他会优先取ioc容器中该类型的Bean，如果没有就使用自己的对象，具体可以看determineConfiguration方法
这样一来事情思路就理清了，只要使用ObjectProvider的特点，自己向IOC容器中提供一个RedisCacheConfiguration对象就可以覆盖掉原本的配置了
功能实现代码
先创建个Redis缓存配置类，编写一个@Bean的方法返回RedisCacheConfiguration对象，为了防止配置文件中的配置项失效，这里直接将上面的createConfiguration方法体复制过来，将CacheProperties放到参数列表中，他会自己去ioc容器中取，另一个参数是JDK序列化用到的，这里用不上就不拿过来了
然后将代码中的JDK序列化删掉，通过Ctrl + P（IDEA Eclipse快捷键）可以看到他需要RedisSerializer类型的序列化对象
点开这个接口查看他的实现类，发现Redis提供了两个JSON序列化对象
下面的是带有泛型的序列化器，这里推荐通用的GenericJackson2JsonRedisSerializer，该类有空参构造直接new对象即可，替换掉JDK序列化
@Configuration
public class CustomRedisConfig {
@Bean
public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
// 获取Redis配置信息
CacheProperties.Redis redisProperties = cacheProperties.getRedis();
// 获取Redis默认配置
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
// 指定序列化器为GenericJackson2JsonRedisSerializer
config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
// 过期时间设置
if (redisProperties.getTimeToLive() != null) {
config = config.entryTtl(redisProperties.getTimeToLive());
}
// KEY前缀配置
if (redisProperties.getKeyPrefix() != null) {
config = config.prefixCacheNameWith(redisProperties.getKeyPrefix());
}
// 缓存空值配置
if (!redisProperties.isCacheNullValues()) {
config = config.disableCachingNullValues();
}
// 是否启用前缀
if (!redisProperties.isUseKeyPrefix()) {
config = config.disableKeyPrefix();
}
return config;
}
}
这样一来JSON序列化功能就完成了，可以重启检查一下效果，由于反序列化的需要，JSON的每个对象中都添加了class信息
修改前缀生成规则
Redis的KEY一般用:来区分层级，这是个约定俗成的习惯，我使用的Redis可视化工具也会基于:将key放在不同文件夹下进行分组展示，可是RedisCache生成的KEY中间有个双冒号，导致可视化界面中有一层文件夹是空的，强迫症表示难以接受，这个问题必须解决
前缀的生成靠的是CacheKeyPrefix，点开这个类可以看到他将双冒号直接写死在代码中了，我们需要自定义接口去继承他，然后代替他
public interface CustomKeyPrefix extends CacheKeyPrefix {
String SEPARATOR = ":";
String compute(String cacheName);
static CustomKeyPrefix simple() {
return (name) -> name + SEPARATOR;
}
static CustomKeyPrefix prefixed(String prefix) {
Assert.notNull(prefix, "Prefix must not be null!");
return (name) -> prefix + name + SEPARATOR;
}
}
回到刚刚创建的Redis缓存配置类中，
@Configuration
public class CustomRedisConfig {
@Bean
public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
// 获取Redis配置信息
CacheProperties.Redis redisProperties = cacheProperties.getRedis();
// 获取Redis默认配置
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
// 指定序列化器为GenericJackson2JsonRedisSerializer
config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
// 过期时间设置
if (redisProperties.getTimeToLive() != null) {
config = config.entryTtl(redisProperties.getTimeToLive());
}
// 替换前缀生成器（有前缀和无前缀）
config = config.computePrefixWith(CustomKeyPrefix.simple());
if (redisProperties.getKeyPrefix() != null) {
config = config.computePrefixWith(CustomKeyPrefix.prefixed(redisProperties.getKeyPrefix()));
}
// 缓存空值配置
if (!redisProperties.isCacheNullValues()) {
config = config.disableCachingNullValues();
}
// 是否启用前缀
if (!redisProperties.isUseKeyPrefix()) {
config = config.disableKeyPrefix();
}
return config;
}
}
问题结局，可以重启后检查一下效果，非常滴完美