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

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

1、缓存使用

1.1 缓存介绍

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

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

1.2整合redis作为缓存

1.导入依赖

<!-- 因为lettuce导致堆外内存溢出 这里暂时排除他 使用jedis -->
        <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，保证获取锁和设置锁的过期时间是原子的，保证解锁时获取锁信息和解锁是原子的

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

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

2.2 整合Redisson

1.导入依赖

 <!-- 以后使用redisson作为所有分布式锁，分布式对象等功能 -->
        <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.导入依赖

<!--整合springCache-->
        <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;
    }
}