6.1 默认缓存管理

Spring Boot继承了Spring框架的缓存管理功能，通过使用@EnableCaching注解开启基于注解的缓存支持，Spring Boot就可以启动缓存管理的自动化配置。

6.1.1 搭建测试环境

主要是搭建一个springboot的web服务，使用jpa连接Mysql数据库，编写查询接口。

@Service 
public class CommentService {   
    @Autowired private CommentRepository commentRepository; 
    public Comment findCommentById(Integer id){ 
        Optional<Comment> comment = commentRepository.findById(id);                             if(comment.isPresent()){ 
            Comment comment1 = comment.get(); 
            return comment1;                                   
        }
        return null;
    }
}

多次查询发现每次都会向数据库查询一次，也就是结果并没有缓存。

6.1.2 默认缓存实现

在项目启动类添加注解@EnableCaching

@EnableCaching // 开启Spring Boot基于注解的缓存管理支持 @SpringBootApplication 
@SpringBootApplication
public class Springboot04CacheApplication { 
 public static void main(String[] args) {                                                      SpringApplication.run(Springboot04CacheApplication.class, args); 
 } 
}

使用@Cacheable对操作方法进行缓存管理，标记在service类上，对查询结果进行缓存。该注解的作用是将查询结果Comment存放在Spring Boot默认缓存中名称为comment 的名称空间（namespace）中，对应缓存唯一标识。（即缓存数据对应的主键k）默认为方法参数comment_id的值，如果没有参数或多个参数，他会使用springboot的默认值。

@Service 
public class CommentService {   
 @Autowired private CommentRepository commentRepository; 
 @Cacheable(cacheNames = "comment")
 public Comment findCommentById(Integer id){ 
     Optional<Comment> comment = commentRepository.findById(id);                             if(comment.isPresent()){ 
         Comment comment1 = comment.get(); 
         return comment1;                                   
     }
     return null;
 }
}

cacheNames=“comment”，comment是该空间的唯一标识，通过该标识找到cache，cache中维护了多个(K,V)值。
底层结构：在诸多的缓存自动配置类中, SpringBoot默认装配的是 SimpleCacheConfiguration , 他使用的 CacheManager 是 ConcurrentMapCacheManager, 使用 ConcurrentHashMap 当底层的数据结构,按照Cache的名字查询出Cache, 每一个Cache中存在多个k-v键值对,缓存值。

缓存注解介绍

刚刚通过使用@EnableCaching、@Cacheable注解实现了Spring Boot默认的基于注解的缓存管
理，除此之外，还有更多的缓存注解及注解属性可以配置优化缓存管理

@EnableCaching注解

@EnableCaching是由spring框架提供的，springboot框架对该注解进行了继承，该注解需要配置在类上（通常配置在项目启动类上），用于开启基于注解的缓存支持

@Cacheable注解
- @Cacheable注解也是由spring框架提供的，可以作用于类或方法（通常用在数据查询方法上），用于对方法结果进行缓存存储。注解的执行顺序是，先进行缓存查询，如果为空则进行方法查询，并将结果进行缓存；如果缓存中有数据，不进行方法查询，而是直接使用缓存数据
- @Cacheable注解提供了多个属性，用于对缓存存储进行相关配置 | 属性名 | 说明 | | —- | —- | | value/cacheNames | 指定缓存空间的名称，必配属性。这两个属性二选一使用 | | key | 指定缓存数据的key，默认使用方法参数值，可以使用SpEL表达式 | | keyGenerator | 指定缓存数据的key的生成器，与key属性二选一使用 | | cacheManager | 指定缓存管理器 | | cacheResolver | 指定缓存解析器，与cacheManager属性二选一使用 | | condition | 指定在符合某条件下，进行数据缓存 | | unless | 指定在符合某条件下，不进行数据缓存 | | sync | 指定是否使用异步缓存。默认false |

执行流程、时机

