一、缓存

1、缓存使用

        为了系统性能的提升，我们一般都会将部分数据放入缓存中，加速访问。

        适合放入缓存的数据有：

                即时性、数据一致性要求不高的；访问量大且更新频率不高的数据。

        在开发中，凡是放入缓存中的数据我们都应该指定过期时间，使其可以在系统即使没有主动更新数据也能自动触发数据加载进缓存的流程。避免业务崩溃导致的数据永久不一致问题。

2、使用redis作为缓存

 引入依赖

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

配置文件

spring:
    redis:
        host: 192.168.56.10
        port: 6379

使用RedisTemplate操作redis 

@Autowired
StringRedisTemplate stringRedisTemplate;

@Test
public void testStringRedisTemplate(){
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    ops.set("hello","world_"+ UUID.randomUUID().toString());
    String hello = ops.get("hello");
    System.out.println(hello);
}

二、缓存失效问题

1、缓存穿透

        缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数 据库也无此记录，我们没有将这次查询的 null 写入缓存，这将导致这个不存在的数据每次 请求都要到存储层去查询，失去了缓存的意义。

        在流量大时，可能 DB 就挂掉了，要是有人利用不存在的 key 频繁攻击我们的应用，这就是 漏洞。

        解决： 缓存空结果、并且设置短的过期时间。

2、缓存雪崩

        缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部转发到 DB，DB 瞬时压力过重雪崩。

        解决： 原有的失效时间基础上增加一个随机值，比如 1-5 分钟随机，这样每一个缓存的过期时间的 重复率就会降低，就很难引发集体失效的事件。

3、缓存击穿

        对于一些设置了过期时间的 key，如果这些 key 可能会在某些时间点被超高并发地访问， 是一种非常“热点”的数据。 这个时候，需要考虑一个问题：如果这个 key 在大量请求同时进来前正好失效，那么所 有对这个 key 的数据查询都落到 db，我们称为缓存击穿。

        解决： 加锁。缓存不存在时。在查询数据库前先获取锁，在得到锁后，再次确认缓存是否存在，不存在则查询数据库并更新缓存。

三、缓存数据的一致性

1、保证一致性

双写模式

失效模式

读写锁

读数据等待写数据整个操作完成。

四、分布式锁

1、分布式锁与本地锁

本地锁只能锁住当前进程，在分布式情况下，有多少个服务就会产生几把锁。

2、分布式锁实现

public Map<String, List<Catelog2Vo>> getCatalogJsonFromDBWithRedisLock() {

        //1、占用分布式锁 锁和过期时间一起设置  原子性操作
        String uuid = UUID.randomUUID().toString();
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid, 300, TimeUnit.SECONDS); //锁设置的时间很长，防止业务执行期间锁过期  todo 自动续锁
        if (lock) { //加锁成功
            System.out.println("获取分布式锁成功");
            //设置过期时间, 必须和加锁是原子性操作
            //redisTemplate.expire("lock", 30, TimeUnit.SECONDS);
            Map<String, List<Catelog2Vo>> lockThenDo = null;
            try {
                lockThenDo = getLockThenDo();
            } finally {
                //lua 脚本解锁
                String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
                redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Collections.singletonList("lock"), uuid);
            }

            //解锁，不能随便删除别人的锁
            //两步：获取值对比， 对比成功删除    一定要是原子性
//            redisTemplate.delete("lock");
//            String uuidString = redisTemplate.opsForValue().get("lock");
//            if (uuid.equalsIgnoreCase(uuidString)) {
//                //删除自己的锁
//                redisTemplate.delete("lock");
//            }

            return lockThenDo;
        } else {
            //加锁失败重试  自旋的方式
            //可以设置休眠 后重试
            System.out.println("获取分布式锁不成功，等待重试。。。。");
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return getCatalogJsonFromDBWithRedisLock();
        }
    }

3、Redisson完成分布式锁

1、简介

        Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分的利用了 Redis 键值数据库提供的一系列优势，基于 Java 实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。

RLock lock = redisson.getLock("anyLock");// 最常见的使用方法
lock.lock();
// 加锁以后 10 秒钟自动解锁// 无需调用 unlock 方法手动解锁
lock.lock(10, TimeUnit.SECONDS);
// 尝试加锁，最多等待 100 秒，上锁以后 10 秒自动解锁 
Boolean res = lock.tryLock(100,10, TimeUnit.SECONDS);
if (res) {
    try {
        ...
    } finally {
        lock.unlock();
    }
}

五、springCache

1、简介

        Spring Cache利用了AOP，实现了基于注解的缓存功能，并且进行了合理的抽象，业务代码只需要简单地加一个注解，就能实现缓存功能了。

2、使用

启用缓存

//只需要在配置类中添加 @EnableCaching
@Configuration
@EnableCaching
public class CachingConfig {

    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager("addresses");
    }
}

 在需要缓存的数据方法加上注解

//    @CacheEvict(value = "catagory", allEntries = true)   第二种方法  批量删除某个分区下的所有数据
//    @Caching(evict = {
//            @CacheEvict(value = "catagory", key = "'getLevel1Cate'"),   //同时进行多种缓存操作  第一种方法 todo
//            @CacheEvict(value = "catagory", key = "'getCatelogJson'")
//    })
//    @CachePut //双写模式

    @CacheEvict(value = "catagory", key = "'getLevel1Cate'") //修改后自动删除缓存
    @Transactional
    @Override
    public List<CategoryEntity> updateCascade(CategoryEntity category) {}