1. 内容概述

• 短信登录
  • 这部分会使用Redis共享session来实现
  • 用Redis替换session来存储邮箱验证码
• 商户查询缓存
  • 这部分要理解缓存击穿，缓存穿透，缓存雪崩等问题，对于这些概念的理解不仅仅是停留在概念上，更是能在代码中看到对应的内容
• 优惠券秒杀
  • 这部分可以学会Redis的计数器功能，完成高性能的Redis操作，同时学会Redis分布式锁的原理，包括Redis的三种消息队列
• 附近的商户
  • 利用Redis的GEOHash(新数据结构，前面没有应用场景就没介绍)来完成对于地理坐标的操作
• UV统计
  • 主要是使用Redis来完成统计功能
• 用户签到
  • 使用Redis的BitMap数据统计功能
• 好友关注
  • 基于Set集合的关注、取消关注，共同关注等等功能，这部分在上篇的练习题中出现过，这次我们在项目中来使用一下
• 达人探店
  • 基于List来完成点赞列表的操作，同时基于SortedSet来完成点赞的排行榜功能

2. 导入项目

• 在实现功能之前，我们先来导入项目，让项目跑起来
  • 导入SQL表

• 有关当前模型
  • 该项目采用的是前后端分离开发模式
  • 手机或者app端发起请求 请求我们的Nginx服务器 Nginx基于七层模型走的是HTTP协议 可以实现基于Lua直接绕开Tomcat访问Redis 也可以作为静态资源服务器 轻松抗下上万并发 负载均衡到下游Tomcat服务器 打散流量
  • 我们都知道一台4核8G的Tomcat在优化和处理简单业务的加持下 大不了就处理1000左右的并发 经过Nginx的负载均衡分馏后 利用集群支撑起整个项目 同时Nginx在部署了前端项目后 更是可以做到动静分离 进一步降低Tomcat服务器的压力 这些功能都靠Nginx起作用 所以Ngix是项目重要的一环
  • 在Tomcat支撑起并发流量后 我们如果让Tomcat直接去访问Mysql 根据经验Mysql企业级服务器只要上点并发 一般是16或32核心cpu 32或64G内存 向企业级mysql加上固态硬盘能够支撑的并发 大概就是4000~7000左右 上万并发 瞬间就会让Mysql服务器的cpu 硬盘全部打满 容易崩溃 所以我们在高并发场景下 会选择使用mysql集群 同时为了进一步降低Mysql的压力 同时增加访问的性能 我们也会加入Redis 同时使用Redis集群使得Redis对外提供更好的服务

• 导入后端项目

  • 黑马已经提供好了后端项目源码压缩包，我们将其解压之后，放到自己的workspace里
  • 然后修改MySQL和Reids的连接要素为自己的，随后启动项目
  • 访问http://localhost:8081/shop-type/list ，如果可以看到JSON数据，则说明导入成功

• 导入前端工程

• 黑马已经提供好了前端项目源码压缩包，我们将其解压之后，放到自己的workSpace里

• 然后在nginx所在目录打开一个cmd窗口，输入命令，即可启动项目
  start nginx.exe

• 访问http://localhost:8080/ ，打开开发者模式，可以看到页面

3. 短信登录

• Session的工作流程

  1 2 3 4 5 6 7 8 9 10 11 12

  // 第一次：存储数据 session.setAttribute("code", "123456"); // 实际上：服务器内部 Map<SessionID, Map<String, Object>> // 类似于：Map<"ABC123", {"code": "123456"}> // 第二次：获取数据 String code = (String) session.getAttribute("code"); // 实际上：通过Session ID "ABC123" 找到对应的Map，然后取"code"的值 // 验证成功，清除Session中的验证码 session.removeAttribute("code");

• 发送验证码
  用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号
  如果手机号合法，后台此时生成对应的验证码，同时将验证码进行保存，然后再通过短信的方式将验证码发送给用户

• 短信验证码登录、注册
  用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，方便后续获得当前登录信息

• 校验登录状态
  用户在请求的时候，会从cookie中携带JsessionId到后台，后台通过JsessionId从session中拿到用户信息，如果没有session信息，则进行拦截，如果有session信息，则将用户信息保存到threadLocal中，并放行

3.1 Session实现发送验证码功能

• 发送验证码
  用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号
  如果手机号合法，后台此时生成对应的验证码，同时将验证码进行保存，然后再通过短信的方式将验证码发送给用户

• 输入手机号 点击发送验证码按钮 查看发送的请求

  这里可以看到

  请求网址: http://localhost:8080/api/user/code?phone=15793458583
  请求方法: POST

