Redis实战 - 《Java基础》

redis是一个键值型的数据库
认识redis
一、短信登陆实战
- 1、基于Session实现短信登陆流程
  - 1.session方法生成手机号验证码
  - 2.session
二、商户查询缓存
- 缓存流程

https://www.bilibili.com/video/BV1cr4y1671t?p=2&vd_source=414a65d222d782153399fbb03cc8be4b

redis是一个键值型的数据库

nosql不严格要求约束

nosql语句的查询方式不统一没有复杂的语法

差异4 事务
事务要满足原子性一致性隔离性所有关系型数据库都是满足ACID的
Nosql一般无事务只有基本的一致性安全性要求高的应该选择关系型数据库

扩展性 SQL垂直导致不好拆分库表

认识redis

一、短信登陆实战

1、基于Session实现短信登陆流程

1.session方法生成手机号验证码

@Override
    public Result sendCode(String phone, HttpSession session) {
        // 1校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            //2.如果不符合返回错误信息
            return Result.fail("手机号格式错误");
        }
        //3. 符合生成验证码
        String code = RandomUtil.randomNumbers(6);
        //4.保存验证码到session
        session.setAttribute("code", code);
        //5.发送验证码
        log.debug("发送短信 验证码成功，验证码:{}",code);
        //返回OK
        return Result.ok();
    }

2.session

package com.hmdp.utils;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Map;
import java.util.concurrent.TimeUnit;
/**
 * @Description:拦截器，用于拦截未登录用户的请求，并通过拦截器刷新用户的token有效期，此拦截器通过MvcConfig加载到spring并设置拦截请求地址
 * @Auther:$
 */
public class LoginInterceptor implements HandlerInterceptor {
    private StringRedisTemplate stringRedisTemplate;
    public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取请求头中的token
        //HttpSession session = request.getSession();
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            //获取请求头 如果没有就false
            response.setStatus(401);
            return false;
        }
        //2.获取session中的用户 session中的user是UserDTO类型的，所以拦截器保存当ThreadLocal也需要是UserDTO类型的
        //Object user = session.getAttribute("user");
        //2.基于TOKEN获取redis中的用户
        String key = RedisConstants.LOGIN_USER_KEY+token;//取出token
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash()
                .entries(key);//通过token取出用户
        //3.判断用户是否存在
        if (userMap.isEmpty()) {
            //4.不存在拦截
            response.setStatus(401);
            return false;
        }
        //5. 将查询到的Hash数据转为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //6.存在用户，保存用户信息到ThreadLocal
        UserHolder.saveUser((UserDTO) userDTO);
        //7.通过token，刷新token有效期
        stringRedisTemplate.expire(key, RedisConstants.LOGIN_USER_TTL, TimeUnit.SECONDS);
        //8.放行
        return true;
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //移除用户
        UserHolder.removeUser();
    }
}

二、商户查询缓存

当用户去查询商户信息，如果商户信息是比较热门的那么会经常去数据库中查询这个信息，会对数据库有非常大的损耗，所以在客户端和数据库之间可以加一层缓存，把用户访问过的信息存到redis缓存中，这样当用户再去查询相同内容的时候就不必从数据库中重新查找而是直接从缓存中拿取，非常方便

缓存流程

public class ShopServiceImpl extends ServiceImpl<ShopMapper,Shop> implements IShopService{
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryById(Long id){
    //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:"+id);
    //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
    //3. 存在直接返回
            Shop shop= JSONUtil.toBean(ShopJson,Shop.class);
            return Result.ok(shop);
        }
    //4.不存在根据id查询数据库
        Shop shop = getById(id);
    //5.不存在返回错误
    if(shop ==null){
        return Result.fail("此店铺不存在");
    }    
    //6.存在，写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(shop));
    //7.返回
    return Result.ok(shop);
    }
}

现在又有了新的问题，虽然说是能够将缓存保存到redis中，查询更快，但是可能会出现，我修改了店铺信息，但是redis中存储的信息依旧是之前的信息，导致数据不一致，redis和数据库中存储的信息不一样。
所以对缓存的更新有更高的要求：

缓存更新策略

业务场景：一致性区别
低一致性需求：使用内存淘汰机制。例如店铺类型的查询缓存
高一致性需求：主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存

先删除缓存，再操作数据库：
在线程执行的过程中另外一个线程来了
线程1去删除了缓存，此时缓存中没有了，但是当线程1还没更新数据库时，线程2来了，线程2去查缓存发现没有就去查数据库，此时线程2去查的值是之前的值，因为新的值线程1还没存到数据库中，此时线程2去查数据库查的是之前的值，并写入了缓存，缓存中还是旧的值，线程2完成了之后线程1该开始更新数据库了，结果就是线程1更新完数据库了但是因为线程2的出现导致缓存中还是旧的值，而且缓存和数据库的值未统一。这就是线程安全产生的问题。发生概率高。
先操作数据库再删缓存：
容易出错情况：恰好缓存失效了，线程1去查，缓存中没有，未命中去数据库里查了，然后写入缓存，但是正在此时，线程2更新数据库，然后再删缓存，然后线程1去写入缓存，但是因为线程1查的是旧数据，所以写入的也是旧数据。
这种情况概率很低。而且可以在修改之前让缓存失效时间增加避免此情况

实现商铺缓存和数据库一致

public class ShopServiceImpl extends ServiceImpl<ShopMapper,Shop> implements IShopService{
    @Resource
    private StringRedisTemplate stringRedisTemplate;
@Transactional
public Result update(Shop shop){
    Long id = shop.getId();
    if(id == null){
        return Result.fail("店铺id不能为空");
    }
    //1.更新数据库
    updateById(shop);
    //2.删除缓存
    stringRedisTemplate.delete(CACHE_SHOP_KEY+id);
    return Result.ok();
}}

