Springboot项目--缓存环境搭建及介绍

小鱼儿 2023-02-14 02:04 18阅读 0赞

### 文章目录 ###

*  1、缓存使用
 *   *  1.1 缓存介绍
     *  1.2整合redis作为缓存
     *  1.3 缓存失效问题
 *  2、分布式锁
 *   *  2.1 分布式锁的原理
     *  2.2 整合Redisson
     *  2.3 看门狗原理
     *  2.4 缓存数据一致性
 *  3、SpringCache
 *   *  3.1 简介
     *  3.2 整合SpringCache
     *  3.3 @Cacheable细节
     *  3.4自定义配置

> **【笔记于学习尚硅谷课程所作】**

# 1、缓存使用 #

## 1.1 缓存介绍 ##

为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问。而db承担数据落盘工作。  
哪些数据适合放入缓存?

*  即时性、数据一致性要求不高的
 *  访问量大且更新频率不高的数据(读多，写少)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk2NTY4_size_16_color_FFFFFF_t_70]

## 1.2整合redis作为缓存 ##

1.导入依赖

<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>

2.在yml中配置

redis:
        host: 192.168.196.128
        port: 6379

3.测试

@Autowired
        StringRedisTemplate stringRedisTemplate;
    
        @Test
        public void testRedis(){
        
            ValueOperations<String,String> ops = stringRedisTemplate.opsForValue();
    
            //保存
            ops.set("hello","world"+new Date());
    
            //查询
            String hello = ops.get("hello");
            System.out.println(hello);
        }

## 1.3 缓存失效问题 ##

*  缓存穿透（查询一个不存在数据）
    
     *  问题：指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义
     *  解决：null结果缓存，并加入短暂过期时间
 *  缓存雪崩（大量key同时过期）
    
     *  问题：缓存雪崩是指在我们设置缓存时key采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重雪崩。
     *  解决：原有的失效时间基础上增加一个随机值
 *  缓存击穿（大量并发同时查一个刚好过期的数据）
    
     *  问题：对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。 如果这个key在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。
     *  解决：加锁

# 2、分布式锁 #

## 2.1 分布式锁的原理 ##

原始使用redis，保证获取锁和设置锁的过期时间是原子的，保证解锁时获取锁信息和解锁是原子的

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk2NTY4_size_16_color_FFFFFF_t_70 1]

Redisson介绍：Redisson是一个在Redis的基础上实现的Java驻内存数据网格(In-Memory Data Grid) .它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。

所以我们使用Redisson框架来完成我们项目所有的分布式锁的使用

## 2.2 整合Redisson ##

1.导入依赖

<dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>3.12.0</version>
            </dependency>

2.编写配置类

@Configuration
    public class MyRedissonConfig {
        
    
        /**
         * 对Redisson的使用都是通过RedissonClient
         * @return
         * @throws IOException
         */
        @Bean(destroyMethod="shutdown")
        public RedissonClient redisson() throws IOException {
        
            // 单Redis节点模式
            // 1、创建配置
            Config config = new Config();
            config.useSingleServer().setAddress("redis://192.168.196.128:6379");
            // 2、根据config创建RedissonClient示例
            RedissonClient redisson = Redisson.create(config);
            return redisson;
        }
    }

## 2.3 看门狗原理 ##

Redisson的看门狗锁会自动给锁续时间，防止超长业务导致锁过期。同时，当一个服务器宕机或者执行业务完成，看门狗不会再给锁续时间，这样就算不解锁，也不会存在死锁问题。但是如果指定了自动解锁时间，则不会自动续锁时间。

原理：

*  如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时就是我们指定的时间
 *  如果我们未指定锁的超时时间，就使用30 \* 1000【LockWatchdogTimeout看门狗的默认时间】
    
     *  只要占锁成功，就会启动一个定时任务【重新给锁设置过期时间，新的过期时间就是看门狗的默认时间】
     *  internallockLeaseTime【看门狗时间】/ 3 =10s，定时任务10s续一次

\*\*真实开发项目时，还是采用手动设置超时时间，这样可以省去看门狗操作。\*\*并且一般>30s的业务都是异常问题

## 2.4 缓存数据一致性 ##

问题：数据库更新导致和缓存不一致

解决：双写模式（同步更新数据库和缓存）、失效模式（更新数据库，同时删除缓存）、Canal

我们项目最终使用失效模式：缓存的所有数据都有过期时间，数据过期下一次查询触发主动更新，读写数据的时候，加上分布式的**读写锁**。

# 3、SpringCache #

## 3.1 简介 ##

缓存抽象层，Spring从 3.1开始定义了org-springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术，并支持使用JCache (JSR-107) 注解简化我们开发。

每次调用需要缓存功能的方法时，Spring会检查检查指定参数的指定的目标方法是否已经被调用过;如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。

主要的注解有：

*  @Cacheable：触发将数据保存到缓存的操作
 *  @CacheEvict：触发将数据从缓存删除的操作（使缓存失效）
 *  @CachePut：不影响方法执行更新缓存（双写模式）
 *  @Caching：组合以上多个操作
 *  @CacheConfig：在类级别共享缓存的相同配置

## 3.2 整合SpringCache ##

1.导入依赖

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

2.在application.properties里配置

spring.cache.type=redis
    
    # 以毫秒为单位 1小时
    spring.cache.redis.time-to-live=3600000
    # 配置缓存名的前缀 如果没配置则使用缓存名作为前缀
    #spring.cache.redis.key-prefix=CACHE_
    # 配置前缀是否生效  默认为ture
    #spring.cache.redis.use-key-prefix=false
    # 是否缓存空值 默认为true
    spring.cache.redis.cache-null-values=true

3.在启动类上添加开启缓存的注解@EnableCaching

## 3.3 @Cacheable细节 ##

当前方法的结果需要缓存 如果缓存中有，方法不调用；如果缓存中没有，会调用该方法，最后将方法的结果放入缓存

默认行为：

*  如果缓存中有，方法不用调用
 *  key默认自动生成
 *  缓存的value的值：默认使用java序列化机制
 *  将序列化后的数据存到redis
 *  默认ttl时间：不过期

自定义：

*  指定生成的缓存使用的key, key属性指定， 接受一个SpEL
 *  指定缓存的数据的存话时间：配置文件中修改tth
 *  将数据保存为json格式：自定义配置类

## 3.4自定义配置 ##

@EnableConfigurationProperties(CacheProperties.class)
    @Configuration
    public class MyCacheConfig {
        
    
    
        @Bean
        public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties) {
        
    
            RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
    
            // 修改默认的序列化器
            config = 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;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk2NTY4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200530212856852.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk2NTY4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk2NTY4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020053021282391.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxNTk2NTY4,size_16,color_FFFFFF,t_70