黑马点评项目全面业务总结

叁歲伎倆 2024-03-31 10:12 93阅读 0赞

## 1 黑马点评项目 ##

### 1.1 短信登陆 ###

#### 1.1.1 短信登陆简介 ####

**session共享问题**:多台服务器并不共享session存储空间,当请求切换到不同tomcat服务时导致数据丢失的问题。

[![ASJVzyEp5dtiYkT.png][]][ASJVzyEp5dtiYkT.png 1]

*  在进行短信登录时,运用redis的String数据结构把手机号作为key,验证码作为value进行存储。
 *  查询用户获得用户信息后,运用redis的hash结构,用token当做key存储(token的意思是“令牌”，是服务器生成的一段加密字符串),用户信息作为一个一个hash存储。  
    **为什么不用String数据结构?**  
    Hash结构可以将对象中的每个字段独立存储,可以针对单个字段做CRUD,并且内存占用更少。String是以JSON字符串来保存的,虽然比较直观,但是不能进行CRUD。

#### 1.1.2 校验登录状态 ####

**主要逻辑:验证手机号格式 如果不符合,返回错误信息,如果符合生成验证码,就运用redis的String数据结构对手机号和验证码进行存储 redis存储一般有个公共前缀并且设置有效时间 一般两分钟 最后返回ok;**

