Redis的使用场景 Day05

1. 作为缓存

1.1 为什么要使用数据库缓存

使用Redis作为数据库缓存可以减少对数据库的访问频率，提高数据的访问率。

1.2 什么样的数据适合放入缓存

①热点数据
②修改频率比较低的数据
③安全系数较低的数据

缓存的原理：

1.3 Redis作为缓存的使用

①搭建一个Spring Boot+Mybatis的工程
②引入Redis相关依赖
③配置Redis
④在Service层编写Redis缓存代码，可以使用两种方式实现。
<1> 注入RedisTemplate类

@Service
public class ClassServiceImpl implements ClassService {

    @Resource
    private ClassDao classDao;

    @Autowired
    private RedisTemplate redisTemplate;

    //作用：先查缓存，缓存存在不会执行代码块，缓存不存在，则执行数据库查询。
    //查询完成后存入Redis
    //第一个值为捕捉的方法，第二个值为传来的cid参数，两者拼接形成Redis中的key
    //查询
    @Override
    public BookClass findById(Integer cid) {
        Object o = redisTemplate.opsForValue().get("findById::" + cid);
        if (o!=null){
            return (BookClass)o;
        }
        BookClass bookClass = classDao.selectById(cid);
        redisTemplate.opsForValue().set("findById::"+cid,bookClass);//把查询的结果放入缓存
        return bookClass;
    }
    //删除
     @Override
    public int delete(Integer cid) {
        redisTemplate.delete("findById::"+cid);
        int i = classDao.deleteById(cid);
        return i;
    }
	//修改
    @Override
    public int update(BookClass bookClass) {
        redisTemplate.delete("findById::"+bookClass.getCid());
        int i = classDao.updateById(bookClass);
        redisTemplate.opsForValue().set("findById::"+bookClass.getCid(),bookClass);//把查询的结果放入缓存
        return i;
    }
}

<2> 使用注解

@Service
public class Class2ServiceImpl implements Class2Service {

    @Resource
    private ClassDao classDao;

    //注解作用：先查缓存，缓存存在不会执行代码块，缓存不存在，则执行数据库查询。
    //查询完成后存入redis
    //第一个值为捕捉的方法，第二个值为参数cid,存入Redis拼接为key
    @Cacheable(cacheNames = "findById",key = "#cid")  //缓存的key值 为findById::cid
    @Override
    public BookClass findById(Integer cid) {
        BookClass bookClass = classDao.selectById(cid);
        return bookClass;
    }

    //数据库和缓存同步问题！
    // beforeInvocation：是否在方法执行前就清空，缺省为 false，
    // 如果指定为 true，则在方法还没有执行的时候就清空缓存。缺省情况下，如果方法执行抛出异常，则不会清空缓存。
    @CacheEvict(cacheNames = "findById",key = "#cid")
    @Override
    public int delete(Integer cid) {
        int i = classDao.deleteById(cid);
        return i;
    }

    //这个注解是必须执行方法体，而且会把方法体执行的结果放入到缓存中。 如果发生异常则不操作缓存。
    @CachePut(cacheNames = "findById",key = "#bookClass.cid",unless = "#result eq null")
    @Override
    public BookClass update(BookClass bookClass) {
        int i = classDao.updateById(bookClass);
        return bookClass;
    }
}

2. 作为分布式锁

2.1 什么是分布式锁

分布式锁，是一种思想，它的实现方式有很多。比如，我们将沙滩当做分布式锁的组件，那么它看起来应该是这样的：

加锁
在沙滩上踩一脚，留下自己的脚印，就对应了加锁操作。其他进程或者线程，看到沙滩上已经有脚印，证明锁已被别人持有，则等待。

解锁
把脚印从沙滩上抹去，就是解锁的过程。

锁超时
为了避免死锁，我们可以设置一阵风，在单位时间后刮起，将脚印自动抹去。

分布式锁的实现有很多，比如基于数据库、memcached、Redis、系统文件、zookeeper等。它们的核心的理念跟上面的过程大致相同。

2.2 为什么要使用分布式锁

在Java中并发编程中，我们通过锁，来避免由于竞争而造成的数据不一致问题。通常，我们以synchronized 、Lock来使用它。

但是Java中的锁，只能保证在同一个JVM进程内中执行，无法保证分布式集群环境下数据的同步。

2.3 Redis作为分布式锁

@Service
public class StockService {