• 看样子是调用了UserController中的code方法 携带参数是phone

  1 2 3 4 5 6 7 8 9

  /** * 发送手机验证码 */ @PostMapping("code") public Result sendCode(@RequestParam("phone") String phone, HttpSession session) { // TODO 发送短信验证码并保存验证码 return Result.fail("功能未完成"); }

• 先在IUserService接口中声明方法

  先在userServiceImpl实现类中实现方法

  最后在userController控制器中调用这个方法来完成发送验证码需求

• 在userServiceImpl实现类中写sendCode方法

  Result是自己定义的类 实现的是返回的信息是否成功

  RegexUtils类和RegexPatterns类中已经封装好了手机号正则表达式工具

  如果手机号符合正则表达式 则使用RandomUtil类中的随机生成数组方法来生成乱序验证码

  有了验证码之后使用setAttribute方法来将验证码保存到session

  这里简化 使用SLF4J直接向命令台发送验证码 之后项目上线了再使用发送验证码的形式

  最后使sendCode方法向前端返回OK

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

  @Service @Slf4j publicclassUserServiceImplextendsServiceImpl<UserMapper, User>implementsIUserService{ @Override //这里的Result是自己定义的类publicResult sendCode(String phone,HttpSessionsession) { //1. 校验手机号//这里黑马已经写好了手机号正则表达式工具//RegexPatterns RegexUtilsif(RegexUtils.isPhoneInvalid(phone)){ //2. 如果不符合 返回错误信息returnResult.fail("手机号格式错误"); } //3. 符合 生成验证码//这里直接用RandomUtil里的随机生成数字方法String code = RandomUtil.randomNumbers(6); //4. 将验证码保存到session//使用setAttribute方法来将验证码保存到sessionsession.setAttribute("code",code); //5. 发送验证码//这里是模拟 实际上线需要替换log.debug("发送短信验证码成功，验证码：{}",code); //返回OKreturnResult.ok(); } }

  1 2 3 4 5 6

  publicinterfaceIUserServiceextendsIService<User> { Result sendCode(String phone,HttpSessionsession); }

  1 2 3 4 5 6

  @PostMapping("code") publicResult sendCode(@RequestParam("phone") String phone,HttpSessionsession)throwsMessagingException { // TODO 发送短信验证码并保存验证码//return Result.fail("功能未完成");returnuserService.sendCode(phone,session); }

  由此可知 实现项目功能的正确顺序为

  在 Service 接口中声明方法 → 在 Service 实现类中实现方法在 → Controller 中调用

3.2 Session实现验证码登录功能

• 短信验证码登录、注册
  用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，方便后续获得当前登录信息
• 输入手机号和验证码 点击登录的按钮 查看发送的请求

可以看到请求的URL是user/login 并且请求参数是JSON形式

由此推断出调用了userController的login方法

• 由图 前端提交的是json形式 所以需要使用@RequestBody
  • @RequestBody是Sping MVC中的注解 作用是将HTTP请求的 JSON/XML正文转换为Java对象
• 如下是LoginFromDTO的代码 由此可知将JSON文件转换成立phone code password

1
2
3
4
5
6
7

@Data
publicclassLoginFormDTO {
privateString phone;
privateString code;
privateString password;  //可以密码登录
}

• 接下来依旧在 Service 接口中声明方法 → 在 Service 实现类中实现方法在 → Controller 中调用

  • 在Service接口中声明 需要的参数为 从JSON转化为Java代码的登录信息 还有Session

    1 2 3 4 5 6 7

    publicinterfaceIUserServiceextendsIService<User> { Result sendCode(String phone,HttpSessionsession); Result login(LoginFormDTO loginForm,HttpSessionsession); }

  • 在 Service 实现类中实现方法 首先先将思路写出 如图

    对数据库增删改查用的是MyBatisPlus 可以能简单的实现CRUD

    本类中继承了ServiceImpl类 这个类是MyBatisPlus提供的 可以实现对单表的CRUD

    query()就相当于SQL中的select * from tb_user where

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

    @Override publicResult login(LoginFormDTO loginForm,HttpSessionsession) { //1. 校验手机号String phone = loginForm.getPhone(); if(RegexUtils.isPhoneInvalid(phone)){ returnResult.fail("手机号格式错误"); } //2. 校验验证码// 从session中取出验证码Object cacheCode = session.getAttribute("code"); String code = loginForm.getCode(); //3. 不一致 直接报错if(cacheCode ==null){ returnResult.fail("验证码已过期"); } //这里要使用toString方法把cacheCode变成字符串 要不然可能出现空指针 elseif(!code.equals(cacheCode.toString())){ returnResult.fail("验证码错误"); } session.removeAttribute("code"); //4. 如果一致 根据手机号查询用户//使用的是mybatisplus 所以很简单就可以实现查询//本类中继承了ServiceImpl父类 这个类是mybatisplus提供的//这个类可以实现对于单表的增删改查//使用方法是表明实体类和Mapper是什么//query()就等同于SQL里的 select * from tb_user whereUser user = query().eq("phone", phone).one(); //5. 判断用户是否存在if(user ==null){ //6. 不存在 创建新用户 保存用户到数据库user = createUserWithPhone(phone); } //7. 存在//8. 保存用户到sessionsession.setAttribute("user",user); //session的原理是cookie 所以不需要返回登陆凭证returnResult.ok(); } privateUser createUserWithPhone(String phone) { //创建新的用户User user =newUser(); user.setPhone(phone); user.setNickName(USER_NICK_NAME_PREFIX+ RandomUtil.randomString(7)); //使用mybatisplus保存用户到数据库save(user); returnuser; }

• 最后在Controller层调用login方法

  1 2 3 4 5

  @PostMapping("/login") publicResult login(@RequestBody LoginFormDTO loginForm,HttpSessionsession){ // 实现登录功能returnuserService.login(loginForm,session); }

这里黑马写出了一个漏洞:

如果我用手机号A申请了验证码 然后将手机号A修改成手机号B 再用验证码还可以登录

解决方案：

首先在发送验证码功能里使用Session里的setAttribute来获取申请验证码的手机号

然后在登录功能里通过校验Session里的手机号和前端发送的手机号进行比对 来避免这个漏洞

3.3 Session实现登录校验拦截功能

• 用拦截器对用户信息进行校验

  • 拦截器概念

  在学习拦截器的概念之前，我们先看一张图
  

  

  • 浏览器发送一个请求，会先到Tomcat服务器的web服务器
  • Tomcat服务器接收到请求后，会先去判断请求的是静态资源还是动态资源
  • 如果是静态资源，会直接到Tomcat的项目部署目录下直接访问
  • 如果是动态资源，就需要交给项目的后台代码进行处理
  • 在找到具体的方法之前，我们可以去配置过滤器（可以配置多个），按照顺序进行执行（在这里就可以进行权限校验）
  • 然后进入到中央处理器（SpringMVC中的内容），SpringMVC会根据配置的规则进行拦截
  • 如果满足规则，则进行处理，找到其对应的Controller类中的方法进行执行，完成后返回结果
  • 如果不满足规则，则不进行处理
  • 这个时候，如果我们需要在每个Controller方法执行的前后添加业务，具体该如何来实现？
    1. 这个就是拦截器要做的事
  • 拦截器（Interceptor）是一种动态拦截方法调用的机制，在SpringMVC中动态拦截控制器方法的执行
    • 作用：
      • 在指定的方法调用前后执行预先设定的代码
      • 阻止原始方法的执行
    • 总结：拦截器就是用来作增强
  • 但是这个拦截器貌似跟我们之前学的过滤器很像啊，不管是从作用上来看还是从执行顺序上来看
    • 那么拦截器和过滤器之间的区别是什么呢？
      • 归属不同：Filter属于Servlet技术，而Interceptor属于SpringMVC技术
      • 拦截内容不同：Filter对所有访问进行增强，Interceptor仅对SpringMVC的访问进行增强
  • 过滤器和拦截器的区别补充
    • 执行顺序：Filter > Interceptor > Controller
    • 依赖关系：Filter不依赖Spring，Interceptor是Spring框架的一部分
    • 使用场景：Filter适合做全局处理（编码、安全），Interceptor适合做业务相关处理（权限、日志）

• 先写出拦截器功能

  创建一个LoginInterceptor类 完成HandlerInterceptor接口 重写其中的两个方法 前置拦截器和完成处理方法 前置拦截器主要用于我们登录之前的权限校验 完成处理方法是用于处理登录后的信息 避免内存泄漏

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

  public class LoginInterceptor implements HandlerInterceptor { //这里按ctrl+i就可以自动构建这两个方法 @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { //1. 获取session HttpSession session = request.getSession(); //2. 获取session中的用户信息 User user = (User) session.getAttribute("user"); //3. 判断用户是否存在 if (user == null) { //4. 不存在，则拦截 response.setStatus(401); return false; } //5. 存在，保存用户信息到ThreadLocal，UserHolder是提供好了的工具类 UserHolder.saveUser(user); //6. 放行 return true; } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { UserHolder.removeUser(); } }

  • 这里将user保存到ThreadLocal 使用UserHolder里的方法

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

    public class UserHolder { private static final ThreadLocal<User> tl = new ThreadLocal<>(); public static void saveUser(User user){ tl.set(user); } public static User getUser(){ return tl.get(); } public static void removeUser(){ tl.remove(); } }

  • 再将拦截器配置到MVC当中

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

    @Configuration public class MvcConfig implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(new LoginInterceptor()) .excludePathPatterns( "/user/code", "/user/login", "/blog/hot", "/shop/**", "/shop-type/**", "/upload/**", "/voucher/**" ); } }

  • 最后写一下me方法

    1 2 3 4 5 6 7

    @GetMapping("/me") public Result me() { //这里通过UserHolder的getUser方法将user从ThreadLocal中拉出来 User user = UserHolder.getUser(); return Result.ok(user); }

• 隐藏用户敏感信息

我们登录的的时候 前端的请求报文会显示用户在整个数据库中的信息

这样会泄露用户的敏感信息 所以我们应当在返回用户信息前 将用户的敏感信息进行隐藏 采用的核心思路是书写一个UserDto对象 这个UserDto对象就没有敏感信息了 在返回前 将有用户敏感信息的User对象转化为没有敏感信息的UserDto对象 就可以避免这个问题

• DTO是什么

  • DTO(Data Transfer Object) 即数据传输对象 是一种设计模式 用于在不同层或不同系统之间传输数据

  DTO 的核心价值：

  • 🛡️ 安全性 - 隐藏敏感字段
  • 🎯 针对性 - 不同场景使用不同DTO
  • 🔧 灵活性 - 数据格式可定制
  • 📦 解耦合 - 各层数据独立，避免相互影响

• UserDto类如下 将User对象中的属性拷贝给UserDto 就可以避免暴露用户的信息

  • lombok是一个Java库 通过注释自动生成代码 不需要开发射手动编写getter setter equals hashCode 构造函数等样板代码

    @Data 是Lombok中一个常用的注解

    作用是所有字段的getter/setter + equals + hashCode + toString

  1 2 3 4 5 6 7 8

  importlombok.Data; @Data publicclassUserDTO { privateLong id; privateString nickName; privateString icon; }

• 修改UserHolder 将其User类型全都改为UserDto类型

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

  publicclassUserHolder { privatestatic finalThreadLocal<UserDTO>tl=newThreadLocal<>(); publicstaticvoidsaveUser(UserDTO user){ tl.set(user); } publicstaticUserDTO getUser(){ returntl.get(); } publicstaticvoidremoveUser(){ tl.remove(); } }

  这里黑马有多处调用了UserHolder类中的getUser方法 他们的类型都是User 突然改用 UserDto会报错所以需要多次修改 一个一个看太麻烦了

  对着getUser方法按左键 点查找方法就能看见所有调用这个方法的地方 然后依次修改就行

• 修改login方法

  1 2 3 4 5 6

  //7. 保存用户信息到session中 - session.setAttribute("user", user); + UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class); + session.setAttribute("user", userDTO); return Result.ok();

  BeamUtil是hutool库里的一个类 里面有一个copyProperties（复制属性）方法 可以自动将属性拷贝成另外一个类型 并且自动创建对象

• 修改拦截器

  1 2 3 4

  //1. 获取sessionHttpSessionsession = request.getSession(); //2. 获取session中的用户信息UserDTO user = (UserDTO) session.getAttribute("user"); //3. 判断用户是否存在

• 修改Controller层的me方法

  1 2 3 4 5 6

  @GetMapping("/me") publicResult me() { // TODO 获取当前登录的用户并返回UserDTO user = UserHolder.getUser(); returnResult.ok(user); }

• 总结

• 将数据库中的User转换成了UserDTO类型 —>

  • 将UserDTO存储在服务器的Session中 —>
  • Session为参数自动生成了JSESSIONID —>
  • 通过Set-Cookie头告诉浏览器保存JSESSIONID —>
  • 服务器使用JESSIONID找到对应的数据(拦截器在这个过程进行校验) —>
  • 往客户端页面里显示User数据

  暂时无法在飞书文档外展示此内容

3.4 Session共享问题

• 每个tomcat中都有一份属于自己的session 假设用户第一次访问第一台tomcat 并且把自己的信息存放到第一台服务器的session中

  但是第二次这个用户访问了第二台tomcat 那么在第二台机器上 肯定没有第一台服务器存放的session 所以此时整个登录拦截功能就会出现问题

  • 我们能如果解决这个问题呢？

    早期的方案是session拷贝 就是说虽然每个tomcat上都会有不同的个session 但是每当任意一台服务器的session修改时 都会同步给其他的tomcat服务器的session 这样就可以实现session的共享

  • 但session共享有两个大问题

    • 每台服务器都有一份完整的session数据 服务器压力过大
    • session拷贝数据时 可能会出现延迟

所以后面都是基于Redis来完成 我们把session换成Redis Redis数据本身就是共享的 就可以避免session共享的问题了

3.5 Redis代替session的业务流程

• 设计key结构
  • 首先要知道用什么数据结构来存储数据
  • 由于存入的数据比较简单 我们可以使用String或者Hash
    • 如果使用String 以JSON字符串来保存数据 会额外占用部分空间
    • 如果使用Hash 则它的value中只会存储数据本身
  • 如果不在意内存 直接使用String就好
• 设计key的细节

  • 这里就采用K-V键值对方式

  • 但是对于key的处理 不能像session一样用phone或code来当key

    因为Redis的key是共享的 code可能会重复 phone这种敏感字段也不适合存储到Redis中

  • 在设计key的时候 我们需要满足两点

    • key要有唯一性
    • key要方便携带

所以我们在后台随机生成一个token 然后让前端带着这个token就能完成我们的业务逻辑

• 整体访问流程
  • 当注册完成后 用户去登录 然后校验用户提交的手机号/邮箱和验证码是否一致
    • 如果一致 则根据手机号查询用户信息 不存在则新建 最后将用户数据保存到Redis 并生成一个token作为Redis的key
  • 当我们校验用户是否登录时 回去携带着token进行访问 从Redis中获取token对应的value 判断是否存在这个数据
    • 如果不存在 则拦截
    • 如果存在 则将其用户信息(userDto)保存到ThreadLocal 并放行

3.6 基于Redis实现短信登录

1. 在UserServiceImpl中注入StringRedisTemplate

   1 2 3

   @Resource privateStringRedisTemplate stringRedisTemplate;

2. 修改sendCode方法

   1. 这里的key使用login:code:手机号 防止与其他业务的key冲突
   2. 验证码需要有效期 防止冗余数据堆叠在Redis中
   3. key需要加上业务名称 避免与其他业务的key冲突 例如login:code:phone
   4. 这些可以定义成常量类 让代码更专业

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   publicclassRedisConstants { publicstaticfinalStringLOGIN_CODE_KEY= "login:code:"; publicstaticfinalLongLOGIN_CODE_TTL= 2L; publicstaticfinalStringLOGIN_USER_KEY= "login:token:"; publicstaticfinalLongLOGIN_USER_TTL= 36000L; publicstaticfinalLongCACHE_NULL_TTL= 2L; publicstaticfinalLongCACHE_SHOP_TTL= 30L; publicstaticfinalStringCACHE_SHOP_KEY= "cache:shop:"; publicstaticfinalStringLOCK_SHOP_KEY= "lock:shop:"; publicstaticfinalLongLOCK_SHOP_TTL= 10L; publicstaticfinalStringSECKILL_STOCK_KEY= "seckill:stock:"; publicstaticfinalStringBLOG_LIKED_KEY= "blog:liked:"; publicstaticfinalStringFEED_KEY= "feed:"; publicstaticfinalStringSHOP_GEO_KEY= "shop:geo:"; publicstaticfinalStringUSER_SIGN_KEY= "sign:"; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   //实现发送验证码功能 @Override //这里的Result是自己定义的类 public Result sendCode(String phone, HttpSession session) { //1. 校验手机号 //这里黑马已经写好了手机号正则表达式工具 //RegexPatterns RegexUtils if(RegexUtils.isPhoneInvalid(phone)){ //2. 如果不符合 返回错误信息 return Result.fail("手机号格式错误"); } //3. 符合 生成验证码 //这里直接用RandomUtil里的随机生成数字方法 String code = RandomUtil.randomNumbers(6); - //4. 将验证码保存到session - //使用setAttribute方法来将验证码保存到session - session.setAttribute("code",code); - session.setAttribute("phone",phone); + //4. 将验证码保存到Redis + //这里的key使用login:code:手机号 防止与其他业务的key冲突 + //key需要有效期 设置成两分钟 2和login:code最好定义个常量类 看起来更专业 + stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone,code,LOGIN_CODE_TTL,TimeUnit.MINUTES); //5. 发送验证码 //这里是模拟 实际上线需要替换 log.debug("发送短信验证码成功，验证码：{}",code); //返回OK return Result.ok(); }

3. 修改login方法

   1. 使用redis获取验证码就不需要校验phone是否前后一致了
   2. 存储用户信息到redis需要生成token作为key 这里使用UUID
   3. 因为需要将用户信息以HashMap的形式存入reidis 所以这里需要使用BeanUtil将UserDTO转化为UserMap
   4. 用户信息一直存到redis会造成redis臃肿 所以也需要给登录信息设置有效期 使用exprie方法
   5. 用户登录后将code删除

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161

   @Override public Result login(LoginFormDTO loginForm, HttpSession session) { //1. 校验手机号 String phone = loginForm.getPhone(); if(RegexUtils.isPhoneInvalid(phone)){ return Result.fail("手机号格式错误"); } - //2. 校验验证码 - // 从session中取出验证码 - Object cacheCode = session.getAttribute("code"); - String code = loginForm.getCode(); + //2. 校验验证码 + // 从Redis获取验证码并校验 + //注意这 opsForValue().get(LOGIN_CODE_KEY + phone); phone是发送验证码之后的phone 所以不需要二次验证 + //如果phone前后不一致 cacheCode就不能获取数据 就是null + String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone); + String code = loginForm.getCode(); //3. 不一致 直接报错 if(cacheCode == null){ return Result.fail("验证码已过期"); } - //这里要使用toString方法把cacheCode变成字符串 要不然可能出现空指针 + //这里cacheCode已经是String类型 else if(!code.equals(cacheCode)){ return Result.fail("验证码错误"); } - session.removeAttribute("code"); //实现发送验证码功能 @Override //这里的Result是自己定义的类 public Result sendCode(String phone, HttpSession session) { //1. 校验手机号 //这里黑马已经写好了手机号正则表达式工具 //RegexPatterns RegexUtils if(RegexUtils.isPhoneInvalid(phone)){ //2. 如果不符合 返回错误信息 return Result.fail("手机号格式错误"); } //3. 符合 生成验证码 //这里直接用RandomUtil里的随机生成数字方法 String code = RandomUtil.randomNumbers(6); - //4. 将验证码保存到session - //使用setAttribute方法来将验证码保存到session - session.setAttribute("code",code); - session.setAttribute("phone",phone); + //4. 将验证码保存到Redis + //这里的key使用login:code:手机号 防止与其他业务的key冲突 + //key需要有效期 设置成两分钟 2和login:code最好定义个常量类 看起来更专业 + stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone,code,LOGIN_CODE_TTL,TimeUnit.MINUTES); //5. 发送验证码 //这里是模拟 实际上线需要替换 log.debug("发送短信验证码成功，验证码：{}",code); //返回OK return Result.ok(); } 修改login方法 使用redis获取验证码就不需要校验phone是否前后一致了 存储用户信息到redis需要生成token作为key 这里使用UUID 因为需要将用户信息以HashMap的形式存入reidis 所以这里需要使用BeanUtil将UserDTO转化为UserMap 用户信息一直存到redis会造成redis臃肿 所以也需要给登录信息设置有效期 使用exprie方法 @Override public Result login(LoginFormDTO loginForm, HttpSession session) { //1. 校验手机号 String phone = loginForm.getPhone(); if(RegexUtils.isPhoneInvalid(phone)){ return Result.fail("手机号格式错误"); } - //2. 校验验证码 - // 从session中取出验证码 - Object cacheCode = session.getAttribute("code"); - String code = loginForm.getCode(); + //2. 校验验证码 + // 从Redis获取验证码并校验 + //注意这 opsForValue().get(LOGIN_CODE_KEY + phone); phone是发送验证码之后的phone 所以不需要二次验证 + //如果phone前后不一致 cacheCode就不能获取数据 就是null + String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone); + String code = loginForm.getCode(); //3. 不一致 直接报错 if(cacheCode == null){ return Result.fail("验证码已过期"); } //这里要使用toString方法把cacheCode变成字符串 要不然可能出现空指针 else if(!code.equals(cacheCode.toString())){ return Result.fail("验证码错误"); } - session.removeAttribute("code"); //4. 如果一致 + //可以将redis中的code删除了 + stringRedisTemplate.delete(LOGIN_CODE_KEY + phone); 根据手机号查询用户 //使用的是mybatisplus 所以很简单就可以实现查询 //本类中继承了ServiceImpl父类 这个类是mybatisplus提供的 //这个类可以实现对于单表的增删改查 //使用方法是表明实体类和Mapper是什么 //query()就等同于SQL里的 select * from tb_user where User user = query().eq("phone", phone).one(); //5. 判断用户是否存在 if(user == null){ //6. 不存在 创建新用户 保存用户到数据库 user = createUserWithPhone(phone); } - //7. 存在 - //8. 保存用户到session - session.setAttribute("user",user); - //session的原理是cookie 所以不需要返回登陆凭证 + //7. 保存用户信息到redis中 + //7.1 随机生成token 作为登录令牌 使用UUID作为token + String token = UUID.randomUUID().toString(); + //7.2 将user对象转化为Hash存储 + //将user改为userDTO 再将userDTO转化为userMap 都可以用BeanUtil方法 + UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class); // 添加空值检查，避免存储null字符串 if (userDTO.getIcon() != null) { userMap.put("icon", userDTO.getIcon()); } userMap.put("id", String.valueOf(userDTO.getId())); if (userDTO.getNickName() != null) { userMap.put("nickName", userDTO.getNickName()); } + //7.3 存储 + stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, userMap); + //用户信息一直存到redis会造成redis臃肿 所以也需要给登录信息设置有效期 + //在存储的时候不能直接设置有效期 需要使用 expire方法 + stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.MINUTES); // 8. 将token返回给客户端 - return Result.ok(); + return Result.ok(token); } private User createUserWithPhone(String phone) { //创建新的用户 User user = new User(); user.setPhone(phone); user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(7)); //使用mybatisplus保存用户到数据库 save(user); return user; } private User createUserWithPhone(String phone) { //创建新的用户 User user = new User(); user.setPhone(phone); user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(7)); //使用mybatisplus保存用户到数据库 save(user); return user; }

   1. 这里有一个问题 redis里的用户信息并不会随着用户的重新登录而刷新用户信息的有效期

      而session就没有这个问题

      我们需要在用户重新登录的时候刷新有效期 这里就需要在拦截器里修改

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   public class LoginInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { //1. 获取session HttpSession session = request.getSession(); //2. 获取session中的用户信息 UserDTO user = (UserDTO) session.getAttribute("user"); //3. 判断用户是否存在 if (user == null) { //4. 不存在，则拦截 response.setStatus(401); return false; } //5. 存在，保存用户信息到ThreadLocal，UserHolder是提供好了的工具类 UserHolder.saveUser(user); //6. 放行 return true; } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { UserHolder.removeUser(); } }

1
2

@Component  //加上注解

1
2
3
4
5
6
7
8
9
10
11

//这个类加了@Configuration  说明这个类由Spring构建  所以可以用@Resource注解
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private LoginInterceptor loginInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //手动new的话  stringRedisTemplate还是null
        registry.addInterceptor(new LoginInterceptor())
        registry.addInterceptor(loginInterceptor)

• 拦截的问题： 拦截器只会拦截指定的路径 不是拦截一切

如果一直访问的是没有被拦截的页面 token就不会被刷新 也就没有刷新有效期

新建一个RefreshTokenInterceptor拦截器 将之前LoginInterceptor拦截器的代码复制过去

并且删除拦截功能 直接放行 但是如果检测到用户存在就把他放到ThreadLocal当中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

//对象是手动new出来的 不受Spring管理  没有@Component注解  所以不能使用@Resource来注入StringRedisTemplate
@Slf4j
@Component
public class RefreshTokenInterceptor implements HandlerInterceptor {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1. 从request获取请求头中的token
        //前端代码中看到请求头叫authorization
        String token = request.getHeader("authorization");

        //使用StrUtil来判断token是否为空
        //如果为空 交给LoginInterceptor处理
        if (StrUtil.isBlank(token)) {
            return true;
        }

        //2. 利用token从redis中获取用户信息
        //使用entries获取的是HashMap
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);

        //3. 判断用户是否存在
        if (userMap.isEmpty()) {
            //4. 不存在，交给LoginInterceptor处理
            return true;
        }

        //5. 将查询到的Hash数据转为userDTO对象  这样才能存到ThreadLocal当中
        // 这里使用BeanUtil的fillBeanWithMap方法  第三个参数是是否忽略错误  填false
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        UserHolder.saveUser(userDTO);

        //6. 刷新token的有效期
        stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.MINUTES);

        //7. 放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();
    }
}

修改LoginInterceptor拦截器 只留拦截功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//对象是手动new出来的 不受Spring管理  没有@Component注解  所以不能使用@Resource来注入StringRedisTemplate
@Slf4j
@Component
publicclassLoginInterceptorimplementsHandlerInterceptor{

    @Resource
privateStringRedisTemplate stringRedisTemplate;

    @Override
publicbooleanpreHandle(HttpServletRequestrequest,HttpServletResponseresponse, Object handler)throwsException {

//判断是否需要拦截（ThreadLocal中是否有用户）if(UserHolder.getUser() ==null){
            response.setStatus(401);
returnfalse;
        }
returntrue;
    }

    @Override
publicvoidafterCompletion(HttpServletRequestrequest,HttpServletResponseresponse, Object handler, Exception ex)throwsException {
        UserHolder.removeUser();
    }

}

修改拦截器配置文件 添加refreshTokenInterceptor拦截器

并使用order来将拦截器排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//这个类加了@Configuration  说明这个类由Spring构建  所以可以用@Resource注解
@Configuration
publicclassMvcConfigimplementsWebMvcConfigurer{

    @Resource
privateLoginInterceptor loginInterceptor;
    @Resource
privateRefreshTokenInterceptor refreshTokenInterceptor;
    @Override
publicvoidaddInterceptors(InterceptorRegistry registry) {
//第一个拦截器  拦截所有请求  有用户数据刷新token有效期  没有用户数据不刷新直接放行//使用order来规定拦截器顺序registry.addInterceptor(refreshTokenInterceptor).order(0);

//第二个拦截器  除了以下路径如果没登录直接拦截registry.addInterceptor(loginInterceptor).order(1)
                .excludePathPatterns(
                        "/user/code",
                        "/user/login",
                        "/blog/hot",
                        "/shop/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/voucher/**"
                );

    }
}

3.7 黑马没讲知识的补充

• 登出功能
  很容易实现
  只需要在Controller层调用UserHolder类的removeUser方法来将用户信息从ThreadLocal去除就行

  • UserController的代码

  1 2 3 4 5

  @PostMapping("/logout") public Result logout(){ UserHolder.removeUser(); return Result.ok(); }

4. 商品查询缓存

4.1 什么是缓存？

• 缓存(Cache)就是数据交换的缓冲区，是存储数据的临时地方，一般读写性能较高。

• 在各个层面都有缓存 如图:
  

  

• 缓存的作用:

  • 降低后端的负载。
  • 提高读写效率，降低响应时间。

• 缓存的成本:

  • 需要保持数据一致性成本。
  • 代码维护成本。
  • 运维成本。

4.2 添加Redis缓存

• 没有添加Redis缓存的时候
  • 客户端直接向数据库发送请求 数据库直接将数据返回给客户端
• 添加了Redis缓存
  • 客户端优先向Redis发送请求 如果Redis中恰好有需要的数据 则直接返回给客户端
  • 如果没有 则向数据库发送请求 数据向Redis发送数据使其缓存 同时返回给客户端 这样下次相同请求可以直接由Redis完成

• 没有使用缓存
• 使用redis缓存

• 根据id查询商铺缓存的流程
  

  

1
2
3
4
5
6

@GetMapping("/{id}")
public Result queryShopById(@PathVariable("id") Long id) {
    //getById是IService接口里的方法  是MyBatisPlus提供的接口
    //所以这里直接向前端返回数据库里的数据
    return shopService.queryById(id);
}

1
2
3
4

 public interface IShopService extends IService<Shop> {

    Result queryById(Long id);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate  stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        //1. 从Redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2. 判断缓存是否命中
                //3. 如果命中 也就是数据在Redis中存在
        if (StrUtil.isNotBlank(shopJson)) {
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //4. 如果Redis中不存在数据  则在MySQL中查询
        Shop shop = getById(id);
        //5. 如果在MySQL中也没查到  返回404
        if (shop == null) {
            return Result.fail("店铺不存在!");
        }
        //6. 如果在MySQL中查到了 存入Redis 使用String存的是JSON类型
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop));
        //7. 返回商铺信息
        return Result.ok(shop);
    }
}

1
2
3
4
5
6
7
8
9
10

@RequestMapping("/shop-type")
public class ShopTypeController {
    @Resource
    private IShopTypeService typeService;
    @GetMapping("list")
    public Result queryTypeList() {
        return typeService.queryShopTypeByList();
    }
}

1
2
3
4
5

public interface IShopTypeService extends IService<ShopType> {

    Result queryShopTypeByList();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

@Service
public class ShopTypeServiceImpl extends ServiceImpl<ShopTypeMapper, ShopType> implements IShopTypeService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;


    @Override
    public Result queryShopTypeByList() {
        //1. 从Redis中查询商铺类型
        String shopTypeListJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_TYPE_KEY);

        //2. 判断缓存是否命中
        //3 如果命中 也就是数据在Redis中存在
        if(StrUtil.isNotBlank(shopTypeListJson)){
            //将JSON数据转化为List<ShopType>集合
            List<ShopType> shopTypeList = JSONUtil.toList(shopTypeListJson, ShopType.class);
            return Result.ok(shopTypeList);
        }
        //4. 如果Redis中不存在数据  则在MySQL中查询
            //这里的sort是tb_shop_type中的排序列
            //所以这段代码使用MyBatisPlus中的query方法按照sort列的顺序赋值给shopTypeList
        List<ShopType> shopTypeList = query().orderByAsc("sort").list();
        //5. 如果在MySQL中也没查到  返回404
        if(shopTypeList == null){
            return Result.fail("商铺列表不存在！");
        }
        //6. 如果在MySQL中查到了  将其存入Redis  使用String类型存入Redis
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_TYPE_KEY,JSONUtil.toJsonStr(shopTypeList));
        //7. 返回商铺列表信息
        return Result.ok(shopTypeList);
    }

}

4.3 缓存更新策略

• 缓存更新是Redis为了节约内存而设计出来的一个东西，主要是因为内存数据宝贵，当我们向Redis插入太多数据，此时就可能会导致缓存中数据过多，所以Redis会对部分数据进行更新，或者把淘汰更合适。🤔

1. 内存淘汰：Redis自动进行，当Redis内存达到我们设定的max-memory时，会自动触发淘汰机制，淘汰掉一些不重要的数据(可以我们自己设置策略方式)。
2. 超时剔除：当我们给Redis设置了过期时间TTL之后，Redis会将超时的数据进行删除，方便我们继续使用缓存。
3. 主动更新：我们可以手动调用方法把缓存删除掉，通常用于解决缓存和数据库不一致问题。

• 业务场景
  • 低一致性需求：使用内存淘汰机制，例如店铺类型的查询缓存（因为这个很长一段时间都不需要更新）
  • 高一致性需求：主动更新，并以超时剔除作为兜底方案，例如店铺详情查询的缓存

数据库和缓存不一致解决方案：

• 由于我们的缓存数据源来自数据库，而数据库的数据是会发生变化的，因此，如果当数据库中数据发生变化，而缓存却没有同步，此时就会有一致性问题存在，其后果是用户使用缓存中的过时数据，就会产生类似多线程数据安全问题，从而影响业务，产品口碑等。

  • 那么如何解决这个问题呢？有如下三种方式：

    • Cache Aside Pattern 人工编码方式：缓存调用者在更新完数据库之后再去更新缓存，也称之为双写方案。

    • Read/Write Through Pattern：缓存与数据库整合为一个服务，由服务来维护一致性。调用者调用该服务，无需关心缓存一致性问题。但是维护这样一个服务很复杂，市面上也不容易找到这样的一个现成的服务，开发成本高。

    • Write Behind Caching Pattern：调用者只操作缓存，其他线程去异步处理数据库，最终实现一致性。但是维护这样的一个异步的任务很复杂，需要实时监控缓存中的数据更新，其他线程去异步更新数据库也可能不太及时，而且缓存服务器如果宕机，那么缓存的数据也就丢失了。

在企业的实际应用中，还是方案一最可靠。

• 操作缓存和数据库时有三个问题需要考虑：

  • 删除缓存还是更新缓存?

    • 更新缓存：每次更新数据库都需要更新缓存，无效写操作较多。
    • 删除缓存：更新数据库时让缓存失效，再次查询时更新缓存。(写的频率会降低，有效更新会更高)

  • 如何保证缓存和数据库操作同时成功或失败？(保证原子性)

    • 单体系统：将缓存与数据库操作放在同一个事务。
    • 分布式系统：利用TCC等分布式事务方案。

  • 先操作缓存还是先操作数据库 ？(保证线程安全)

• 先删除缓存，再操作数据库
• 先操作数据库，再删除缓存

删除缓存的操作很快，但是更新数据库的操作相对较慢，如果此时有一个线程2刚好进来查询缓存，由于我们刚刚才删除缓存，所以线程2需要查询数据库，并写入缓存，但是我们更新数据库的操作还未完成，所以线程2查询到的数据是脏数据，数据库和缓存中的值不一样，出现线程安全问题。

线程1在查询缓存的时候，缓存TTL刚好失效，需要查询数据库并写入缓存，这个操作耗时相对较短（相比较于上图来说），但是就在这么短的时间内，线程2进来了，更新数据库，删除缓存，但是线程1虽然查询完了数据（更新前的旧数据），但是还没来得及写入缓存，所以线程2的更新数据库与删除缓存，并没有影响到线程1的查询旧数据，写入缓存，数据库和缓存中的值不一样，造成线程安全问题。

红色文字

4.4 实现商铺缓存双写一致

• 修改ShopServiceImpl的queryById方法，写入缓存时设置一下TTL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {

    @Resource
    StringRedisTemplate  stringRedisTemplate;

    @Override
    public Result queryById(Long id) {
        //1. 从Redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2. 判断缓存是否命中
                //3 如果命中 也就是数据在Redis中存在
        if (StrUtil.isNotBlank(shopJson)) {
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
            return Result.ok(shop);
        }
        //3. 如果Redis中不存在数据  则在MySQL中查询
        Shop shop = getById(id);
        //4. 如果在MySQL中也没查到  返回404
        if (shop == null) {
            return Result.fail("店铺不存在!");
        }
        //5. 如果在MySQL中查到了 存入Redis 使用String存的是JSON类型
        - stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop));
        

        + /*写入缓存设置TTL*/
        + stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);


        //6. 返回商铺信息
        return Result.ok(shop);
    }
}