//Slfg4    日志注解
        public Result sendCode(String phone, HttpSession session) {
        
            //1:先验证手机号格式  不符合就返回错误信息
            if(RegexUtils.isPhoneInvalid(phone)){
        
                //2:如果不符合,返回错误信息
                return Result.fail("手机号格式错误");
            }
                //4:生成验证码
                String code = RandomUtil.randomNumbers(6);
               //保存验证码到redis phone作为key 并且有一个公共前缀
    
                stringRedisTemplate.opsForValue()
                .set(RedisConstants.LOGIN_CODE_KEY +phone,code
                        ,RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
                //6:发送验证码
                log.debug("验证码是{}",code);
                return Result.ok();
    
        }

#### 1.1.3短信验证码登录和注册 ####

**主要逻辑:前端给手机号,以手机号从redis里面拿出验证码,比较验证码,如果不等则返回错误"验证码不正确",如果相等看看是否被注册过,如果没有被注册过,需要插入数据,没注册过的话直接返回UserDto对象(注:UserDto对象相比User对象少了一些敏感信息,例如:密码),然后将对象存储到redis的hash结构里面,并设置有效期 一般为30分钟**

@Override
        public Result login(LoginFormDTO loginForm, HttpSession session) {
        
            //获取手机号
            String phone = loginForm.getPhone();
            if(RegexUtils.isPhoneInvalid(phone)){
        
                //2:如果不符合,返回错误信息
                return Result.fail("手机号格式错误");
            }
            //从reids中拿出验证码
            String code = stringRedisTemplate.opsForValue()
            .get(RedisConstants.LOGIN_CODE_KEY + phone);
            if(loginForm.getPhone().equals(code)){
        
                //如果验证码错误直接返回false
                return Result.fail("验证码不正确");
            }
            //如果正确 在确定手机号是否已经被注册过
            User user = query().eq("phone", phone).one();
            //生成token  用hutool工具类生成的uuid toString(true)可以把uuid中的-去掉
            String token = UUID.randomUUID().toString(true);
            if(user==null){
        
                //没有注册过新建并插入新数据
                user=CreateNewUser(phone);
            }
            //hutool工具类 Beanutil
            UserDTO userDTO= BeanUtil.copyProperties(user, UserDTO.class);
            //运用redis中的map数据结构存储userDto对象
            Map<String,String> map=new  HashMap<>();
            map.put("id",userDTO.getId().toString());
            map.put("nickName",userDTO.getNickName());
            map.put("icon",userDTO.getIcon());
            stringRedisTemplate.opsForHash()
            .putAll(RedisConstants.LOGIN_USER_KEY+token,map);
            //设置时间一般是30分钟不进行操作,就会失效
            stringRedisTemplate
            .expire(RedisConstants.LOGIN_USER_KEY+token, 
            RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
          return Result.ok(token);
        }
    
        private User CreateNewUser(String phone) {
        
         User user=new User();
         user.setPhone(phone);
         user.setNickName(USER_NICK_NAME_PREFIX+RandomUtil.randomString(4));
         save(user);
         return  user;
        }

#### 1.1.4 拦截器的实现 ####

[![g5tNILAb31D8CKU.png][]][g5tNILAb31D8CKU.png 1]

**主要逻辑:一个拦截器是更新拦截器,主要是更新token的有效期,一个拦截不合法的路径,更新拦截器首先获得token对象 如果token为空直接放行。若不为空的话token刷新token的有效期，然后用token从redis里面拿出UserDTO的map对象,然后把map对象转换为UserDTO对象,存入ThreadLocal域中。在拦截器执行之后将TheadLocal域中的对象释放掉,避免发生内存泄漏.一个拦截器只用判断ThreadLocal域中有没有UserDTO对象,如果有则放行,如果没有就拦截.**

//更新拦截器 主要是更新token有效期 另外拦截器不是spring管理的bean 
    //里面不能用自动注入注解 需要用构造方法
    public class RefreshInterceptor implements HandlerInterceptor {
        
        private StringRedisTemplate stringRedisTemplate;
    
        public RefreshInterceptor(StringRedisTemplate stringRedisTemplate) {
        
            this.stringRedisTemplate = stringRedisTemplate;
        }
    
        @Override
        public boolean preHandle(HttpServletRequest request,
         HttpServletResponse response, Object handler) throws Exception {
        
            //从对象头获得token
            String token = request.getHeader("authorization");
            if(StrUtil.isBlank(token)){
        
                return true;
            }
            //若不为空放行,并且把用户放进TheadLocal并且把时间重置为30分钟
            Map<Object, Object> map = stringRedisTemplate.opsForHash()
                    .entries(RedisConstants.LOGIN_USER_KEY+token);
            if(map.isEmpty()){
        
                return true;
            }
            //hutool工具类 将map转换为实体类对象
            UserDTO userDTO = BeanUtil.fillBeanWithMap(map, new UserDTO(), false);
            UserHolder.saveUser(userDTO);
            stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY+token,
                    RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
    
            return true;
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        
         //释放Thread中的user类 避免内存泄露
            UserHolder.removeUser();
        }
    }
    //目的是拦截不合法的路径
    public class LoginInterceptor implements HandlerInterceptor {
        
        @Override
        public boolean preHandle(HttpServletRequest request
        , HttpServletResponse response, Object handler) throws Exception {
        
            System.out.println("执行拦截器");
            System.out.println(UserHolder.getUser());
            if(UserHolder.getUser()==null){
        
               //状态码401 表示没授权
               response.setStatus(401);
               return false;
           }
           return true;
        }
    }

**拦截器的配置**

@Configuration
    public class MvcConfig implements WebMvcConfigurer {
        
        @Resource
        private StringRedisTemplate stringRedisTemplate;
        @Override
        //登录拦截器
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(new LoginInterceptor()).excludePathPatterns(
                 "/shop/**",
                 "/voucher/**",
                 "/shop-type/**",
                 "upload/**",
                 "/blog/hot",
                 "/user/code",
                 "/user/login"
            ).order(1);
            //刷新放行拦截器
            registry.addInterceptor(new RefreshInterceptor(stringRedisTemplate))
            .addPathPatterns("/**").order(0);
        }
    }

### 1.2 商户查询缓存 ###

#### 1.2.1 redis缓存简介 ####

**缓存就是数据交换的缓冲区，是存储数据的临时地方,一般读写性能比较高**

缓存的作用?

*  降低后端负载
 *  提高读写效率,降低相应时间

缓存的成本?

*  数据一致性成本
 *  代码维护成本
 *  运维成本

#### 1.2.2添加商户缓存 ####

[![qWbrX4YkKVOpdmI.png][]][qWbrX4YkKVOpdmI.png 1]

**具体流程：根据前端返回的id的数据,查商品信息,接收到id后,先从redis里面拿数据,如果有直接返回,如果没有在从数据库里面拿商品信息,如果没有报错商品不存在,如果有先往redis缓存里存入数据并且设置有效期(避免缓存数据与数据库的数据长期不一致)。**

@Override
        public Result queryShopById(Long id) {
        
            //根据id看看redis有没有缓存
            String shopString = stringRedisTemplate.opsForValue()
            .get(RedisConstants.CACHE_SHOP_KEY + id);
            if(StrUtil.isNotBlank(shopString)){
        
                //如果有 直接返回
                //hutool工具类
                Shop shop = JSONUtil.toBean(shopString, Shop.class);
                return Result.ok(shop);
            }
            //如果没有从数据库查
            Shop shop = getById(id);
            if(shop==null){
        
                //数据库没有 返回404 没有该商品
                return Result.fail("该店铺不存在");
            }
            //数据库有 往redis插入数据 并且返回数据
            stringRedisTemplate.opsForValue()
            .set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil
            .toJsonStr(shop),RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
            return Result.ok(shop);
        }

#### 1.2.3 缓存更新策略 ####

[![ltwqpuSNb4dUCsB.png][]][ltwqpuSNb4dUCsB.png 1]

操作缓存和数据库有三个问题?

1.  删除缓存还是更新缓存
    
     *  更新缓存:每次更新数据库都会更新缓存,无效写操作比较多(比如:如果一直改而没有查 缓存也会一直改,效率低)
     *  删除缓存:更新数据库时让缓存失效,查询时在更新缓存( 采用)
2.  如何保证缓存与数据库的操作同时成功或失效
    
     *  单体系统,将缓存与数据库操作放在一个事务
     *  分布式系统,利用TCC等分布式事务方案
3.  先操作缓存还是先操作数据库?
    
     *  先删除缓存,在操作数据库:如果线程一删除了缓存,线程二查询缓存没查到,然后写入了缓存,这时候线程一才更新完数据库 这时候会造成数据不一致
     *  先操作数据库,在删除缓存:如果线程一查询缓存没命中,查询数据库，线程二更新数据库 并且删除缓存，这时候线程一才写入缓存 会造成数据不一致，但是一般缓存的读写比数据库快 所以这种方式几率很小

[![7JXgkiZSmCKraYw.png][]][7JXgkiZSmCKraYw.png 1]

**具体流程:首先获得前端给的修改的数据 ,判断id是否为空,为空直接返回错误,不为空就先更新数据库,在删除redis的缓存**

@Override
        @Transactional//事务注解
        public Result updateShop(Shop shop) {
        
            Long id = shop.getId();
            if(id==null){
        
                //先检查id是否为空
                return Result.fail("商品id不能为空");
            }
            //先更新数据库
            updateById(shop);
            //在删除缓存
            stringRedisTemplate.delete(RedisConstants.CACHE_SHOP_KEY+id);
             return Result.ok();  
        }

#### 1.2.4解决缓存穿透 ####

[![xt6YGw5V4bDvuIf.png][]][xt6YGw5V4bDvuIf.png 1]

具体流程 如果没有该商品 则往redis插入一个空字符串,设置短的有效期,下一次如果在redis里面查的是空字符串的话,则直接返回商品不存在

//缓存穿透解决方案
    if(StrUtil.isNotBlank(shopString)){
        
                //如果有 直接返回
         Shop shop = JSONUtil.toBean(shopString, Shop.class);
         return Result.ok(shop);
       }
    //判断字符串不为null 则为一个空字符串 直接返回404 不用经过数据库查询
    if("".equals(shopString)){
        
                return Result.fail("该商铺不存在");
      }
    
    if(shop==null){
        
           //数据库没有 则往redis插入一个空字符串,并且设置一个短的有效期
        stringRedisTemplate.opsForValue()
        .set(RedisConstants.CACHE_SHOP_KEY+id,""
        ,RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
                return Result.fail("该店铺不存在");
       }

[![FR7cEnvWJBiO2Hk.png][]][FR7cEnvWJBiO2Hk.png 1]

#### 1.2.5解决缓存击穿 ####

缓存击穿问题也叫做热点key问题,就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了,无数请求在瞬间给数据库带来巨大的冲击

常见的解决方案有两种:

*  互斥锁
 *  逻辑过期

互斥锁解决  
具体流程:当redis里面查不到之后,先上锁,锁用的是redis的String数据结构,如果上锁失败,先睡眠,在重新去获得数据.如果上锁成功,进行第二次从redis里面查,如果还查不到,从数据库查,并且插入reids数据,释放锁,返回数据.

private Shop queryWithMutex(Long id){
        
            //获得key
            String key=RedisConstants.CACHE_SHOP_KEY + id;
            //从redis里面获得数据
            String shopString = stringRedisTemplate.opsForValue().get(key);
            if(StrUtil.isNotBlank(shopString)){
        
                Shop shop = JSONUtil.toBean(shopString, Shop.class);
                return shop;
            }
            if("".equals(shopString)){
        
                return null;
            }
            //获得锁的key
            String lockKey = RedisConstants.LOCK_SHOP_KEY + id;
            Shop shop=null;
            try {
        
                //尝试获得锁
                if (!tryLock(lockKey)) {
        
                    //如果没有获的 睡眠 50ms 重新获取值
                    Thread.sleep(RedisConstants.LOCK_SLEEP_TTL);
                    return queryWithMutex(id);
                }
                //如果获得锁 进行第二次 从redis里面获得数据
                String string = stringRedisTemplate.opsForValue().get(key);
                if (StrUtil.isNotBlank(string)) {
        
                    shop = JSONUtil.toBean(string, Shop.class);
                    return shop;
                }
                if ("".equals(string)) {
        
                    return null;
                }
                //第二次没获得 从数据库查
                shop = getById(id);
                //没查到赋空字符串
                if (shop == null) {
        
                    stringRedisTemplate.opsForValue()
                    .set(RedisConstants.CACHE_SHOP_KEY + id, "",
                     RedisConstants.CACHE_NULL_TTL, TimeUnit.MINUTES);
                    return null;
                }
                //查到则直接往redis里面插入值
                stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop),
                        RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
            }catch (InterruptedException e){
        
                throw new RuntimeException(e);
            }finally {
        
                //释放锁
                unLock(lockKey);
            }
            return shop;
        }

逻辑过期(感觉挺重要)

[![eAr5oq4alTRVE17.png][]][eAr5oq4alTRVE17.png 1]

具体流程:一般这种热点key在使用之前需要进行预热,也就是把数据先提前送到缓存中,并设置一个逻辑时间,然后拿到id查数据,如何缓存里面没有则直接返回null,如果有则查看它的逻辑过期时间是否已经过期,如果过期则拿锁,若拿不到直接返回旧值,如果拿到了再从redis拿出来看看是否过期,如果这次没过期,则直接返回,如果依然过期,则开启一个新的线程将商铺数据重新写入redis,最后释放互斥锁

//首先设置一个Shop和过期时间的Bean
    @Data
    //@Data相当于@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode这5个注解的合集
    public class RedisData {
        
        private LocalDateTime expireTime;
        private Object data;
    }

//自定义一个线程用于开启线程
    private static final ExecutorService CACHE_REBUILD_EXECUTOR=
             new ThreadPoolExecutor(10,10,0,
             TimeUnit.MINUTES,new LinkedBlockingDeque<>());
        private Shop queryWithLogicalExpire(Long id){
        
            //从redis拿数据
            String shopString = stringRedisTemplate.opsForValue()
            .get(RedisConstants.CACHE_SHOP_KEY + id);    //如果为空 直接返回空
            if(StrUtil.isBlank(shopString)){
        
              return null;
            }
            //不为空拿出对象和过期时间
            RedisData redisData = JSONUtil.toBean(shopString, RedisData.class);
            Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
            //如果过期时间没到期 直接返回对象
            if(redisData.getExpireTime().isAfter(LocalDateTime.now())){
        
                return shop;
            }
            String lockKey=RedisConstants.LOCK_SHOP_KEY+id;
            //如果过期时间到了 尝试获取锁
            Boolean lock = tryLock(lockKey);
            if(!lock){
        
                //如果没拿到锁直接返回旧数据
                return shop;
            }
            //拿到锁后在进行一次验证过期时间如果这一次已经被修改了 则直接返回
            shopString = stringRedisTemplate.opsForValue()
            .get(RedisConstants.CACHE_SHOP_KEY + id);
            if(StrUtil.isNotBlank(shopString)){
        
                redisData = JSONUtil.toBean(shopString, RedisData.class);
                shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
                if(redisData.getExpireTime().isAfter(LocalDateTime.now())){
        
                    return shop;
                }
            }
            //如果没被修改 运用自定义线程池 开启一个新的线程 进行更新缓存操作
            CACHE_REBUILD_EXECUTOR.submit(()->{
        
                try {
        
                    this.saveRedis(id,20L);
                }catch (Exception e){
        
                    throw new RuntimeException(e);
                }
                finally {
        
                    this.unLock(lockKey);
                }
            });
            return shop;
        }
        //逻辑过期 缓存预热
        public void saveRedis(Long id,Long outTime){
        
            Shop shop = getById(id);
            RedisData rs=new RedisData();
            rs.setData(shop);
            rs.setExpireTime(LocalDateTime.now().plusSeconds(o3utTime));
               stringRedisTemplate.opsForValue()
               .set(RedisConstants.CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(rs));
        }

### 1.3 优惠卷秒杀 ###

#### 1.3.1 Redis实现全局唯一id ####

全局id生成器,一般需要满足一下几个特征:

*  唯一性
 *  高可用
 *  高性能
 *  递增性
 *  安全性

[![2Dgr4Gsa8hw9dAx.png][]][2Dgr4Gsa8hw9dAx.png 1]

id的组成部分:

*  符号位:1bit,永远为0
 *  时间戳:31bit,以秒为单位,可使用69年
 *  序列号:32bit,秒内的计数器,支持每秒产生2^32割不同的id

@Component
    public class RedisIdWorker {
        
        //开始的时间戳 用的是2022/10/19 的时间戳
        private static final long BEGIN_TIMESTAMP=1666137600L;
        //序列号长度
        private static final int COUNT_BITS=32;
        @Resource
        private StringRedisTemplate stringRedisTemplate;
        public long nextId(String keyPrefix){
        
            //生成时间戳
            LocalDateTime now = LocalDateTime.now  //2022-10-19T16:07:19.784197600
            long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
            Long timestamp=nowSecond-BEGIN_TIMESTAMP;
            //生成序列号
            //获得当前日期,精确到天
            //key中有年月日,方便计算一年一月一天的销售总量
            String date=now.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
            //自增长
            Long count=stringRedisTemplate.opsForValue()
            .increment("inc"+keyPrefix+":"+date);
            //将生成的时间戳向右移动32位 然后将序列号或到后32位
            return timestamp<<COUNT_BITS|count;
        }
    }

@Resource
        private RedisIdWorker redisIdWorker;
        //线程池 注意线程池里面的线程必须比CountDownLatch中定义的值多
        private ExecutorService ex=new ThreadPoolExecutor(500,500,0,
         TimeUnit.SECONDS,new LinkedBlockingDeque<>());
        @Test
        void m1() throws InterruptedException {
        
            //CountDownLatch允许 count 个线程阻塞在一个地方，直至所有线程的任务都执行完毕
         CountDownLatch latch=new CountDownLatch(300);
         Runnable task=()-> {
        
             for (int i = 0; i < 100; i++) {
        
                 long id = redisIdWorker.nextId("order");
                 System.out.println("id=" + id);
             }
             //执行一次用countDown减一
             latch.countDown();
         };
         long begin=System.currentTimeMillis();
             for(int i=0;i<300;i++){
        
                 ex.submit(task);
             }
            //全部执行完 才能往下执行
             latch.await();
             Long end=System.currentTimeMillis();
            System.out.println("time="+(end-begin));
         }

#### 1.3.2 实现优惠卷秒杀一人一单功能 ####

public Result seckillVoucher(Long voucherId) {
        
            //获得秒杀优惠卷的id
            SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
            
            if(voucher==null){
        
                return Result.fail("优惠卷不存在");
            }
            if(voucher.getBeginTime().isAfter(LocalDateTime.now())){
        
                return Result.fail("秒杀已经开始");
            }
            if(voucher.getEndTime().isBefore(LocalDateTime.now())){
        
                return Result.fail("秒杀已经结束");
            }
            if(voucher.getStock()<1){
        
                return Result.fail("优惠卷已经被发放完");
            }
            //加锁
            Long userId= UserHolder.getUser().getId();
            //把userId当成锁 toString() 会将id变成字符串
            // 但是toString的源码只是new 了一个新字符串
            //同个id toString()还是不同对象 所以用intern()方法 将字符串放入字符串常量池 并返回
            synchronized (userId.toString().intern()) {
        
                //获取代理对象(事务)  处理事务失效问题 还没学到 以后解决
                IVoucherOrderService proxy=
                (IVoucherOrderService)AopContext.currentProxy();
                /*这个对象需要在接口中声明 
                并且在启动类加入@EnableAspectJAutoProxy(exposeProxy = true)注解
                暴露代理对象  还需要加入<artifactId>aspectjweaver</artifactId> 依赖
                */
                return proxy.createVoucherOrder(voucherId);
            }
        }
        @Transactional
        public Result createVoucherOrder(Long voucherId) {
        
            //为什么不在方法里面加锁?
            //因为 在释放锁之后事务spring才提交事务 释放锁 
            //还没提交的时候 可能另一个线程可能拿到锁
            //线程不安全
            Long userId= UserHolder.getUser().getId();
            //实现一人一单
            int count = query().eq("user_id", userId)
            .eq("voucher_id", voucherId).count();
            if(count>0){
        
                return Result.fail("您已经购买到了");
            }
            //前面已经判断库存是否充足
            //这次在判断 是一种乐观锁的机制 
            //运用cas机制 在进行库存加减的时候 需要再次进行判断 库存是否有
            boolean success = seckillVoucherService.update()
                    .setSql("stock=stock-1")
                    .eq("voucher_id", voucherId)
                    //
                    .gt("stock",0)
                    .update();
            if(!success){
        
                return Result.fail("优惠卷已经被发放完");
            }
    
            VoucherOrder voucherOrder=new VoucherOrder();
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            voucherOrder.setUserId(UserHolder.getUser().getId());
            voucherOrder.setVoucherId(voucherId);
            this.save(voucherOrder);
            return Result.ok(orderId);
        }

然而上述锁只能运用在单体项目中,如果在分布式项目上并不能起到一人一单功能,所以需要分布式锁  
分布式锁:满足分布式系统或集群模式下多线程可见并且互斥的锁

*  多进程可见
 *  高可用
 *  安全性
 *  互斥
 *  高性能 等等

private StringRedisTemplate stringRedisTemplate;
        private String name;
        public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String name) {
        
            this.stringRedisTemplate = stringRedisTemplate;
            this.name = name;
        }
        private static final String KEY_PREFIX="lock:";
        private static final String ID_PREFIX= UUID.randomUUID().toString(true)+"-";
      @Override
         // 上锁
        public boolean tryLock(long timeoutSec) {
        
            //运用uuid和线程id生成 value
            String threadId = ID_PREFIX+Thread.currentThread().getId();
            //前缀和name组成 key
            //设置过期时间 如果redis宕机后 锁还能等时间结束后释放  避免造成死锁
            Boolean success = stringRedisTemplate
            .opsForValue().setIfAbsent(KEY_PREFIX + name, threadId
            ,timeoutSec, TimeUnit.SECONDS);
            return BooleanUtil.isTrue(success);
        }
        @Override
        public void unLock() {
        
            //在释放锁的时候 如果线程一 拿到锁 但是进行阻塞 然后锁失效了 
            //线程二拿到锁 线程一在阻塞消失后 直接删除了线程二的锁 
            //解决方案 lua脚本
            String threadID = ID_PREFIX+Thread.currentThread().getId();
            String id1=stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
            if(threadID.equals(id1)){
        
                stringRedisTemplate.delete(KEY_PREFIX+name);
            }
        }

