SpringCache

缺乏、安全感 2021-09-20 06:04 315阅读 0赞

# Introduce #

Spring 3.1 引入了激动人心的基于凝视（annotation）的缓存（cache）技术，它本质上不是一个具体的缓存实现方案（比如EHCache 或者 OSCache），而是一个对缓存使用的抽象，通过在既有代码中加入少量它定义的各种 annotation，即能够达到缓存方法的返回对象的效果。

**springCache 是spring整合的**

![18721752-2315ad2bf76cc8f5.png][]

image.png

缓存官方文档

[https://docs.spring.io/spring-framework/docs/5.2.11.RELEASE/spring-framework-reference/integration.html\#cache][https_docs.spring.io_spring-framework_docs_5.2.11.RELEASE_spring-framework-reference_integration.html_cache]

![18721752-9234a75e73faa60a.png][]

image.png

Cache Abstraction 缓存抽象，如其名字，它本质上不是一个具体的缓存实现方案（比如EHCache 或者 OSCache），而是一个对缓存使用的抽象，通过在既有代码中加入少量它定义的各种 annotation，即能够达到缓存方法的返回对象的效果。

# 不用SpringCache的缓存 #

//缓存改写2：使用redis作为本地缓存
            ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
            String catalogJson = ops.get("catalogJson");
            if (StringUtils.isEmpty(catalogJson)) {
                Map<String, List<Catalog2Vo>> categoriesDb = getCategoriesDb();
                String toJSONString = JSON.toJSONString(categoriesDb);
                ops.set("catalogJson",toJSONString);
               return categoriesDb;
           }
           Map<String, List<Catalog2Vo>> listMap = JSON.parseObject(catalogJson, new TypeReference<Map<String, List<Catalog2Vo>>>() {});
          return listMap;

# 使用SpringCache #

## pom ##

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
        <exclusions>
            <exclusion>
                <groupId>io.lettuce</groupId>
                <artifactId>lettuce-core</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
    
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>

## redis.yml ##

spring:
      redis:
        host: 192.168.16.129
        port: 6379
      cache:
        type: redis
        redis:
          time-to-live: 3600000
          #是否缓存空值,防止缓存穿透
          cache-null-values: true

## bootstrap-dev.properties ##

spring.profiles.active=dev
    spring.application.name=gulimail-product-config
    spring.cloud.nacos.config.server-addr=xxxxxx:8848
    spring.cloud.nacos.config.file-extension=yaml
    spring.cloud.nacos.config.group=gulimail_product_group
    spring.cloud.nacos.config.namespace=72616c9f-6977-460d-9a1b-b43859b57beb
    
    spring.cloud.nacos.config.ext-config[0].data-id=gulimail-product-redis-dev.yaml
    spring.cloud.nacos.config.ext-config[0].group=gulimail_product_group
    spring.cloud.nacos.config.ext-config[0].refresh=true

## 配置类 ##

package com.pl.gulimail.product.config;
    
    import org.springframework.boot.autoconfigure.cache.CacheProperties;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.cache.RedisCacheConfiguration;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializationContext;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @EnableConfigurationProperties(CacheProperties.class)//不加这个注解，配置文件不生效
    @Configuration
    @EnableCaching
    public class MyCacheConfig {
        //要想配置文件生效 @EnableConfigurationProperties(CacheProperties.class)
        @Bean
        public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
    
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
            //序列化key value
            config.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
            config = config.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()));
    
            CacheProperties.Redis redisProperties = cacheProperties.getRedis();
            //过期时间
            if (redisProperties.getTimeToLive() != null) {
                config = config.entryTtl(redisProperties.getTimeToLive());
            }
            //缓存件有没有前缀
            if (redisProperties.getKeyPrefix() != null) {
                config = config.prefixKeysWith(redisProperties.getKeyPrefix());
            }
            //是否缓存空数据
            if (!redisProperties.isCacheNullValues()) {
                config = config.disableCachingNullValues();
            }
            //是否用缓存前缀
            if (!redisProperties.isUseKeyPrefix()) {
                config = config.disableKeyPrefix();
            }
            return config;
        }
    }

## 开启缓存 ##

@EnableCaching

