一、Spring Boot与缓存
1、整章思维导图
https://gitmind.cn/app/doc/971798891
2、JSR107 缓存规范
Java Caching定义了5个核心接口，分别是CachingProvider, CacheManager, Cache, Entry 和 Expiry。
- CachingProvider 定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider
- CacheManager 定义了创建、配置、获取、管理和控制多个唯一命名的Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有
- Cache 是一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache仅被一个CacheManager所拥有
- Entry 是一个存储在Cache中的key-value对
- Expiry 每一个存储在Cache中的条目有一个定义的有效期。一旦超过这个时间，条目为过期的状态。一旦过期，条目将不可访问、更新和删除。缓存有效期可以通过ExpiryPolicy设置
3、Spring缓存抽象
Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术，并支持使用JCache（JSR-107）注解简化我们开发
-
Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合
-
Cache 接口下Spring提供了各种xxxCache的实现；如RedisCache，EhCacheCache , ConcurrentMapCache等
-
每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过；如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取
-
使用Spring缓存抽象时我们需要关注以下两点：
1）、确定方法需要被缓存以及他们的缓存策略
2）、从缓存中读取之前缓存存储的数据
4、主要注解
| 注解 | 说明 |
|---|---|
| @EnableCaching | 开启基于注解的缓存 |
| @Cacheable | 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存 |
| @CachePut | 保证方法被调用，又希望结果被缓存，更新缓存 |
| @CacheEvict | 清空缓存 |
| @Caching | 处理复杂规则的缓存，可以一起处理@Cacheable、@CachePut、@CacheEvict |
| @CacheConfig | 作用于类上，统筹类中使用的缓存注解 |
5、注解详细用法及例子
-
@EnableCaching
作用于类上，在Spring Boot中一般配置在项目的启动类上，用于开启基于注解的缓存
-
@Cacheable
作用在类或方法上，一般作用在数据查询的方法上，用于对方法查询的结果进行缓存
作用顺序：
先进行缓存查询，如果为空则进行方法查询，并将结果进行缓存；如果有数据，不进行方法查询，而是直接使用缓存数据
注解属性：
| 属性名 | 说明 |
|---|---|
| value/cacheNames | 指定缓存空间的名称，必须属性，这两个属性二选一 |
| key | 指定缓存数据的key，默认使用方法参数值，可以使用SpEL表达式 |
| keyGenerator | 指定缓存数据key的生成器，与key属性二选一使用 |
| cacheManager | 指定缓存管理器 |
| cacheResolver | 指定缓存解析器，与cacheManager属性二选一使用 |
| condition | 指定在符合某条件下，进行数据缓存 |
| unless | 指定在符合某条件下，不进行数据缓存 |
| sync | 指定是否使用异步缓存，默认false |
注解属性进行具体讲解：
（1）value/cacheNames
value和cacheName属性作用相同，用于指定缓存的名称空间，可以指定多个空间（例如：cacheNames={“comment1”,“comment2”}）。如果只配置了value/cacheNames属性，则属性名可以省略。
// 指定一个缓存空间为user的缓存
@Cacheable(value = "user")
（2）key
key属性的作用是指缓存数据对应的唯一标识，默认使用注解标记的方法参数值，也可以使用SpEL表达式。缓存数据的本质是Map类型数据，key用于指定唯一的标识
如果缓存数据时没有key属性，Spring Boot默认提供的配置类SimpleKeyGenerator会通过generateKey(Object…params)方法参数生成key值。默认情况下，如果generateKey()方法有一个参数，参数值就是key属性的值；如果有没有参数，那么key参数属性是一个空参的SimpleKey[]对象，如果有多个参数，那么key属性是一个带参的SimpleKey[params1,[param2,…]]对象
==SimpleKeyGenerator原码：==
public static Object generateKey(Object... params) {
// 如果注解的方法形参为空
if (params.length == 0) {
// EMPTY 静态方法生成一个对象，作为key
// public static final SimpleKey EMPTY = new SimpleKey(new Object[0]);
return SimpleKey.EMPTY;
} else {
if (params.length == 1) {
// 如果形参为一个，则这个参数的值就作为key
Object param = params[0];
if (param != null && !param.getClass().isArray()) {
return param;
}
}
// 多个值就返回一个多参的对象作为key
return new SimpleKey(params);
}
}
Cache缓存支持的SpEL表达式及说明
| 名字 | 位置 | 描述 | 示例 |
|---|---|---|---|
| methodName | root对象 | 当前被调用的方法名 | #root.methodName |
| method | root对象 | 当前被调用的方法 | #root.method.name |
| target | root对象 | 当前被调用的目标对象 | #root.target |
| targetClass | root对象 | 当前被调用的目标对象类 | #root.targetClass |
| args | root对象 | 当前被调用的方法的参数列表 | #root.args[0] |
| caches | root对象 | 当前方法调用使用的缓存列表（如@Cacheable(value={“cache1”, “cache2”})），则有两个cache | #root.caches[0].name |
| argument Name | root对象 | 方法参数的名字. 可以直接 # 参数名 ，也可以使用 #p0或#a0 的形式，0代表参数的索引 | #comment_id、#a0 、#p0 |
| result | root对象 | 方法执行后的返回值（仅当方法执行之后的判断有效，如‘unless’，’cache put’的表达式 ’cache evict’的表达式beforeInvocation=false） | #result |
// 用缓存列表的第0号user的userName的值作为key
@Cacheable(value = "user",key = "#root.caches[0].userName")
（3）keyGenerator
keyGenerator属性与key属性的本质作用相同，都是用于指定缓存数据的key，只不过keyGenerator属性指定的不是具体的key值，而是key值的生成器规则，由其中指定的生成器生成具体的key，与key属性互斥使用，Spring Boot默认使用SimpleKeyGenerator类生成key值
@Configuration
public class MyCacheConfig{
@Bean("myKeyGenerator")
public KeyGenerator keyGenerator(){
return new KeyGenerator() {
@Override
public Object generate(Object o, Method method, Object... objects) {
// 这里返回的是findAll[[]]
return method.getName()+"["+Arrays.asList(objects).toString()+"]";
}
};
}
}
// 指定keyGenerator的bean id
@Cacheable(value = "user",keyGenerator = "myKeyGenerator")
（4）cacheManager/cacheResolver
指定缓存管理器/缓存解析器，两个属性二选一，默认情况不需要配置，如果存在多个缓存管理器（如Redis、Ehcache等），可以使用这两个属性分别指定
（5）condition
用于对数据进行有 条件的选择性存储，只有当指定条件为true时才会对查询结果进行缓存，可以使用SpEL表达式指定属性值
// comment_id的值大于10才会对结果数据进行缓存
@Cacheable(value = "user",condition = "#comment_id>10")
（6）unless
与condition属性的作用相反，当指定的条件为true时，方法的返回值不会被缓存，可以使用SpEL表达式指定属性值
// comment_id的值大于10不会对结果数据进行缓存
@Cacheable(value = "user",unless = "#comment_id>10")
（7）sync
表示数据缓存缓存过程中是否使用异步模式，默认值为false
-
@CachePut
作用在类或方法上，一般作用在数据更新方法上（增删改），用于更新缓存数据
作用顺序：
先进行方法调用，然后将方法结果更新到缓存中
@CachePut注解和@Cacheable注解的属性完全相同，具体参照上面的@Cacheable属性
// 更新key = "#root.caches[0].userName"里的缓存数据，这里要注意key里面的值要和查询的key一致 @Cacheable(value = "user" key = "#root.caches[0].userName") -
@CacheEvict
作用在类或方法上，一般作用在数据删除方法上，用于删除缓存数据
默认作用顺序：
先进行方法调用，然后清除缓存
@CacheEvict注解和@Cacheable注解的属性基本相同，具体参照上面的@Cacheable属性
@CacheEvict注解额外提供了两个属性allEntries、beforeInvocation
（1）allEntries
表示是否清除指定缓存空间中的所有缓存数据，默认值为false（只删除指定key对应的缓存数据）
// 表示方法执行后会删除缓存空间user中的所有数据 @CacheEvict(value = "user",allEntries = true)（2）beforeInvocation
表示是否在方法执行之前进行缓存清除，默认值为false（在执行方法后再进行删除缓存中的数据）
弊端：
在数据删除的方法中出现了异常，这会导致实际数据并没有被删除，但是缓存数据却被清除了
// 表示会在方法执行之前进行缓存的清除 @CacheEvict(value = "user",beforeInvocation = true) -
@Caching
作用在类或方法上，用来处理复杂的数据缓存规则
包含cacheable、put、evict上个属性，它们的作用等同于@Cacheable、@CachePut、@CacheEvict
// 有@Cacheable和@CachePut的功能 @Cacheing(cacheable={@Cacheable(value = "user",key = "#id")}, put={@CachePut(cacheName = "user",key = "result.author")}) -
@CacheConfig
作用在类上，用来统筹@Cacheable、@CachePut、@CacheEvict注解标准方法中的公共属性
// 表示整个类都以user作为缓存的命名空间，若该类的某个方法相同的属性，那么该属性值会使用就近原则 @CacheConfig(cacheNames = "user")
6、缓存的工作原理
-
配置类CacheAutoConfiguration执行
-
缓存的配置类（默认使用SimpleCacheConfiguration）
org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration -
通过CacheConfigurationImportSelector类导入配置文件
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
CacheType[] types = CacheType.values();
String[] imports = new String[types.length];
// 通过这个类按上面配置类的顺序导入配置文件
// 类生效的判断条件，只有满足的类才会生效
// @ConditionalOnMissingBean({CacheManager.class})
// @Conditional({CacheCondition.class})
for(int i = 0; i < types.length; ++i) {
imports[i] = CacheConfigurations.getConfigurationClass(types[i]);
}
return imports;
}
- SimpleCacheConfiguration的作用：给容器中注册了一个CacheManager：ConcurrentMapCacheManager
@Bean
ConcurrentMapCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers) {
ConcurrentMapCacheManager cacheManager = new ConcurrentMapCacheManager();
List<String> cacheNames = cacheProperties.getCacheNames();
if (!cacheNames.isEmpty()) {
cacheManager.setCacheNames(cacheNames);
}
return (ConcurrentMapCacheManager)cacheManagerCustomizers.customize(cacheManager);
}
- ConcurrentMapCacheManage：获取和创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentHashMap<String,Cache>中
private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentHashMap(16);
-
如果不指定key的值，默认使用SimpleKeyGenerator生成key的值，然后以key:value的形式放进Cache中
7、Spring Boot整合Redis
- 添加Data Redis的依赖启动器
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
- 配置redis
spring:
redis:
host: 121.199.34.225
password: 123
port: 6379
-
基于注解的Redis缓存
请参考上面的注解
注意：redis中的key值是以"命名空间::key"的字符串体现，实体类要实现序列化，value值经过JDK默认序列化格式
-
基于API的Redis缓存
（1）Redis命令http://www.redis.cn/commands.html
（2）操作redis用StringRedisTemplate.opsForXxx().xxx 或 RedisTemplate.opsForXxx().xxx
/** * Redis常见的五大数据类型 * String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合） * stringRedisTemplate.opsForValue()[String（字符串）] * stringRedisTemplate.opsForList()[List（列表）] * stringRedisTemplate.opsForSet()[Set（集合）] * stringRedisTemplate.opsForHash()[Hash（散列）] * stringRedisTemplate.opsForZSet()[ZSet（有序集合）] */ // 注入StringRedisTemplate，操作k-v都是字符串的 @Autowired StringRedisTemplate stringRedisTemplate; // 注入RedisTemplate，操作k-v都是对象的 @Autowired RedisTemplate RedisTemplate; @Test void testRedis(){ // 将value为hello的数据放进key为msg中 stringRedisTemplate.opsForValue().set("msg","hello"); // 拿到key为msg的值 String msg = stringRedisTemplate.opsForValue().get("msg"); System.out.println(msg); // redisTemplate存入对象，主意：实体类要实现序列化的接口，不然程序编译出错 List<User> users = userDao.findAll(); redisTemplate.opsForValue().set("user",users); } -
自定义RedisTemplate序列化机制（解决API方式）
因为默认使用JDK的JdkSerializationRedisSerializer进行序列化的，不便于使用可视化管理工具进行查看和管理，原理跳转
// 定义一个配置类
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
RedisTemplate<Object,Object> template = new RedisTemplate<>();
template.setConnectionFactory(redisConnectionFactory);
// 创建一个Jackson2JsonRedisSerializer对象
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
// 将默认的序列化规则改为json
template.setDefaultSerializer(jackson2JsonRedisSerializer);
// 返回RedisTemplate
return template;
}
}
-
自定义RedisCacheManager序列化机制（解决注解方式）
这里的配置适用于Spring Boot2.x版本，1.x不适用，原理跳转
@Configuration
public class RedisManager {
@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory){
// 分别创建key和value的格式化序列对象
RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(stringRedisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();
RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(cacheConfiguration).build();
return cacheManager;
}
}
8、Spring Boot整合Redis的原理
- 配置类CacheAutoConfiguration执行
- 导入的org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration配置类根据引入的依赖判断生效
- RedisCacheConfiguration创建一个RedisCacheManager对象，放在容器中
@Bean
RedisCacheManager cacheManager(CacheProperties cacheProperties, CacheManagerCustomizers cacheManagerCustomizers, ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration, ObjectProvider<RedisCacheManagerBuilderCustomizer> redisCacheManagerBuilderCustomizers, RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) {
RedisCacheManagerBuilder builder = RedisCacheManager.builder(redisConnectionFactory).cacheDefaults(this.determineConfiguration(cacheProperties, redisCacheConfiguration, resourceLoader.getClassLoader()));
List<String> cacheNames = cacheProperties.getCacheNames();
if (!cacheNames.isEmpty()) {
builder.initialCacheNames(new LinkedHashSet(cacheNames));
}
if (cacheProperties.getRedis().isEnableStatistics()) {
builder.enableStatistics();
}
redisCacheManagerBuilderCustomizers.orderedStream().forEach((customizer) -> {
customizer.customize(builder);
});
return (RedisCacheManager)cacheManagerCustomizers.customize(builder.build());
}
private org.springframework.data.redis.cache.RedisCacheConfiguration determineConfiguration(CacheProperties cacheProperties, ObjectProvider<org.springframework.data.redis.cache.RedisCacheConfiguration> redisCacheConfiguration, ClassLoader classLoader) {
return (org.springframework.data.redis.cache.RedisCacheConfiguration)redisCacheConfiguration.getIfAvailable(() -> {
return this.createConfiguration(cacheProperties, classLoader);
});
}
private org.springframework.data.redis.cache.RedisCacheConfiguration createConfiguration(CacheProperties cacheProperties, ClassLoader classLoader) {
Redis redisProperties = cacheProperties.getRedis();
org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig();
config = config.serializeValuesWith(SerializationPair.fromSerializer(new JdkSerializationRedisSerializer(classLoader)));
if (redisProperties.getTimeToLive() != null) {
config = config.entryTtl(redisProperties.getTimeToLive());
}
if (redisProperties.getKeyPrefix() != null) {
config = config.prefixCacheNameWith(redisProperties.getKeyPrefix());
}
if (!redisProperties.isCacheNullValues()) {
config = config.disableCachingNullValues();
}
if (!redisProperties.isUseKeyPrefix()) {
config = config.disableKeyPrefix();
}
return config;
}
- RedisCacheManager创建一个RedisCache对象
protected RedisCache createRedisCache(String name, @Nullable RedisCacheConfiguration cacheConfig) {
return new RedisCache(name, this.cacheWriter, cacheConfig != null ? cacheConfig : this.defaultCacheConfig);
}
- RedisCache对象里面包含操作redis的方法
9、Spring Boot整合Redis的序列化原理
-
自定义RedisTemplate序列化原理
（1）RedisAutoConfiguration中的RedisTemplate原码
@Bean // 判断容器中是否存在redisTemplate的bean，若不存在则创建一个RedisTemplate对象放进容器中 @ConditionalOnMissingBean( name = {"redisTemplate"} ) @ConditionalOnSingleCandidate(RedisConnectionFactory.class) public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<Object, Object> template = new RedisTemplate(); template.setConnectionFactory(redisConnectionFactory); return template; }（2）RedisTemplate默认使用JDK的序列化机制
if (this.defaultSerializer == null) { this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader()); }（3）我们只需要自定义一个RedisTemplate的bean对象放进容器中，RedisAutoConfiguration自动配置类就不会帮我们自动创建RedisTemplate对象
（4）我们只需仿照原码来，并在原码的基础上更改默认的序列化机制即可
-
自定义RedisCacheManager序列化原理
（1）在RedisCacheConfiguration配置类中默认使用JDK的序列化机制
org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig(); config = config.serializeValuesWith(SerializationPair.fromSerializer(new JdkSerializationRedisSerializer(classLoader)));（2）我们也只需像自定义RedisTemplate序列化原理一样创建一个RedisCacheManager对象放进容器中
（3）我们只需在原码的基础上修改默认的序列化机制
即可
-
自定义RedisCacheManager序列化原理
（1）在RedisCacheConfiguration配置类中默认使用JDK的序列化机制
org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig(); config = config.serializeValuesWith(SerializationPair.fromSerializer(new JdkSerializationRedisSerializer(classLoader)));（2）我们也只需像自定义RedisTemplate序列化原理一样创建一个RedisCacheManager对象放进容器中
（3）我们只需在原码的基础上修改默认的序列化机制
（4）因为RedisCacheManager对象的创建包含两个类，我们要把两个类写成一个类（像原码两个类一样也行）即可
319
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