--- lua脚本能保证代码执行的原子性
    if(redis.call('get',KEYS[1])==ARGV[1]) then
        return redis.call('del',KEYS[1])
    end
    return 0

private  static  final DefaultRedisScript<Long> UNLOCK_SCRIPT;
        static {
        
            //初始化
            UNLOCK_SCRIPT=new DefaultRedisScript<>();
            //设置脚本位置   classPath下的资源
            UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
            //设置返回值
            UNLOCK_SCRIPT.setResultType(Long.class);
        }
       public void unLock() {
        
             stringRedisTemplate.execute(UNLOCK_SCRIPT,
                     Collections.singletonList(KEY_PREFIX+name),
                     ID_PREFIX+Thread.currentThread().getId()
                  );
        }

使用Redisson分布式锁

[![AqjuYmVBZvaIo7Q.png][]][AqjuYmVBZvaIo7Q.png 1]

Redisson可重入锁的原理  
[![lT61ayoetdprBhq.png][]][lT61ayoetdprBhq.png 1]

Redisson的锁重试,和看门狗机制

[![ZR52zQKBG16XSUn.png][]][ZR52zQKBG16XSUn.png 1]

异步秒杀思路

[![aEAZ1NfRelcKwVg.png][]][aEAZ1NfRelcKwVg.png 1]