1
2
3
4
5
6

@PutMapping
public Result updateShop(@RequestBody Shop shop) {
    return shopService.update(shop);
}

1

Result update(Shop shop);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

    @Override
    //如果删除缓存抛出异常  依赖@Transactional来回滚数据库事务
    @Transactional
    public Result update(Shop shop) {
        //1. 更新数据库
            //先判断以下ID是否为空
        if(shop.getId()==null){
            return Result.fail("店铺id不能为空");
        }
            //更新数据库
        updateById(shop);
        //2. 删除缓存  如果有之前的商铺id 这里直接删除之前的商铺的缓存  保持原子性
        stringRedisTemplate.delete(CACHE_SHOP_KEY + shop.getId());
        //返回结果
        return Result.ok();
    }
}

使用Postman来更新商铺

1. 在postman中添加一个New Request 改名为”更新店铺”。
2. 设置请求路径为http://localhost:8081/shop (注意是后端的8081)。
3. 在Body里选择raw-JSON模式，设置修改的信息，然后Send。
4. 当显示200 OK就是发送成功了。
   

   

• 这时查看CLI 发现已经调用updateById方法修改了商铺数据
• MySQL里的商铺数据也发生了更改
• Redis中这条商铺缓存已经删除了

• CLI
• MySQL

4.5 缓存穿透

