缓存之SpringCache整合redis(五)

我就是我 2024-04-22 04:05 78阅读 0赞

#### SpringCache整合redis ####

*  一、引入pom
 *  二、配置
 *   *  1.springCache自动配置了redis
     *  2.配置yml
     *  3.开启缓存功能
     *  4.测试使用缓存
     *  5.缓存保存JSON格式
 *  三、springCache的读写模式
 *   *  1.读模式
     *  2.写模式（缓存和数据库一致性）

## 一、引入pom ##

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

## 二、配置 ##

### 1.springCache自动配置了redis ###

![在这里插入图片描述][2dbbbaedb2014258b2d9843e7a61dcd8.png]

![在这里插入图片描述][18ef6a2cac0445b4833fc93969021289.png]  
![在这里插入图片描述][c9aa9cd175b043838e94aa729ba1fec4.png]

### 2.配置yml ###

spring:
      cache:
        type: redis #配置reids作为缓存
        redis:
          time-to-live: 60000 #缓存过期时间为60秒，单位毫秒
          key-prefix: HEIZI_   #key增加前缀
          use-key-prefix: true #是否开启前缀（Ⅰ.如果为true，并且key-prefix指定了值，那么缓存的key就是：HEIZI_key。Ⅱ.如果为true，key-prefix没有指定前缀，那么缓存的key就是：缓存的名字::key。Ⅲ.如果为false，缓存的key就是：key）
          cache-null-values: true #是否缓存空值，防止缓存穿透问题

### 3.开启缓存功能 ###

#在启动类加上此注解
    @EnableCaching

### 4.测试使用缓存 ###

`@Cacheable`：保存到缓存中。  
`@CacheEvict`：删除缓存。  
`@CachePut`：不影响方法执行，更新缓存。（双写模式默认）  
`@Caching`：多条命令操作。  
`@CacheConfig`：共享缓存配置（类级别）。

# 把结果放到缓存，如果有缓存，那么不调用接口，直接返回缓存里面的数据。没有缓存，调用接口返回数据，并且把结果存到缓存中去。缓存的value存放的是jdk序列化的内容。
    	
    	# 缓存的名称：ikun，一个缓存下可以有多个key，key的名称：ceshi（支持Spring的表达式语言SPEL语法）
        @Cacheable(value = {
        "ikun"},key = "'ceshi'")
        Object detail(@PathVariable("id") Serializable id);
        
     
        # 缓存的名称：ikun，一个缓存下可以有多个key，key的名称：结果的id值
        @Cacheable(value = {
        "ikun"},key = "#result.id")
        Object detail(@PathVariable("id") Serializable id);
    
    	
      	# 缓存的名称：ikun，一个缓存下可以有多个key，key的名称：参数的id值
        @Cacheable(value = {
        "ikun"},key = "#heizi.id")
        Object detail(HeiZi heizi);
    
    
    	//删除ikun缓存下的，key为ceshi的缓存。
        @CacheEvict(value = {
        "ikun"},key = "'ceshi'")
        String update(HeiZi heizi);
    
    
    	//删除ikun缓存下的，所有的缓存。
        @CacheEvict(value = {
        "ikun"},allEntries = true)
        String update(HeiZi heizi);
    
    
    	//删除ikun缓存下的，key为ceshi1和ceshi2的缓存。
       @Caching(
               evict = {
        
                   @CacheEvict(value = "ikun",key = "'ceshi1'"),
                   @CacheEvict(value = "ikun",key = "'ceshi2'")  
               }
       )
       String update(HeiZi heizi);

**SpEl表达式**