[![jbwuCRfdAy9TYV4.png][]][jbwuCRfdAy9TYV4.png 1]

异步秒杀的主要流程:在秒杀的时候 判断库存是否充足 如果不充足 直接返回错误,如果是充足的话,将优惠卷id,用户id和订单id存入阻塞队列,另开线程进行数据库交互

-- lua脚本在判断库存是否充足时 是原子性的 避免产生线程问题
    -- 优惠卷id
    local voucherId=ARGV[1]
    -- 1.2 用户id
    local userId=ARGV[2]
    -- 2.数据key
    -- 2.1 库存key
    -- .. 字符串连接符
    local stockKey='seckill:stock:' .. voucherId
    local orderKey='seckill:order:' .. voucherId
    --3脚本业务
    --3.1判断库存是否充足 get stockKey
    if(tonumber(redis.call('get',stockKey))<=0) then
        return 1
    end
    if(redis.call('sismember',orderKey,userId)==1) then
        return 2
    end
    --3.4 扣库存
    redis.call('incrby',stockKey,-1)
    redis.call('sadd',orderKey,userId)
    return 0

public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder>
     implements IVoucherOrderService {
        
         @Resource
         private SeckillVoucherServiceImpl seckillVoucherService;
         @Resource
         private RedisIdWorker redisIdWorker;
         @Resource
         private StringRedisTemplate stringRedisTemplate;
         @Resource
         private RedissonClient redissonClient;
         private  IVoucherOrderService proxy;
        /*阻塞队列特点：当一个线程尝试从队列中获取元素，
        没有元素，线程就会被阻塞，直到队列中有元素，线程才会被唤醒，并去获取元素
        */
         private BlockingQueue<VoucherOrder> orderTasks
         =new ArrayBlockingQueue<>(1024*1024);
        //线程池的创建 
         private static  final ExecutorService SECKILL_ORDER_EXECUTOR= 
         Executors.newSingleThreadExecutor();
        private  static  final DefaultRedisScript<Long> SECKILL_SCRIPT;
        static {
        
            //初始化
            SECKILL_SCRIPT=new DefaultRedisScript<>();
            //设置脚本位置   classPath下的资源
            SECKILL_SCRIPT.setLocation(new ClassPathResource("seckill.lua"));
            //设置返回值
            SECKILL_SCRIPT.setResultType(Long.class);
        }
        //spring的知识 目的是为了让 在类创建时 对这个方法进行初始话
        @PostConstruct//spring注解
        private  void init(){
        
            SECKILL_ORDER_EXECUTOR.submit(new VoucherOrderHandler());
        }
     @Override
        public Result seckillVoucher(Long voucherId){
        
            //执行lua脚本
            Long userId = UserHolder.getUser().getId();
            Long result = stringRedisTemplate.execute(
                    SECKILL_SCRIPT,
                    Collections.emptyList(),
                    voucherId.toString(), userId.toString()
            );
            int r=result.intValue();
            //判断结果为0
            
            if(r!=0){
        
                return Result.fail(r==1?"库存不足":"不能重复下单");
            }
            // 保存阻塞队列 将新建的对象存入阻塞队列
            VoucherOrder voucherOrder=new VoucherOrder();
            long orderId = redisIdWorker.nextId("order");
            voucherOrder.setId(orderId);
            voucherOrder.setUserId(userId);
            voucherOrder.setVoucherId(voucherId);
            //不为0 代表没有购买职责
            //处理spring事务失效问题
            proxy=(IVoucherOrderService) AopContext.currentProxy();
            //加入队列 开辟线程 
            orderTasks.add(voucherOrder);
            //直接返回
            return Result.ok(orderId);
        }
        private   class VoucherOrderHandler implements Runnable{
        
            @Override
            public void run() {
        
                while(true){
        
                    try{
        //这个线程主要从阻塞队列拿出voucherOrder对象 一直循环
                        VoucherOrder voucherOrder=orderTasks.take();
                        handleVoucherOrder(voucherOrder);
                    }catch (Exception e){
        
                        log.error("处理订单异常",e);
                    }
                }
            }
        }
        private  void handleVoucherOrder(VoucherOrder voucherOrder){
        
            //不能在线程里面拿对象了 因为线程变了
            Long userId=voucherOrder.getUserId();
            //分布式锁 获取锁 双重保障
            RLock lock = redissonClient.getLock("lock:order"+userId);
            boolean b = lock.tryLock();
            if(!b){
        
                log.error("不允许重复下单");
                return;
            }
            try{
        
                //调用方法
                proxy.createVoucherOrder(voucherOrder);
            }finally {
        
                lock.unlock();
            }
    
        }
       
        @Transactional
        public void createVoucherOrder(VoucherOrder voucherOrder) {
        
            Long userId= voucherOrder.getUserId();
            //实现一人一单
            int count = query().eq("user_id", userId)
            .eq("voucher_id",voucherOrder.getVoucherId()).count();
            if(count>0){
        
                log.error("用户已经购买过一次!");
                return;
            }
            boolean success = seckillVoucherService.update()
                    .setSql("stock=stock-1")
                    .eq("voucher_id", voucherOrder.getVoucherId())
                    .gt("stock",0)
                    .update();
            if(!success){
        
                log.error("库存不足");
            }
            this.save(voucherOrder);
        }
    
    }