• 缓存穿透：指客户端请求的数据在缓存中或在数据库中都不存在，这样缓存永远都不生效（只有数据库查到了，才会让redis缓存，现在的问题是查不到），会频繁的访问数据库。
• 常见的解决方案：
  • 缓存空对象：
    • 将不存在的数据设置为null存到redis中，这样下次用户就不会直接访问数据库。给这种空对象设置TTL，防止占用太多内存。但是如果恰好在数据库中更新了相同key的对象，就会数据库缓存短期不一致。
      • 优点：实现简单，维护方便。
      • 缺点：额外的内存消耗，可能造成短期的不一致。
  • 布隆过滤：
    • 在客户端和Redis之间设置一个布隆过滤器，过滤不存在的数据
      • 优点：内存占用少，没有多余的key。
      • 缺点：实现复杂，可能存在误判
        

        

编码解决商品查询的缓存穿透问题

• 核心思路如下
  

  

• 在ServiceImpl层增加判断逻辑 如果不存在将value设置为空字符串，设置较短的TTL，返回错误信息。
• 再次发起查询，判断value是否为空字符串，如果是，就说明是不存在的数据，返回错误信息。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

@Override public Result queryById(Long id) { //1. 从Redis查询商铺缓存 String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id); //2. 判断缓存是否命中 //3 如果命中 也就是数据在Redis中存在 if (StrUtil.isNotBlank(shopJson)) { Shop shop = JSONUtil.toBean(shopJson, Shop.class); return Result.ok(shop); } + //判断商铺信息是否为空值 + //这里shopJson只有空值和null两种情况 + //排除null就是空对象 + if(shopJson != null){ + return Result.fail("商铺不存在"); + } //3. 如果未命中 则在MySQL中查询 Shop shop = getById(id); - //4. 如果在MySQL中也没查到 返回404 + //4. 如果在MySQL中也没查到 将空值写入Redis if (shop == null) { + stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL,TimeUnit.MINUTES); return Result.fail("店铺不存在!"); } //5. 如果在MySQL中查到了 存入Redis 使用String存的是JSON类型 //写入缓存设置TTL stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES); //6. 返回商铺信息 return Result.ok(shop); }

运行之后进入一个不存在的店铺页面 会提示错误

在Redis中可以看到空对象，并且有很短的TTL

小结：

缓存穿透产生的原因是什么？
用户请求的数据在缓存中和在数据库中都不存在，不断发起这样的请求，会给数据库带来巨大压力
缓存产投的解决方案有哪些？
缓存null值
布隆过滤
增强id复杂度，避免被猜测id规律（可以采用雪花算法）
做好数据的基础格式校验
加强用户权限校验
做好热点参数的限流

4.6 缓存雪崩

• 缓存雪崩是指在同一时间段，大量缓存的key同时失效，或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

• 解决方案

  • 给不同的Key的TTL添加随机值，让其在不同时间段分批失效。
  • 利用Redis集群提高服务的可用性（使用一个或者多个哨兵(Sentinel)实例组成的系统，对redis节点进行监控，在主节点出现故障的情况下，能将从节点中的一个升级为主节点，进行故障转义，保证系统的可用性。 ）。
  • 给缓存业务添加降级限流策略 (在微服务中)。
  • 给业务添加多级缓存（浏览器访问静态资源时，优先读取浏览器本地缓存；访问非静态资源（ajax查询数据）时，访问服务端；请求到达Nginx后，优先读取Nginx本地缓存；如果Nginx本地缓存未命中，则去直接查询Redis（不经过Tomcat）；如果Redis查询未命中，则查询Tomcat；请求进入Tomcat后，优先查询JVM进程缓存；如果JVM进程缓存未命中，则查询数据库）。

4.7 缓存击穿

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

1
2
3
4
5
6
7

//设置互斥锁
private boolean tryLock(String key){
    //setOfAbsent就是redis中的setnx 如果value不为空则不能修改
    Boolean Mutex = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_SHOP_KEY + key, "notnull", LOCK_SHOP_TTL, TimeUnit.MINUTES);
    //避免返回值为null，我们这里使用了BooleanUtil工具类
    return BooleanUtil.isTrue(Mutex);
}