package com.pl.gulimail.product;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    import org.springframework.context.annotation.EnableAspectJAutoProxy;
    
    @EnableCaching
    @EnableAspectJAutoProxy(exposeProxy = true)
    @MapperScan("com.pl.gulimail.product.sql.dao")
    @EnableDiscoveryClient
    @SpringBootApplication
    @EnableFeignClients(basePackages = {"com.pl.gulimail.product.sql.feign"})
    public class GulimalProductApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(GulimalProductApplication.class, args);
        }
    
    }

## 测试使用缓存 ##

*  `@Cacheable`: Triggers cache population. 处罚将数据保存到缓存的操作。
 *  `@CacheEvict`: Triggers cache eviction. 触发将数据从缓存中删除的操作。
 *  `@CachePut`: Updates the cache without interfering with the method execution. 不影响方法执行更行缓存。
 *  `@Caching`: Regroups multiple cache operations to be applied on a method. 组合史上多个操作。
 *  `@CacheConfig`: Shares some common cache-related settings at class-level.在类级别共享缓存配置。

## code ##

### 读模式 ###

//value 缓存分区 按照业务类型分区,
    //@Cacheable(value = {"category","sss"},key = "#root.methodName",sync = true)  这条数据往category，sss两个区中存放数据
    @Cacheable(value = {"category"})
    public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithSpringCache() {
        return getCategoriesDb();
    }

SimpleKey是默认给的名字，数据是jdk序列化的样子

![18721752-d072e0f6f1765879.png][]

image.png

指定key并引入配置类，value数据为json格式后

//value 缓存分区 按照业务类型分区,
    //@Cacheable(value = {"category","sss"},key = "#root.methodName",sync = true)  这条数据往category，sss两个区中存放数据
    @Cacheable(value = {"category"},key = "#root.methodName",sync = true)
    public Map<String, List<Catalog2Vo>> getCatalogJsonDbWithSpringCache() {
        return getCategoriesDb();
    }

可以发现key为方法名，TTL失效时间也按照配置文件中指定的一样生效了。该方法只有在第一次访问或者缓存失效后会被调用查询数据库，其余时间直接从缓存中读取数据。

![18721752-300f66ceab82d70f.png][]

image.png

![18721752-75e3292cbc0291bc.png][]

image.png

### notice： ###

#### n1使用@Cacheable的特点： ####

1.如果方法中有姐不在调用了。

2.缓存的数据，默认的key是默认生成的，缓存名字:: SimpleKey（自动生成的key值）

3.缓存的value，默认使用jdk序列化机制，将序列化后的数据缓存到redis。

4.默认ttl过期时间 -1。永不过期。

#### 自定义： ####

1.指定生成缓存中的key（注解上指定key）

2.指定缓存存活时间

3.将数据保存为json格式

#### key: ####

![18721752-1449b3502f4c7a8c.png][]

image.png

支持SqEL动态获取key,

如果想用方法名作为key

#root.methodName

如果想获取方法的参数  
\{@code \#root.args\[1\]\}, \{@code \#p1\} or \{@code \#a1\}

#### 配置文件中指定前缀 ####

![18721752-53bb9244306ff1b1.png][]

image.png

##### 测试缓存空值和指定前缀 #####

![18721752-626e799fcb190796.png][]

image.png

##### 不使用缓存前缀 #####

![18721752-983011715bf3ab87.png][]

image.png

没有前缀，只显示指定的key

![18721752-923676c9b02f9f8e.png][]

image.png

### 写模式 ###

#### 指定删除指定的一个key ####

/**
    * 级联更新所有数据
    * CacheEvict: 失效模式
    * @param category
    */
    @Override
    @Transactional
    @CacheEvict(value = {"category"},key = "'getCatalogJsonDbWithSpringCache'") //指定删除哪个分区，哪个key
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
    }

key是遵循SqEL表达式的，字符串需要加单引号。

执行更行操作

![18721752-9550629500f7bf9e.png][]

image.png

![18721752-29f864ebc3841d3f.png][]

image.png

#### 指定删除多个key ####

/**
    * 级联更新所有数据
    * CacheEvict: 失效模式
    * @param category
    */
    @Override
    @Transactional  
    @Caching(evict = {
    @CacheEvict(value = {"category"},key = "'getCategoryLeve1'"),
    @CacheEvict(value = {"category"},key = "'getCatalogJsonDbWithSpringCache'")
    })
    public void updateCascade(CategoryEntity category) {
      this.updateById(category);
    }