    @Resource
    private StockDao stockDao;

    @Autowired
    private StringRedisTemplate redisTemplate;

    public String decrStock(Integer cid) {//synchronized () 同步方法    同步代码块
        Boolean flag = redisTemplate.opsForValue().setIfAbsent("buy::" + cid, "utaha",30, TimeUnit.SECONDS);
        //查询对应的id的库存
         if(flag) {//获取锁了
             try {
                 Stock stock = stockDao.selectById(cid);
                 if (stock.getNum() > 0) {
                     //根据id修改库存
                     stock.setNum(stock.getNum() - 1);
                     stockDao.updateById(stock); //异常发生
//                   int c=10/0;
                     System.out.println("库存剩余:" + (stock.getNum()));
                     return "库存减少成功";
                 } else {
                     return "库存不足";
                 }
             }catch (Exception e){
                  throw  new RuntimeException(e.getMessage());
             }
             finally {
                 redisTemplate.delete("buy::" + cid);//释放锁资源 一定再finally
             }
         }else{
             return "服务器正忙请稍后再试..........";
         }
    }
}

至此，Redis的分布式锁的实现就已经完成了，但是很这只是最简单的业务逻辑，如果复杂的业务逻辑呢？我们就会陷入无限的上锁释放锁的代码书写轮回中。怎么解决呢？

2.4 使用Redisson

2.4.1 什么是Redisson

Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间的协作。

Redisson原理：

2.4.2 Redisson的使用

①Maven引入依赖

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

②通过配置类获取RedissonClient客户端的实例

    @Bean
    public RedissonClient getRedisson(){
        Config config = new Config();
        config.useSentinelServers().addSentinelAddress("redis://192.168.23.224:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }

③使用Redisson分布式锁

@Service
public class StockService1Impl implements StockService1 {

    @Autowired
    private RedissonClient redissonClient;

    @Resource
    private StockDao stockDao;

    @Override
    public String decrStock(Integer cid) {
        RLock lock = redissonClient.getLock("buy::" + cid);
        try {
            lock.lock();
            BookClass bookClass = stockDao.selectById(cid);
            if (bookClass.getCount() > 0) {
                bookClass.setCount(bookClass.getCount() - 1);
                stockDao.updateById(bookClass);
                System.out.println("库存剩余:" + bookClass.getCount());
                return "库存减少成功";
            } else {
                return "库存不足";
            }
        }catch (Exception e){
            throw new RuntimeException(e.getMessage());
        }finally {
            //看门狗判断是否还是锁定状态，如果是则延迟时间
            if (lock.isLocked()){
                //当前执行线程的锁
                if (lock.isHeldByCurrentThread()){
                    lock.unlock();
                }
            }
        }
    }
}

这里涉及到看门狗原理，举个例子，Redisson中每个线程持有的锁的有效期默认时间是30秒，但是 线程1 业务还没有执行完，时间就过了，线程1 还想持有锁的话，就会启动一个watch dog后台线程，不断的延长锁key的生存时间，延长的机制为看门狗每隔10秒都会查看线程1是否执行完毕，如果没执行完自动再续成30秒直到线程1执行完毕。

如果我们指定了锁的超时时间，默认超时就是我们制定的时间，不会自动续期。如果我们未指定锁的超时时间，就使用 lockWatchdogTimeout = 30 * 1000 【看门狗默认时间】

3. 作为点赞量，排行榜，转发量

什么是计数器，如电商网站商品的浏览量、视频网站视频的播放数等。为了保证数据实时效，每次浏览都得给+1，并发量高时如果每次都请求数据库操作无疑是种挑战和压力。Redis提供的incr命令来实现计数器功能，内存操作，性能非常好，非常适用于这些计数场景 。

关系型数据库在排行榜方面查询速度普遍偏慢，所以可以借助Redis的SortedSet进行热点数据的排序。 在奶茶活动中，我们需要展示各个部门的点赞排行榜， 所以我针对每个部门做了一个SortedSet,然后以用户的openid作为上面的username,以用户的点赞数作为上面的score, 然后针对每个用户做一个hash, 通过zrangebyscore就可以按照点赞数获取排行榜，然后再根据username获取用户的hash信息。

4. 限时业务的运用

Redis中可以使用expire命令设置一个键的生存时间，到时间后Redis会删除它。利用这一特性可以运用在限时的优惠活动信息、手机验证码等业务场景。