1
2
3
4

//释放互斥锁
  private void unLock(String key){
      stringRedisTemplate.delete(LOCK_SHOP_KEY + key);
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

//缓存穿透代码
public Shop queryWithPassThrough(Long id) {

    //1. 从Redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
    //2. 判断缓存是否命中
    //3 如果命中 也就是数据在Redis中存在
    //isNotBlank对于空字符串返回的也是false
    if (StrUtil.isNotBlank(shopJson)) {
        return JSONUtil.toBean(shopJson, Shop.class);
    }

    //判断商铺信息是否为空值
    //这里shopJson只有空值和null两种情况
    //排除null就是空对象
    if(shopJson != null){
        return null;
    }

    //3. 如果未命中  则在MySQL中查询
    Shop shop = getById(id);
    //4. 如果在MySQL中也没查到  将空值写入Redis
    if (shop == null) {
        stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
        return null;
    }
    //5. 如果在MySQL中查到了 存入Redis 使用String存的是JSON类型
    //写入缓存设置TTL
    stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
    //6. 返回商铺信息
    return shop;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

//缓存穿透代码
    public Shop queryWithMutex(Long id) {

        //1. 从Redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);
        //2. 判断缓存是否命中
        //3 如果命中 也就是数据在Redis中存在
        //isNotBlank对于空字符串返回的也是false
        if (StrUtil.isNotBlank(shopJson)) {
            return JSONUtil.toBean(shopJson, Shop.class);
        }

        //判断商铺信息是否为空值
        //这里shopJson只有空值和null两种情况
        //排除null就是空对象
        if(shopJson != null){
            return null;
        }
        Shop shop = null;

        try {
            //3. 如果未命中 实现缓存重建
            //3.1 获取互斥锁
            boolean isGetLock = tryLock(CACHE_SHOP_KEY + id);
            //3.2 判断是否获取成功
            if(!isGetLock){
                //3.3 如果获取失败 休眠并重试
                Thread.sleep(50);
                //递归
                return queryWithMutex(id);
            }
            //如果成功获取  根据id查询数据库
            shop = getById(id);
            //为了更容易发生并发冲突  这里模拟重建的延迟  =  如果是企业级代码一定不行
            Thread.sleep(200);

            //4. 如果在MySQL中也没查到  将空值写入Redis
            if (shop == null) {
                stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
                return null;
            }
            //5. 如果在MySQL中查到了 存入Redis 使用String存的是JSON类型
            //写入缓存设置TTL
            stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            //6. 释放互斥锁
            unLock(CACHE_SHOP_KEY + id);

        }

        //7. 返回商铺信息
        return shop;

    }

1
2
3
4
5
6
7
8
9
10
11
12
13

 @Override
    public Result queryById(Long id) {
       //缓存穿透
//        Shop shop = queryWithPassThrough(id);

        //互斥锁解决缓存击穿
        Shop shop = queryWithMutex(id);
        if (shop == null) {
            return Result.fail("店铺不存在！");
        }
        //返回商铺信息
        return Result.ok(shop);
    }

1
2
3

: ==>  Preparing: SELECT id,name,type_id,images,area,address,x,y,avg_price,sold,comments,score,open_hours,create_time,update_time FROM tb_shop WHERE id=?
: ==> Parameters: 2(Long)
: <==      Total: 1

1
2
3
4
5
6

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//将封装有获取时间的店铺信息传到redis
  //设置成public以便于测试类调用
  public void saveShopToRedis(Long id,Long expireSeconds){
      //1. 查询店铺数据
      Shop shop = getById(id);

      //2. 写入逻辑过期
      RedisData redisData = new RedisData();
      //将shop的数据添加到redisData当中
      redisData.setData(shop);
      //过期时间 = 本地时间 + 所预期的时间
      redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));

      //3. 写入Redis
      stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData),CACHE_SHOP_TTL, TimeUnit.MINUTES);
  }