### 1.4点赞功能实现 ###

需求:

*  同一个用户只能点赞一次,再次点击则取消点赞
 *  如果当前用户已经点赞,则点赞按钮高亮显示(前端已实现,判断字段Blog类的isLike属性)

实现步骤:

*  给Blog类中添加一个isLike字段,标示是否被当前用户点赞
 *  修改点赞功能,利用Redis的set集合判断是否点赞过,未点赞过则点赞数+1,一点赞过则点赞-1

@Override
        public Result likeBlog(Long id) {
        
            //获得登录信息
            Long userId = UserHolder.getUser().getId();
            //判断当前登录用户是否已经点赞
            //往redis里面存入key是前缀加上博客id,value是用户id
            Boolean member = stringRedisTemplate.opsForSet()
            .isMember(RedisConstants.BLOG_LIKED_KEY + id, userId.toString());
            if(BooleanUtil.isFalse(member)){
        
                //如果未点赞,可以点赞
                //数据库点赞+1
                boolean success = update().setSql("liked=liked+1")
                .eq("id", id).update();
                if(success) {
        
          //保存用户到redis的set集合
         //stringRedisTemplate.opsForZSet().add(RedisConstants.BLOG_LIKED_KEY + id,
         //    userId.toString(),System.currentTimeMillis());存放在zet中
                    stringRedisTemplate.opsForSet()
                    .add(RedisConstants.BLOG_LIKED_KEY + id, userId.toString());
                }
            }else{
        
                //如果已点赞,取消点赞
                //数据库点赞数-1
                boolean success = update().setSql("liked=liked-1").eq("id", id).update();
                if(success) {
        
               //把用户从redis的set集合移除
                    stringRedisTemplate.opsForSet().remove(RedisConstants.BLOG_LIKED_KEY + id, userId.toString());
                }
            }
            return Result.ok();
        }
    //在每次查询的时候需要判断该用户是否已经点赞了这个博客
        private void isBlogLiked(Blog blog){
        
            // 获得这个用户
            Long userId = UserHolder.getUser().getId();
            //key前缀加博客id  
            String key=RedisConstants.BLOG_LIKED_KEY+blog.getId();
            //查redis里面有没有数据 如果有 isLike返回假 如果没有 则返回真
            Boolean isMember = stringRedisTemplate.opsForSet()
            .isMember(key, userId.toString());
            blog.setIsLike(BooleanUtil.isTrue(isMember));
        }