缓存穿透

企业遇到这种情况有的就会即时是数据库中没有这个东西也会缓存到redis中尽管值是null，但是有额外的内存消耗，也可以设置ttl

布隆过滤是一个算法，先去布隆过滤去查这个数据存不存在，如果不存在就直接拒绝，如果存在就去redis里查询，布隆过滤器怎么知道存在？把数据基于Hash算法计算成hash值，将hash值转换为二进制位，去保存，再判断是否存在并不是百分比准确，不存在是真不存在，说存在不一定存在，有一点穿透风险。

解决缓存穿透

解决缓存穿透，1是将不存在的商铺以空值的形式写入Redis 2是请求的时候命中了要判断一下是不是空值，避免返回一个null 如果是空的就直接结束

public class ShopServiceImpl extends ServiceImpl<ShopMapper,Shop> implements IShopService{
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryById(Long id){
    //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:"+id);
    //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
    //3. 存在直接返回
            Shop shop= JSONUtil.toBean(ShopJson,Shop.class);
            return Result.ok(shop);
        }
    //判断命中的是否是空值
        if(shopJson !=null){
            //返回一个错误信息
            return Result.fail("店铺信息不存在");
        }
    //4.不存在根据id查询数据库
        Shop shop = getById(id);
    //5.不存在返回错误
    if(shop ==null){
        //将空值写入redis
        stringRedisTemplate.opsForValue().set(key,"",2,TimeUtil.MINUTES); 
        return Result.fail("此店铺不存在");
    }    
    //6.存在，写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(shop));
    //7.返回
    return Result.ok(shop);
    }
}

缓存雪崩

就是短时间内大量的key同时失效，或者Redis宕机后导致大量请求请求到数据库，带来很大的压力
解决：给不太的key的TTL添加随机值
利用Redis集群提高服务的可用性
给缓存业务添加降级限流策略：让请求失败拒绝服务，而不是让请求压到数据库中去，保护数据库牺牲服务
给业务添加多级缓存：多添加几级缓存，可以在nginx中添加缓存，再去redis
以上的问题可以通过springcloud解决记得看！

缓存击穿

部分key过期导致的
缓存击穿问题也叫热点key问题，就是被高并发访问并且缓存重建业务较为复杂的key突然消失了，无数的请求访问会在瞬间给数据库带来巨大的冲击。
就是有一些复杂的业务，访问的时间很长，导致缓存到redis中的时间很久，导致大量的访问请求到了数据库当中，导致数据库崩塌。

两种解决方案：互斥锁，逻辑过期

互斥锁：一个线程进行查询其他等待，会导致效率低

逻辑过期：因为短期内大量的key过期，所以不设置过期时间了，直接逻辑过期
，在字段中加上一个expire 注意这个不是ttl只是字段，针对热点key，

基于互斥锁方式解决缓存击穿问题

public class ShopServiceImpl extends ServiceImpl<ShopMapper,Shop> implements IShopService{
    @Resource
    private StringRedisTemplate stringRedisTemplate;
public Result queryById(Long id){
    //缓存穿透
    //Shop shop = queryWithPassThrough(id);
    //互斥锁解决缓存击穿
    Shop shop = queryWithMutex(id);
    //返回
    return Result.ok(shop);
}
 public Shop queryWithMutex(Long id){
     //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:"+id);
    //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
    //3. 存在直接返回
            return JSONUtil.toBean(ShopJson,Shop.class) ;
        }
    //判断命中是否为空值
    if(shopJson!=null){
        //返回一个错误信息
        return null;
    }
     //实现缓存重建
     //4.1获取互斥锁
     String lockKey = "lock:shop:"+id;
     boolean isLock = tryLock(lockKey);
     //4.2判断是否获取成功
     if(!isLock){
         //4.3失败，则休眠并重试
         Thread.sleep(50);
         //重试 重新去执行查询操作
         return queryWithMutex(id);
     }
     //4.4成功 根据id查询数据库
     Shop shop = getById(id);
     ///未命中 情况 尝试使用互斥锁去解决
    //5.不存在返回错误
    if(shop ==null){
        //将空值写入redis
        stringRedisTemplate.opsForValue().set(key,"",5,TimeUtil.MINUTES;
        //返回错误信息
        return null;
    }    
    //6.存在，写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(shop));
    //7.释放互斥锁
    unlock(lockKey);                                    
    //8.返回
    return shop;
}
public Shop queryWithPassThrough(Long id){
     //1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get("cache:shop:"+id);
    //2.判断是否存在
        if(StrUtil.isNotBlank(shopJson)){
    //3. 存在直接返回
            return JSONUtil.toBean(ShopJson,Shop.class) ;
        }
    //判断命中是否为空值
    if(shopJson!=null){
        //返回一个错误信息
        return null;
    }
    //4.不存在根据id查询数据库
        Shop shop = getById(id);
    //5.不存在返回错误
    if(shop ==null){
        //将空值写入redis
        stringRedisTemplate.opsForValue().set(key,"",5,TimeUtil.MINUTES;
        //返回错误信息
        return null;
    }    
    //6.存在，写入redis
        stringRedisTemplate.opsForValue().set("cache:shop:"+id,JSONUtil.toJsonStr(shop));
    //7.返回
    return shop;
}
//开锁
private boolean tryLock(String key){
   Boolean flag =  stringRedisTemplate.opsForValue().setIfAbsent(key,"1",10,TimeUnit.SECONDS);//设置锁 和锁过期时间
   return Boolean.isTrue(falg);//由于方法是基本数据类型boolean，如果直接返回这个flag，会做拆箱的，可能会有空指针，所以用方法   
}
//关锁
private void unlock(String key){
    stringRedisTemplate.delete(key);
}