1
2
3
4

@Test
void testSaveShopToRedis() {
    shopService.saveShopToRedis(1L,20L);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

{
  "data": {
    "area": "大关",
    "openHours": "10:00-22:00",
    "sold": 4215,
    "images": "",
    "address": "金华路锦昌文华苑29号",
    "comments": 3035,
    "avgPrice": 80,
    "updateTime": 1760852369000,
    "score": 37,
    "createTime": 1640167839000,
    "name": "102茶餐厅",
    "x": 120.149192,
    "y": 30.316078,
    "typeId": 1,
    "id": 1
  },
  "expireTime": 1760929504900
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

//创建一个缓存重建线程池
private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

//使用逻辑过期解决缓存穿透代码
public Shop queryWithLogicalExpire(Long id) {

    //1. 从Redis查询商铺缓存
    String shopJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_KEY + id);

    //因为这是解决缓存穿透的代码，默认已经有了热点数据，所以如果未命中直接返回空
    if(StrUtil.isBlank(shopJson)){
        return null;
    }
    //如果命中  判断缓存是否过期
    //先把JSON反序列化为对象
    RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
    //将data转为Shop对象

    //redisData中的data是一个JSONObject类型
    //将data修改为shop类型
    JSONObject data = (JSONObject)redisData.getData();
    Shop shop = JSONUtil.toBean(data, Shop.class);

    //获取过期时间
    LocalDateTime expireTime = redisData.getExpireTime();

    //未过期 直接返回商铺信息
    if (expireTime.isAfter(LocalDateTime.now())) {
        return shop;
    }

    //过期了 尝试获取互斥锁
    boolean getKey = tryLock(LOCK_SHOP_KEY + id);
    if (getKey) {
        //成功获取互斥锁  开启独立线程  实现缓存重建
        CACHE_REBUILD_EXECUTOR.submit(() -> {
            try {
                //缓存重建就是重新查看数据库  重新将数据写入缓存
                saveShopToRedis(id,20L);
            } catch (Exception e) {
                throw new RuntimeException(e);
            } finally {
                //释放锁
                unLock(LOCK_SHOP_KEY + id);
            }
        });
    }
    return shop;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

@Override
public Result queryById(Long id) {
    //解决缓存穿透
    //Shop shop = queryWithPassThrough(id);

    //互斥锁解决缓存击穿
    //Shop shop = queryWithMutex(id);

    //逻辑过期解决缓存击穿
    Shop shop = queryWithLogicalExpire(id);

    //判断是否为空数据
    if (shop == null) {
        return Result.fail("店铺不存在！");
    }
    //返回商铺信息
    return Result.ok(shop);
}

4.8 封装缓存工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202

package com.hmdp.utils;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.hmdp.entity.Shop;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.*;


@Slf4j
@Component
public class CacheClient {
    @Resource
    private StringRedisTemplate stringRedisTemplate;



    //方法1：将任意Java对象序列化为JSON，并存储到String类型的Key中，并可以设置TTL过期时间
    public void set(String key, Object value,Long time, TimeUnit timeUnit) {
        //将value序列化为JSON字符串
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, timeUnit);
    }


    //方法2：将任意Java对象序列化为JSON，并存储在String类型的Key中，并可以设置逻辑过期时间，用于处理缓存击穿问题
    public void setWithLogicExpire(String key, Object value, Long time, TimeUnit timeUnit) {
        //由于要生成过期时间 所以需要用到RedisData
        RedisData redisData = new RedisData();
        //添加逻辑过期时间
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(time)));
        //添加数据
        redisData.setData(value);
        //将数据转化成json存入redis 因为是逻辑过期所以不需要加过期时间
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
    }



    //方法3：根据指定的Key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
    //这里返回值不确定 使用泛型
    //所以参数要有数据的类型 来告诉泛型要用什么类型
    //因为id是一个string类型 所以这里需要传一个id的前缀
    //id的类型也不确定  所以也需要用泛型
    //因为不知道类型 不能使用getById 所以使用function 传入数据库取出操作 第一个参数是传入的值  第二个参数是返回类型也就是R
    public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit timeUnit) {
        String key = keyPrefix + id;

        String json = stringRedisTemplate.opsForValue().get(key);

        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }


        if(json != null){
            return null;
        }


        R r = dbFallback.apply(id);


        //如果数据库中没有  返回空值
        if (r == null) {
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.SECONDS);
            return null;
        }

        set(key,r,time,timeUnit);

        return r;
    }



    //方法4：根据指定的Key查询缓存，并反序列化为指定类型，需要利用互斥锁解决缓存击穿问题
    public <R, ID> R queryWithMutex(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit timeUnit) {
        //先从Redis中查，这里的常量值是固定的前缀 + 店铺id
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);
        //如果不为空（查询到了），则转为Shop类型直接返回
        if (StrUtil.isNotBlank(json)) {
            return JSONUtil.toBean(json, type);
        }
        if (json != null) {
            return null;
        }
        R r = null;
        String lockKey = LOCK_SHOP_KEY + id;
        try {
            //否则去数据库中查
            boolean flag = tryLock(lockKey);
            if (!flag) {
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, timeUnit);
            }
            r = dbFallback.apply(id);
            //查不到，则将空值写入Redis
            if (r == null) {
                stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            //并存入redis，设置TTL
            this.set(key, r, time, timeUnit);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            unLock(lockKey);
        }
        return r;
    }



    //创建一个缓存重建线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    //5. 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题
    public <R,ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time, TimeUnit timeUnit) {

        //1. 从Redis查询缓存
        String key = keyPrefix + id;
        String json = stringRedisTemplate.opsForValue().get(key);

        //因为这是解决缓存穿透的代码，默认已经有了热点数据，所以如果未命中直接返回空
        if(StrUtil.isBlank(json)){
            return null;
        }

        //如果命中  判断缓存是否过期
        //先把JSON反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        //将data转为Shop对象

        //redisData中的data是一个JSONObject类型
        //将data修改为shop类型
        JSONObject data = (JSONObject)redisData.getData();
        //这里R是泛型  所以不能用R.class
        R r = JSONUtil.toBean(data, type);

        //获取过期时间
        LocalDateTime expireTime = redisData.getExpireTime();

        //未过期 直接返回商铺信息
        if (expireTime.isAfter(LocalDateTime.now())) {
            return r;
        }

        //过期了 尝试获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        boolean getKey = tryLock(lockKey);
        if (getKey) {
            //成功获取互斥锁  开启独立线程  实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //缓存重建就是重新查看数据库  重新将数据写入缓存
                    //先查数据库 得到数据
                    //r1是新的数据
                    R r1 = dbFallback.apply(id);
                    //再写Redis
                    //这里将ri变为之后的r
                    setWithLogicExpire(key,r1,time,timeUnit);

                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    //释放锁
                    unLock(lockKey);
                }
            });
        }
        //这里如果没有获取互斥锁  获取的是过期的数据
        return r;
    }


    //设置互斥锁
    private boolean tryLock(String key){
        //setOfAbsent就是redis中的setnx 如果value不为空则不能修改
        Boolean Mutex = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_SHOP_KEY + key, "notnull", LOCK_SHOP_TTL, TimeUnit.MINUTES);
        //避免返回值为null，我们这里使用了BooleanUtil工具类
        return BooleanUtil.isTrue(Mutex);
    }


    //释放互斥锁
    private void unLock(String key){
        stringRedisTemplate.delete(LOCK_SHOP_KEY + key);
    }

}