#### 1.4.1 点赞排行榜 ####

在实现点赞排行榜时 不能用set集合做判断了 因为set是无序的 因此将set要改成zset 将时间戳存放到score中 实现排行

@Override
        public Result queryBlogLikes(Long id) {
        
            //1 查询top5的点赞用户
            String key=RedisConstants.BLOG_LIKED_KEY+id;
            Set<String> top5 = stringRedisTemplate.opsForZSet().range(key, 0, 4);
            //解析出其中的用户id
            if(top5==null||top5.isEmpty()){
        
                return  Result.ok(Collections.emptyList());
            }
            //运用了jdk8中的新特性 有时间学学 将set集合中的String统统改为Long
            List<Long> ids = top5.stream().map(Long::valueOf)
            .collect(Collectors.toList());
            //hutool下的string工具类
            String idsStr = StrUtil.join(",", ids);
            //用in不会根据根据自己的顺序进行排序
            //需要用 select * from tb_user where in(5,1) order by field(id,5,1)
            List<UserDTO> userDTOS = userService.query()
                    .in("id",ids)
                    .last("ORDER BY FIELD(id,"+idsStr+")").list()
                    .stream()
                    .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
                    .collect(Collectors.toList());
            return Result.ok(userDTOS);
        }

#### 1.4.2 关注和取关功能实现 ####

public class FollowServiceImpl extends ServiceImpl<FollowMapper, Follow> implements IFollowService {
        
        @Override
        public Result follow(Long followUserId, Boolean isFollow) {
        
            //获得登录用户
            Long userId = UserHolder.getUser().getId();
            //判断到底是关注还是取关
            if(isFollow){
        
                //直接往表里插入数据
             Follow follow=new Follow();
             follow.setUserId(userId);
             follow.setFollowUserId(followUserId);
             save(follow);
            }else {
        
                //删除数据
                remove(new QueryWrapper<Follow>()
                .eq("user_id", userId).eq("follow_user_id", followUserId));
            }
            //关注,新增取关
            //取关,删除
            return Result.ok();
        }
    