方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取，（CacheManager 先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
去Cache中查找缓存的内容，使用一个key，默认就是方法的参数，如果多个参数或者没有参数，是按照某种策略生成的，默认是使用KeyGenerator生成的，使用SimpleKeyGenerator生成key

SimpleKeyGenerator生成key的默认策略：

参数个数	key
没有参数	new SimpleKey()
有一个参数	参数值
多个参数	new SimpleKey(params)

常见的SPEL表达式：

描述	示例
当前被调用的方法名	#root.mathodName
当前被调用的方法	#root.mathod
当前被调用的目标对象	#root.target
当前被调用的目标对象类	#root.targetClass
当前被调用的方法的参数列表	#root.args[0] 第一个参数, #root.args[1] 第二个参数…
根据参数名字取出值	#参数名, 也可以使用 #p0 #a0 0是参数的下标索引
当前方法的返回值	#result

@CachePut注解

目标方法执行完之后生效, @CachePut被使用于修改操作比较多,哪怕缓存中已经存在目标值了,但是这个注解保证这个方法依然会执行,执行之后的结果被保存在缓存中。
@CachePut注解也提供了多个属性，这些属性与@Cacheable注解的属性完全相同。
更新操作,前端会把id+实体传递到后端使用,我们就直接指定方法的返回值从新存进缓存时的 key=”#id” , 如果前端只是给了实体,我们就使用 key=”#实体.id” 获取key. 同时,他的执行时机是目标方法结束后执行, 所以也可以使用 key=”#result.id” , 拿出返回值的id。

@CacheEvict注解

@CacheEvict注解是由Spring框架提供的，可以作用于类或方法（通常用在数据删除方法上），该注解的作用是删除缓存数据。@CacheEvict注解的默认执行顺序是，先进行方法调用，然后将缓存进行除。

6.2 整合Redis缓存实现

6.2.1 SpringBoot支持的缓存组件

在Spring Boot中，数据的缓存管理存储依赖于Spring框架中cache相关的
org.springframework.cache.Cache和org.springframework.cache.CacheManager缓存管理器接口。如果程序中没有定义类型为CacheManager的Bean组件或者是名为cacheResolver的CacheResolver缓存解析器，Spring Boot将尝试选择并启用以下缓存组件（按照指定的顺序）：

Generic
JCache (JSR-107) (EhCache 3、Hazelcast、Infifinispan等)
EhCache 2.x
Hazelcast
Infifinispan
Couchbase
Redis
Caffffeine
Simple

以上是根据Spring Boot缓存组件的加载顺序来列举的：

如果项目中没有添加任何缓存组件，则使用第9的默认组件，也就是6.1提到的SimpleCacheConfiguration，它默认使用内存中的ConcurrentMap进行缓存存储。这种方式并不推荐。
如果项目中有多个组件，则按照加载顺序来选择组件，加载先的优先级高。但是也可以自己指定，比如使用@Cacheable注解时使用cacheManager属性指定缓存管理器。
6.2.2 基于注解的Redis缓存实现

引入redis依赖
```
<dependency> 
<groupId>org.springframework.boot</groupId> 
<artifactId>spring-boot-starter-data-redis</artifactId> 
</dependency>
```
当我们添加进redis相关的启动器之后, SpringBoot会使用 RedisCacheConfiguration当做生效的自动
配置类进行缓存相关的自动装配,容器中使用的缓存管理器是 RedisCacheManager , 这个缓存管理器创建的Cache为 RedisCache , 进而操控redis进行数据的缓存。

配置文件

# Redis服务地址 
spring.redis.host=127.0.0.1 
# Redis服务器连接端口 
spring.redis.port=6379 
# Redis服务器连接密码（默认为空） 
spring.redis.password=