#### 指定删除区中的的所有key ####

/**
    * 级联更新所有数据
    * CacheEvict: 失效模式
    * @param category
    */
    @Override
    @Transactional
    @CacheEvict(value = {"category"},key = "'getCatalogJsonDbWithSpringCache'",allEntries = true)
    public void updateCascade(CategoryEntity category) {
        this.updateById(category);
    }

#### 双写模式 ####

这次更新完事后，将数据放到缓存中一份,方法中必须有返回值

/**
    * 级联更新所有数据
    * CacheEvict: 失效模式
    * @param category
    */
    @Override
    @Transactional
    @CacheEvict(value = {"category"},key = "'getCatalogJsonDbWithSpringCache'",allEntries = true)
    @cachePut
    public CategoryEntity updateCascade(CategoryEntity category) {
        return this.updateById(category);
    }

# Spring-Cache的不足之处 #

## 1.读模式（@Cacheable） ##

缓存穿透：查询一个null数据。解决方案：缓存空数据，可通过`spring.cache.redis.cache-null-values=true`

缓存击穿：大量并发进来同时查询一个正好过期的数据。解决方案：加锁 ? 默认是无加锁的;

使用sync = true来解决击穿问题

缓存雪崩：大量的key同时过期。解决：加随机时间。加上过期时间，即使通过配置文件指定了相同的随机时间，但是每次出发写缓存的时间都不一致，所以就算TTL时间相同，但是彼此失效的时间不同。

可以看出Spring-Cache对读操作的所有问题，都是有对应的解决办法的。

### notice： ###

只有@Cacheable有锁，其他注解没有加锁的属性。

<wiz\_code\_mirror><pre class=" CodeMirror-line " role="presentation">@Cacheable(value = \{"category"\},key = "\#root.methodName",sync = true)</pre></wiz\_code\_mirror>

## 2.写模式：（缓存与数据库一致） ##

因为@CacheEvict,@CachePut都没有锁属性，所以都不可以加锁，这些注解对于缓存雪崩的场景是没法应对的。

### 解决办法： ###

a、读写加锁。

b、引入Canal,感知到MySQL的更新去更新Redis

c 、读多写多，直接去数据库查询就行

## 3.总结： ##

常规数据（读多写少，即时性，一致性要求不高的数据，完全可以使用Spring-Cache）：

写模式(只要缓存的数据有过期时间就足够了)

特殊数据：特殊设计

[18721752-2315ad2bf76cc8f5.png]: /images/20210918/f9b4adfd8cd14e29b5c01d8336f12661.png
[https_docs.spring.io_spring-framework_docs_5.2.11.RELEASE_spring-framework-reference_integration.html_cache]: https://links.jianshu.com/go?to=https%3A%2F%2Fdocs.spring.io%2Fspring-framework%2Fdocs%2F5.2.11.RELEASE%2Fspring-framework-reference%2Fintegration.html%23cache
[18721752-9234a75e73faa60a.png]: /images/20210918/58c0be17373d412ba9af665eb5ab632b.png
[18721752-d072e0f6f1765879.png]: /images/20210918/2063f6c6934d4e30840bb0e084e2d44d.png
[18721752-300f66ceab82d70f.png]: /images/20210918/2ed1076e52e546d3a720d8739bb6dc93.png
[18721752-75e3292cbc0291bc.png]: /images/20210918/0ad0fb6301994ac580a9113c8d46e688.png
[18721752-1449b3502f4c7a8c.png]: /images/20210918/55a17a84b6374c3582d7426cde4a4379.png
[18721752-53bb9244306ff1b1.png]: /images/20210918/c1f8f43720af4ff8ad69f341b0e3ce58.png
[18721752-626e799fcb190796.png]: /images/20210918/276e1a2ed9894a4484a227aaf6eefc71.png
[18721752-983011715bf3ab87.png]: /images/20210918/66c56d7a15c3413f9f89c748cc7d41fe.png
[18721752-923676c9b02f9f8e.png]: /images/20210918/72cdfc24afa2441ca2d2e7d43ced446b.png
[18721752-9550629500f7bf9e.png]: /images/20210918/bed313564f674c958016faa34c0f567b.png
[18721752-29f864ebc3841d3f.png]: /images/20210918/2334e75cd65244dcbf89f36f85b49e36.png