<table> 
 <thead> 
  <tr> 
   <th>名称</th> 
   <th>位置</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>methodName</td> 
   <td>root对象</td> 
   <td>当前被调用的方法名</td> 
   <td>#root.methodname</td> 
  </tr> 
  <tr> 
   <td>method</td> 
   <td>root对象</td> 
   <td>当前被调用的方法</td> 
   <td>#root.method.name</td> 
  </tr> 
  <tr> 
   <td>target</td> 
   <td>root对象</td> 
   <td>当前被调用的目标对象实例</td> 
   <td>#root.target</td> 
  </tr> 
  <tr> 
   <td>targetClass</td> 
   <td>root对象</td> 
   <td>当前被调用的目标对象的类</td> 
   <td>#root.targetClass</td> 
  </tr> 
  <tr> 
   <td>args</td> 
   <td>root对象</td> 
   <td>当前被调用的方法的参数列表</td> 
   <td>#root.args[0]</td> 
  </tr> 
  <tr> 
   <td>caches</td> 
   <td>root对象</td> 
   <td>当前方法调用使用的缓存列表</td> 
   <td>#root.caches[0].name</td> 
  </tr> 
  <tr> 
   <td>Argument Name</td> 
   <td>执行上下文</td> 
   <td>当前被调用的方法的参数，如detail(HeiZi heizi),可以通过#heizi.id获得参数</td> 
   <td>#heizi.id</td> 
  </tr> 
  <tr> 
   <td>result</td> 
   <td>执行上下文</td> 
   <td>方法执行后的返回值（仅当方法执行后的判断有效）</td> 
   <td>#result.id</td> 
  </tr> 
 </tbody> 
</table>

### 5.缓存保存JSON格式 ###

> 因为默认缓存，存的是JDK序列化的内容，如果我们要想存JSON怎么办呢？

@Configuration
    @EnableCaching
    @EnableConfigurationProperties({
        CacheProperties.class})
    public class MyRedisConfig {
        
    
        @Bean
        RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
        
            RedisCacheConfiguration redisConfig = RedisCacheConfiguration.defaultCacheConfig();
            //设置redis存的格式为JSON
            //使用GenericJackson2JsonRedisSerializer()和StringRedisSerializer()都可以
            redisConfig = redisConfig.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
            redisConfig = redisConfig.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
    
            //使你配置文件的配置生效
            CacheProperties.Redis redisProperties = cacheProperties.getRedis();
            //读取配置文件的缓存过期时间
            if (redisProperties.getTimeToLive() != null) {
        
                redisConfig = redisConfig.entryTtl(redisProperties.getTimeToLive());
            }
            //读取配置文件的缓存的前缀
            if (redisProperties.getKeyPrefix() != null) {
        
                redisConfig = redisConfig.prefixCacheNameWith(redisProperties.getKeyPrefix());
            }
            //读取配置文件的缓存是否存空值
            if (!redisProperties.isCacheNullValues()) {
        
                redisConfig = redisConfig.disableCachingNullValues();
            }
    
            //读取配置文件的是否开启缓存前缀
            if (!redisProperties.isUseKeyPrefix()) {
        
                redisConfig = redisConfig.disableKeyPrefix();
            }
            return redisConfig;
        }
    
    }

## 三、springCache的读写模式 ##

### 1.读模式 ###

**缓存穿透：** 查询为null的数据。**解决：** 设置缓存是否为空。(cache-null-values: true)。

**缓存击穿：** 大量并发查询过期的缓存。**解决：** 加锁 @Cacheable(sync = true)。

**缓存雪崩：** 大量缓存同时过期。**解决：** 加随机时间 (time-to-live: 60000)。

### 2.写模式（缓存和数据库一致性） ###

springCache并没有对写模式进行特别的配置和处理，要根据不同的场景进行不同的操作。

[2dbbbaedb2014258b2d9843e7a61dcd8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/52d854a8b3b64d62b6c3bcec5c68f1eb.png
[18ef6a2cac0445b4833fc93969021289.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/6e5dca14253a415abd95153412923675.png
[c9aa9cd175b043838e94aa729ba1fec4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/e564c86529364a5790a96ad0dab8e00a.png