对CommentService类中的方法进行修改使用@Cacheable、@CachePut、@CacheEvict三个注解定制缓存管理，分别进行缓存存储、缓存更新和缓存删除的演示 ```java @Service public class CommentService { // unless = “#result==null””表示查询结果为空不进行缓存 // @Cacheable注解中没有标记key值，将会使用默认参数值comment_id作为key进行 // 数据保存 @Cacheable(cacheNames = “comment”,unless = “#result==null”) public Comment findCommentById(Integer id){
```
 Optional<Comment> comment = commentRepository.findById(id);                                 if(comment.isPresent()){ 
     Comment comment1 = comment.get(); 
     return comment1; 
 }
 return null; 
```
}

@CachePut(cacheNames = “comment”,key = “#result.id”) public Comment updateComment(Comment comment) { commentRepository.updateComment(comment.getAuthor(), comment.getaId());
```
return comment;                                          
```
}

@CacheEvict(cacheNames = “comment”) public void deleteComment(int comment_id) { commentRepository.deleteById(comment_id); }

}


4. 缓存保存的数据（对象类）需要进行序列化操作。java实现序列化可以实现Serializable接口来实现。
5. 进行调用测试。
6. 对缓存配置过期时间，此方法不够灵活，对所有缓存生效。
```properties
# 对基于注解的Redis缓存数据统一设置有效期为1分钟，单位毫秒 
spring.cache.redis.time-to-live=60000

6.2.3 基于API的Redis缓存实现

基于API的Redis缓存实现，需要在某种业务需求下通过 Redis提供的API调用相关方法实现数据缓存管理；同时，这种方法还可以手动管理缓存的有效期。

6.2.2已经实现了redis缓存的引入，以下主要是使用API的方式实现缓存。

@Service 
public class ApiCommentService {
 @Autowired private 
 CommentRepository commentRepository;
 @Autowired private 
 RedisTemplate redisTemplate;
 public Comment findCommentById(Integer id){
     Object o = redisTemplate.opsForValue().get("comment_" + id);
     if(o!=null) {
         return (Comment) o;
     } else {
         //缓存中没有，从数据库查询
         Optional<Comment> byId = commentRepository.findById(id);
         if(byId.isPresent()){
             Comment comment = byId.get();
             //将查询结果存入到缓存中，并设置有效期为1天
             redisTemplate.opsForValue().set("comment_"+id,comment,1,TimeUnit.DAYS);
             return comment;
         } else {
             return null;
         }
     }
 }
 public Comment updateComment(Comment comment) {
     commentRepository.updateComment(comment.getAuthor(), comment.getaId());
     //更新数据后进行缓存更新
     redisTemplate.opsForValue().set("comment_"+comment.getId(),comment);
     return comment;
 }
 public void deleteComment(int comment_id) {
     commentRepository.deleteById(comment_id);                                                  redisTemplate.delete("comment_"+comment_id);
 }
}

6.2.4 自定义Redis缓存序列化机制

基于API的Redis缓存实现是使用RedisTemplate模板进行数据缓存操作的，这里打开
RedisTemplate类，查看该类的关键源码信息：

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
    // 声明了key、value的各种序列化方式，初始值为空
    @Nullable
    private RedisSerializer keySerializer = null;
    @Nullable
    private RedisSerializer valueSerializer = null;
    @Nullable
    private RedisSerializer hashKeySerializer = null;
    @Nullable
    private RedisSerializer hashValueSerializer = null;
    public void afterPropertiesSet() {
        super.afterPropertiesSet();
        // 进行默认序列化方式设置，设置为JDK序列化方式
        if (this.defaultSerializer == null) {
            this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
            ......
            ......
        }
    }
}

源码解析：
从上述RedisTemplate核心源码可以看出，在RedisTemplate内部声明了缓存数据key、value的各
种序列化方式，且初始值都为空；在afterPropertiesSet()方法中，判断如果默认序列化参数
defaultSerializer为空，将数据的默认序列化方式设置为JdkSerializationRedisSerializer 。
根据源码信息，可以得出以下重要结论：