        @Override
        public Result isFollow(Long followUserId) {
        
            //查看有没有关注
            Long userId = UserHolder.getUser().getId();
            Integer count = query()
            .eq("user_id", userId).eq("follow_user_id", followUserId).count();
            return Result.ok(count>0);
        }

#### 1.4.2 共同关注 ####

在开发共同关注时,需要将关注和取关功能的功能改善一下 需要将用户id的key和关注的用户的id作为value 放到set 因为set可以进行查找供同拥有的value

@Override
        public Result followCommons(Long id) {
        
            //用户id
            Long userId=UserHolder.getUser().getId();
            //用户id key
            String key=RedisConstants.FOLLOW+userId;
            //查找另一个用户的id
            String key1=RedisConstants.FOLLOW+id;
            //进行value查重
            Set<String> intersect = stringRedisTemplate
            .opsForSet().intersect(key, key1);
            if(intersect==null||intersect.isEmpty()){
        
                return Result.ok(Collections.emptyList());
            }
            List<Long> ids= intersect.stream().map(Long::valueOf)
            .collect(Collectors.toList());
            List<UserDTO> collect = userService.listByIds(ids)
                    .stream()
                    .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
                    .collect(Collectors.toList());
            return Result.ok(collect);
        }

#### 1.4.3 订阅好友关注 ####

feed流

拉模式:大v都有自己的发件箱,当发消息的时候会发到自己的发件箱里面,等用户上线查看收件箱,会将用户关注的所有大v的发件箱复制一份放到用户的收件箱,重新按时间戳进行排序,供用户读取!弊端:如果这个人是个变态,关注着几千多个人,成千上万个数据会复制到收件箱,耗费内存

[![bOhXWTP3I1KLSk4.png][]][bOhXWTP3I1KLSk4.png 1]

推模式:大v在写消息时,会将关注自己的所有人的收件箱里面写一份,供粉丝阅读。缺点:如果大v有太多粉丝,也会造成太耗费内存

[![Pf36OXSlWZd2Qsz.png][]][Pf36OXSlWZd2Qsz.png 1]

拉推结合模式:对待僵尸粉采用拉模式,对待活跃粉丝采用推模式

[![MAIoNmepkz7fxwa.png][]][MAIoNmepkz7fxwa.png 1]

[![y6A5RdshHOKm3UY.png][]][y6A5RdshHOKm3UY.png 1]

本次实现使用的是推模式

//在发布笔记时,向各个用户的收件箱发送   运用的时有序zset集合
    @Override
        public Result saveBlog(Blog blog) {
        
            //获得登录用户/ 
            UserDTO user = UserHolder.getUser();
            blog.setUserId(user.getId());
            boolean success = save(blog);
            if(!success){
        
                return Result.fail("新增笔记失败");
            }
            //查询该用户的所有粉丝
             select * from tb_follow where follow_id ='user.getId()'
            List<Follow> follows = followService.query()
            .eq("follow_user_id", user.getId()).list();
            //
            long l = System.currentTimeMillis();
            for(Follow follow:follows){
        
                //对每个粉丝的收件箱进行推送
                String key=RedisConstants.FEED_KEY+follow.getUserId();
                stringRedisTemplate.opsForZSet().add(key,blog.getId().toString(),l);
            }
            return Result.ok(blog.getId());
        }

//滚动查询的意思是 当查询的时候   本来是10条数据 分页 一页两条数据 如果这时候插入一条新数据 索引变化 分页会重复查询 数据 这时候需要滚动查询 在查询第二页数据时 记录最后一个数据的score数据 并记录 这一页score 有几个 然后根据这个score数据查第三页 
    @Override
        public Result queryBlogOfFollow(Long max, Integer offset) {
        
            //获得当前用户id
            Long userId = UserHolder.getUser().getId();
            //查询收件箱 key max最大值 min最小值 limit offset偏移量 count 分页数量
            String key=RedisConstants.FEED_KEY+userId;
             //value 是blogId score 就是分数
            Set<ZSetOperations.TypedTuple<String>> typedTuples = 
                stringRedisTemplate.opsForZSet().
                reverseRangeByScoreWithScores(key, 0, max, offset, 2);
            //非空判断
            if(typedTuples==null||typedTuples.isEmpty()){
        
                return Result.ok();
            }
            //解析数据:blogId,minTime,offset
            ArrayList<Long> ids = new ArrayList<>(typedTuples.size());
            long minTime=0;
            int os=1;
            for(ZSetOperations.TypedTuple<String> tuple:typedTuples){
        
                ids.add(Long.valueOf(tuple.getValue()));
                long time =tuple.getScore().longValue();
                if(time==minTime){
        
                    os++;
                }else{
        
                    minTime=time;
                    os=1;
                }
            }
            String idStr=StrUtil.join(",",ids);
            List<Blog> blogs = query().in("id", ids)
            .last("ORDER BY FIELD(id," + idStr + ")").list();
            for(Blog blog:blogs){
        
                //查询blog有关的用户
                queryBlogUser(blog);
                //查询blog是否被点赞
                isBlogLiked(blog);
            }
            ScrollResult r=new ScrollResult();
            r.setList(blogs);
            r.setOffset(os);
            r.setMinTime(minTime);
            return Result.ok(r);
        }

### 1.5用户签到 ###

@Override
        public Result sign() {
        
            //获取当前用户
            Long userId = UserHolder.getUser().getId();
            //获取日期
            LocalDateTime now=LocalDateTime.now();
            String keySuffix=now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
            //拼接key
            String key=RedisConstants.USER_SIGN_KEY+userId+keySuffix;
            //获得今天是本月第几天
            int dayOfMonth = now.getDayOfMonth();
            //写入redis
            stringRedisTemplate.opsForValue().setBit(key,dayOfMonth-1,true);
            return Result.ok();
        }

#### 1.5.1 查询连续签到了几天 ####

@Override
        public Result signCount() {
        
            //获取当前用户
            Long userId = UserHolder.getUser().getId();
            //获取日期
            LocalDateTime now=LocalDateTime.now();
            String keySuffix=now.format(DateTimeFormatter.ofPattern(":yyyyMM"));
            //拼接key
            String key=RedisConstants.USER_SIGN_KEY+userId+keySuffix;
            //获得今天是本月第几天
            int dayOfMonth = now.getDayOfMonth();
            List<Long> result=stringRedisTemplate.opsForValue().bitField(key,
                    BitFieldSubCommands.create().get(BitFieldSubCommands.BitFieldType
                    .unsigned(dayOfMonth)).valueAt(0));
            if(result==null||result.isEmpty()){
        
                //没有任何签到结果
                return Result.ok(0);
            }
            Long num=result.get(0);
            if(num==null || num==0){
        
                return Result.ok(0);
            }
            //循环遍历
            int count=0;
            while(true){
        
                //让这个数字与1做与运算,得到数字的最后的一个bit
                if((num&1)==0){
        
                    //如果为0,说明未签到 ,结束
                    break;
                }else{
        
                    //如果不为0,说明已签到,计数器+1
                    count++;
                }
                //把数字右移一位,抛给最后的比特位,继续下一个bit位
                num>>>=1;
            }
            return Result.ok(count);
        }

## 总结 ##

jdk8的新特性学一下 spring再重新学一下

[ASJVzyEp5dtiYkT.png]: https://s2.loli.net/2022/10/16/ASJVzyEp5dtiYkT.png
[ASJVzyEp5dtiYkT.png 1]: https://smms.app/image/ASJVzyEp5dtiYkT
[g5tNILAb31D8CKU.png]: https://s2.loli.net/2022/10/16/g5tNILAb31D8CKU.png
[g5tNILAb31D8CKU.png 1]: https://smms.app/image/g5tNILAb31D8CKU
[qWbrX4YkKVOpdmI.png]: https://s2.loli.net/2022/10/17/qWbrX4YkKVOpdmI.png
[qWbrX4YkKVOpdmI.png 1]: https://smms.app/image/qWbrX4YkKVOpdmI
[ltwqpuSNb4dUCsB.png]: https://s2.loli.net/2022/10/17/ltwqpuSNb4dUCsB.png
[ltwqpuSNb4dUCsB.png 1]: https://smms.app/image/ltwqpuSNb4dUCsB
[7JXgkiZSmCKraYw.png]: https://s2.loli.net/2022/10/17/7JXgkiZSmCKraYw.png
[7JXgkiZSmCKraYw.png 1]: https://smms.app/image/7JXgkiZSmCKraYw
[xt6YGw5V4bDvuIf.png]: https://s2.loli.net/2022/10/17/xt6YGw5V4bDvuIf.png
[xt6YGw5V4bDvuIf.png 1]: https://smms.app/image/xt6YGw5V4bDvuIf
[FR7cEnvWJBiO2Hk.png]: https://s2.loli.net/2022/10/17/FR7cEnvWJBiO2Hk.png
[FR7cEnvWJBiO2Hk.png 1]: https://smms.app/image/FR7cEnvWJBiO2Hk
[eAr5oq4alTRVE17.png]: https://s2.loli.net/2022/10/18/eAr5oq4alTRVE17.png
[eAr5oq4alTRVE17.png 1]: https://smms.app/image/eAr5oq4alTRVE17
[2Dgr4Gsa8hw9dAx.png]: https://s2.loli.net/2022/10/19/2Dgr4Gsa8hw9dAx.png
[2Dgr4Gsa8hw9dAx.png 1]: https://smms.app/image/2Dgr4Gsa8hw9dAx
[AqjuYmVBZvaIo7Q.png]: https://s2.loli.net/2022/10/21/AqjuYmVBZvaIo7Q.png
[AqjuYmVBZvaIo7Q.png 1]: https://smms.app/image/AqjuYmVBZvaIo7Q
[lT61ayoetdprBhq.png]: https://s2.loli.net/2022/10/21/lT61ayoetdprBhq.png
[lT61ayoetdprBhq.png 1]: https://smms.app/image/lT61ayoetdprBhq
[ZR52zQKBG16XSUn.png]: https://s2.loli.net/2022/10/21/ZR52zQKBG16XSUn.png
[ZR52zQKBG16XSUn.png 1]: https://smms.app/image/ZR52zQKBG16XSUn
[aEAZ1NfRelcKwVg.png]: https://s2.loli.net/2022/10/21/aEAZ1NfRelcKwVg.png
[aEAZ1NfRelcKwVg.png 1]: https://smms.app/image/aEAZ1NfRelcKwVg
[jbwuCRfdAy9TYV4.png]: https://s2.loli.net/2022/10/21/jbwuCRfdAy9TYV4.png
[jbwuCRfdAy9TYV4.png 1]: https://smms.app/image/jbwuCRfdAy9TYV4
[bOhXWTP3I1KLSk4.png]: https://s2.loli.net/2022/10/23/bOhXWTP3I1KLSk4.png
[bOhXWTP3I1KLSk4.png 1]: https://smms.app/image/bOhXWTP3I1KLSk4
[Pf36OXSlWZd2Qsz.png]: https://s2.loli.net/2022/10/23/Pf36OXSlWZd2Qsz.png
[Pf36OXSlWZd2Qsz.png 1]: https://smms.app/image/Pf36OXSlWZd2Qsz
[MAIoNmepkz7fxwa.png]: https://s2.loli.net/2022/10/23/MAIoNmepkz7fxwa.png
[MAIoNmepkz7fxwa.png 1]: https://smms.app/image/MAIoNmepkz7fxwa
[y6A5RdshHOKm3UY.png]: https://s2.loli.net/2022/10/23/y6A5RdshHOKm3UY.png
[y6A5RdshHOKm3UY.png 1]: https://smms.app/image/y6A5RdshHOKm3UY