使用RedisTemplate进行Redis数据缓存操作时，内部默认使用的是 JdkSerializationRedisSerializer序列化方式，所以进行数据缓存的实体类必须实现JDK自带的序列化接口（例如Serializable）。
使用RedisTemplate进行Redis数据缓存操作时，如果自定义了缓存序列化方式 defaultSerializer，那么将使用自定义的序列化方式。
缓存数据key、value的各种序列化类型都是 RedisSerializer。进入RedisSerializer源码查看RedisSerializer支持的序列化方式（查看RedisSerializer接口的实现类）

自定义RedisTemplate序列化机制
在项目中引入Redis依赖后，Spring Boot提供的RedisAutoConfifiguration自动配置会生效。打开
RedisAutoConfifiguration类，查看内部源码中关于RedisTemplate的定义方式：

public class RedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

根据源码可以看出， @ConditionalOnMissingBean注解表示如果当前不存在redisTemplate类的时候就会自动实例化这个类并放入容器，所以我们可以自定义一个RedisTemplate放入容器，自动配置中的类就不会生效了。参考自动配置的自定义配置如下：

@Configuration 
public class RedisConfig {
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        // 使用JSON格式序列化对象，对缓存数据key和value进行转换
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        // 解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper(); 
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);                      om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);                              jacksonSeial.setObjectMapper(om);
        // 设置RedisTemplate模板API的序列化方式为JSON
        template.setDefaultSerializer(jacksonSeial);
        return template;
    }
}

通过@Confifiguration注解定义了一个RedisConfifig配置类，并使用@Bean注解注入了一个默认名
称为方法名的redisTemplate组件（注意，该Bean组件名称必须是redisTemplate）。在定义的Bean组
件中，自定义了一个RedisTemplate，使用自定义的Jackson2JsonRedisSerializer数据序列化方式；在
定制序列化方式中，定义了一个ObjectMapper用于进行数据转换设置

自定义RedisCacheManager
刚刚针对基于 API方式的RedisTemplate进行了自定义序列化方式的改进，从而实现了JSON序列化
方式缓存数据，但是这种自定义的RedisTemplate对于基于注解的Redis缓存来说，是没有作用的。
针对注解的Redis缓存机制和自定义序列化机制如下：
Redis注解默认序列化机制
打开Spring Boot整合Redis组件提供的缓存自动配置类 RedisCacheConfifiguration（org.springframework.boot.autoconfifigure.cache包下的），该配置类中的RedisCacheManager的定义，选择了JDK序列化方式，我们自定义一个RedisCacheManager进行覆盖：

@Bean public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    // 分别创建String和JSON格式序列化对象，对缓存数据key和value进行转换 
    RedisSerializer<String> strSerializer = new StringRedisSerializer(); 
    Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
    // 解决查询缓存转换异常的问题 
    ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); 
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); 
    jacksonSeial.setObjectMapper(om);
    // 定制缓存数据序列化方式及时效 
    RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(Duration.ofDays(1))     
        .serializeKeysWith(RedisSerializationContext.SerializationPair 
                           .fromSerializer(strSerializer)) 
        .serializeValuesWith(RedisSerializationContext.SerializationPair 
                             .fromSerializer(jacksonSeial)) .disableCachingNullValues();
    RedisCacheManager cacheManager = RedisCacheManager 
        .builder(redisConnectionFactory).cacheDefaults(config).build();
    return cacheManager;
}

上述代码中，在RedisConfifig配置类中使用@Bean注解注入了一个默认名称为方法名的cacheManager组件。在定义的Bean组件中，通过RedisCacheConfifiguration对缓存数据的key和value
分别进行了序列化方式的定制，其中缓存数据的key定制为StringRedisSerializer（即String格式），而 value定制为了Jackson2JsonRedisSerializer（即JSON格式），同时还使用entryTtl(Duration.ofDays(1))方法将缓存数据有效期设置为1天

Java 框架

6. SpringBoot缓存管理