【Redis实战篇】黑马点评学习笔记（16万字超详细、Redis实战项目学习必看、欢迎点赞⭐收藏）

Hiヽ(゜▽゜ )－欢迎来到蓝染Aizen的CSDN博客~ 🔥 博客主页： 【✨蓝染 の Blog😘】 💖感谢大家点赞👍 收藏⭐ 评论✍

文章目录

一、项目知识点介绍二、短信登录1、导入黑马点评项目（1）导入SQL（2）项目架构模型（3）导入后端项目（4）导入前端项目

2、基于Session实现登录流程3、实现阿里云发送短信验证码功能4、实现登录拦截和登录验证功能5、集群的Session共享问题6、基于Redis实现共享Session登录流程梳理（1）设计存储的数据结构（2）设计Key的细节（3）整体访问流程

7、基于Redis实现短信登录8、解决登录状态刷新问题（1）初始方案问题分析（2）优化登录拦截器

三、商户查询缓存1、添加商户缓存2、查询店铺类型缓存3、缓存一致性问题（1）常见的缓存更新策略（2）主动更新策略的三种方案（3）双写方案 操作缓存和数据库需要考虑的三个问题

4、实现商铺查询的数据库与缓存双写一致5、缓存穿透的解决方案6、缓存雪崩的解决方案7、缓存击穿的解决方案8、利用互斥锁解决缓存击穿问题9、利用逻辑过期解决缓存击穿问题10、封装Redis工具类

四、优惠券秒杀1、全局唯一ID（1）数据库自增ID存在的问题（2）基于Redis自增器实现分布式全局ID

2、实现秒杀下单优惠券功能3、单体服务下一人多单超卖问题4、乐观锁解决一人多单超卖问题5、单体服务下一人一单超卖问题6、悲观锁解决单体服务下一人一单超卖问题7、集群服务下一人一单超卖问题（1）搭建服务集群并实现负载均衡（2）一人一单的并发安全问题

8、分布式锁介绍9、Redis分布式锁解决集群超卖问题10、Redis分布式锁优化（1）Redis分布式锁超时误删问题（2）解决Redis分布式锁超时误删问题（3）Redis分布式锁释放锁原子性问题（4）解决Redis分布式锁释放锁原子性问题

11、Redisson（1）介绍（2）Redisson实现分布式锁（3）Redisson分布式锁原理① 可重入锁的原理② Redisson源码流程原理解析

12、Redis异步秒杀优化（1）秒杀业务性能测试（2）异步秒杀思路分析（3）改进秒杀业务，提高并发性能

13、Redis消息队列实现异步秒杀（1）基于List结构模拟消息队列（2）基于PubSub的消息队列（3）基于Stream的消息队列① Stream的单消费模式② Stream的消费者组模式

（4）Stream消息队列优化异步秒杀

五、达人探店1、发布探店笔记2、查看探店笔记3、Set实现点赞功能4、Sorted Set实现点赞排行榜功能

六、好友关注1、关注和取关2、共同关注3、关注推送（1）Feed流实现方案（2）推送到粉丝收件箱（3）实现滚动分页查询

七、附近商铺1、GEO的基本用法2、附近商户搜索

八、用户签到1、BitMap的基本用法2、实现签到功能3、实现统计连续签到天数

九、UV统计1、HyperLogLog的基本用法2、实现百万数据的统计

一、项目知识点介绍

本项目包含了Redis各种应用技巧和解决方案，具体包括：

短信登录：使用Redis共享session来实现。商户查询缓存：企业的缓存使用技巧、缓存击穿，缓存穿透，缓存雪崩等问题解决。优惠卷秒杀：Redis的计数器功能、 结合Lua脚本完成高性能的Redis操作、Redis分布式锁、Redis的三种消息队列。好友关注：基于Set集合的关注、取消关注，共同关注、消息推送等功能。达人探店：基于List来完成点赞列表的操作，同时基于SortedSet来完成点赞排行榜功能。附近的商户：利用Redis的GEOHash来完成对于地理坐标的操作。用户签到：使用Redis的BitMap数据统计功能。UV统计：使用Redis的HyperLogLog来完成统计功能。

✅ 视频地址：[实战篇] 黑马程序员Redis入门到实战教程，深度透析redis底层原理+redis分布式锁+企业解决方案+黑马点评实战项目

💡 Redis基础篇在这里👉【Redis基础篇】超详细♥Redis安装教程、5种常用数据结构和常见命令、Jedis和SpringDataRedis的使用

📂 Redis实战篇官方代码资料

📚 本文代码gitee仓库地址

二、短信登录

1、导入黑马点评项目

（1）导入SQL

首先，创建名为hmdp数据库，执行hmdp.sql脚本：

// 此处省略sql文件和导入步骤

注意：MySQL的版本采用5.7及以上，最好是8.0版本

（2）项目架构模型

Nginx服务器作为静态资源服务器，部署前端项目，经过Nginx负载均衡分流到下游tomcat服务器。在高并发场景下，会选择使用MySQL集群，同时为了进一步降低MySQL的压力，同时增加访问的性能，我们也会加入Redis，同时使用Redis集群使得Redis对外提供更好的服务。

（3）导入后端项目

后端项目代码导入idea后，修改yaml配置文件中mysql和redis相关配置信息。

启动后端项目后，在浏览器访问：http://localhost:8081/shop-type/list，如果可以看到app界面，则运行成功。

（4）导入前端项目

前端项目代码已经放在了nginx-1.18.0/html 下，在nginx所在目录下打开一个CMD窗口，输入start nginx.exe即可启动前端项目。

启动前端项目后，在浏览器访问：http://localhost:8080，如果可以看到app界面，则运行成功。

2、基于Session实现登录流程

发送验证码：

用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号。

如果手机号合法，后台此时生成对应的验证码，同时将验证码保存到session中，然后再通过短信的方式将验证码发送给用户。

短信验证码登录、注册：

用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验；如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，创建session时tomcat会自动生成JsessionId写到用户浏览器的Cookie里，方便后续获得当前登录信息。

校验登录状态:

用户在请求时候，会从cookie中携带着JsessionId到后台，后台通过JsessionId从session中拿到用户信息，也就是说登录凭证就是JsessionId。如果没有session信息，则进行拦截；如果有session信息，则将用户信息保存到threadLocal中，并且放行。

ThreadLocal是一个线程域对象，在我们的业务中，每一个请求到达微服务都是一个独立的线程，如果没有用ThreadLocal，直接把用户保存到一个本地变量，就有可能出现多线程环境下的并发修改安全问题。而将用户保存在ThreadLocal中，它会在每一个线程的内部创建一个Map将数据保存，这样每一个线程都有自己独立的存储空间，与其他请求线程相互之间没有干扰，实现了线程隔离的效果。

3、实现阿里云发送短信验证码功能

发送手机验证码页面流程

发送验证码

/**

* 发送手机验证码

*/

@PostMapping("code")

public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {

// 发送短信验证码并保存验证码

return userService.sendCode(phone, session);

}

/**

* 发送手机验证码

*/

@Override

public Result sendCode(String phone, HttpSession session) {

// 校验手机号格式是否有效

if (RegexUtils.isPhoneInvalid(phone)) {

// 格式不符合，返回错误信息

return Result.fail("手机号格式错误！");

}

// 格式有效，生成验证码

String code = RandomUtil.randomNumbers(6); // 随机6位数字

// 保存验证码到session

session.setAttribute(phone, code);

// 模拟发送短信验证码

log.debug("向{}发送短信验证码成功，验证码：{}", phone, code);

// 返回ok

return Result.ok();

}

由于这里是日志输出模拟发送验证码，如果我们真的想要给手机发送验证码，需要去开通阿里云短信服务，申请签名和短信模板，阿里云SMS短信服务官方帮助文档：https://help.aliyun.com/zh/sms/。

去官网申请和配置好AK密钥对后，就可以使用下面的工具类发送阿里云短信啦~

导入SMS依赖坐标

com.aliyun

dysmsapi20170525

3.0.0

阿里云短信验证码发送工具类SMSUtils（支持双参数短信模板）

/**

* 阿里云短信验证码发送工具类

*/

public class SMSUtils {

/**

* 发送短信（双参数模板）

* : 接收短信的手机号码，多个用英文逗号隔开

* : 短信签名名称，eg: "阿里云"

* : 短信模板CODE

* : 短信模板变量对应的实际值，eg：{"code":"1234"}

*

* @param signName 签名

* @param templateCode 模板

* @param phoneNumbers 手机号

* @param code 验证码

* @param time 验证码有效期（单位：秒）

*/

public static void sendMessage(String signName, String templateCode, String phoneNumbers, String code, int time) {

// 初始化请求客户端

Client client = null;

try {

client = SMSUtils.createClient();

} catch (Exception e) {

throw new RuntimeException(e);

}

// 构造请求对象，请填入请求参数值

SendSmsRequest sendSmsRequest = new SendSmsRequest()

.setPhoneNumbers(phoneNumbers)

.setSignName(signName)

.setTemplateCode(templateCode)

.setTemplateParam("{\"code\":\"" + code + "\",\"time\":\"" + time + "\"}");

// 获取响应对象

SendSmsResponse sendSmsResponse = null;

try {

sendSmsResponse = client.sendSms(sendSmsRequest);

} catch (Exception e) {

throw new RuntimeException(e);

}

// 响应包含服务端响应的 body 和 headers

System.out.println(toJSONString(sendSmsResponse));

//System.out.println(sendSmsResponse.getBody());

}

private static Client createClient() throws Exception {

Config config = new Config()

// 配置 AccessKey ID，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_ID。

.setAccessKeyId(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID"))

// 配置 AccessKey Secret，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_SECRET。

.setAccessKeySecret(System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET"));

// 配置 Endpoint

config.endpoint = "dysmsapi.aliyuncs.com";

return new Client(config);

}

/**

* 发送短信（单参数模板）

* : 接收短信的手机号码，多个用英文逗号隔开

* : 短信签名名称，eg: "阿里云"

* : 短信模板CODE

* : 短信模板变量对应的实际值，eg：{"code":"1234"}

*

* @param signName 签名

* @param templateCode 模板

* @param phoneNumbers 手机号

* @param code 验证码

*/

public static void sendMessage(String signName, String templateCode, String phoneNumbers, String code) {

// 初始化请求客户端

Client client = null;

try {

client = SMSUtils.createClient();

} catch (Exception e) {

throw new RuntimeException(e);

}

// 构造请求对象，请填入请求参数值

SendSmsRequest sendSmsRequest = new SendSmsRequest()

.setPhoneNumbers(phoneNumbers)

.setSignName(signName)

.setTemplateCode(templateCode)

.setTemplateParam("{\"code\":\"" + code + "\"}");

// 获取响应对象

SendSmsResponse sendSmsResponse = null;

try {

sendSmsResponse = client.sendSms(sendSmsRequest);

} catch (Exception e) {

throw new RuntimeException(e);

}

// 响应包含服务端响应的 body 和 headers

System.out.println(toJSONString(sendSmsResponse));

}

}

调用工具类发送短信

// 发送验证码，有效期LOGIN_CODE_TTL分钟

SMSUtils.sendMessage("签名signName", "SMS_474225xxx", phone, code, LOGIN_CODE_TTL);

log.debug("向{}发送短信验证码成功，验证码：{}", phone, code);

登录页面流程

登录、注册

/**

* 登录功能

*/

@PostMapping("/login")

public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){

// 实现登录功能

return userService.login(loginForm, session);

}

/**

* 登录、注册

* @param loginForm 验证码登录：手机号、验证码；密码登录：手机号、密码

* @param session session中获取验证码，保存用户到session

* @return

*/

@Override

public Result login(LoginFormDTO loginForm, HttpSession session) {

// 校验手机号

String phone = loginForm.getPhone();

if (RegexUtils.isPhoneInvalid(phone)) {

// 格式不符合，返回错误信息

Result.fail("手机号格式错误！");

}

// 校验验证码

Object cacheCode = session.getAttribute(phone);

String code = loginForm.getCode();

// 如果没有发送验证码，或者session中验证码过期、验证码不一致

if (cacheCode == null || !cacheCode.toString().equals(code)) {

// 不一致报错

return Result.fail("验证码错误");

}

// 一致，根据手机号查询用户

User user = query().eq("phone", phone).one();

// 判断用户是否存在

if (user == null) {

// 不存在，创建新用户保存并返回

user = createUserWithPhone(phone);

}

// 保存用户到session中

session.setAttribute("user", BeanUtil.copyProperties(user, UserVo.class));

return Result.ok();

}

/**

* 根据手机号创建用户

* @param phone 手机号

* @return 用户

*/

private User createUserWithPhone(String phone) {

User user = new User();

user.setPhone(phone);

user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));

save(user);

return user;

}

4、实现登录拦截和登录验证功能

Tomcat运行原理

当用户发起请求时，会访问我们像tomcat注册的端口，任何程序想要运行，都需要有一个线程对当前端口号进行监听，当监听线程知道用户想要和tomcat连接连接时，那会由监听线程创建socket连接，socket都是成对出现的，用户通过socket像互相传递数据，当tomcat端的socket接受到数据后，此时监听线程会从tomcat的线程池中取出一个线程执行用户请求，在我们的服务部署到tomcat后，线程会找到用户想要访问的工程，然后用这个线程转发到工程中的controller，service，dao中，并且访问对应的DB，在用户执行完请求后，再统一返回，再找到tomcat端的socket，再将数据写回到用户端的socket，完成请求和响应。

我们可以得知：每个用户其实对应都是去找tomcat线程池中的一个线程来完成工作的， 使用完成后再进行回收，既然每个请求都是独立的，所以在每个用户去访问我们的工程时，我们可以使用ThreadLocal来做到线程隔离，每个线程操作自己的一份数据。

当随着业务的开发，越来越多的业务都需要去校验用户的登录，我们应该考虑把用户登录验证功能的逻辑抽取到一个地方，就是SpringMVC的拦截器，它可以在请求所有Controller之前去做，用户的所有请求必须先经过拦截器，再由拦截器判断是否放行到对应的Controller。

第二个问题是，拦截器帮我们完成了对用户的校验，拿到了用户信息，那对应的Controller如何拿到用户信息呢？因此我们应该设计一个方案，将拦截器里得到的用户信息传递到Controller，在传递过程中需要保证线程安全问题。这个方案就是将用户信息保存到ThreadLocal中。

关于ThreadLocal

ThreadLocal是一个线程域对象，每一个进入Tomcat的请求都是一个独立的线程，ThreadLocal会在当前用户线程内开辟一块独立的内存空间，保存信息到对应的ThreadLocalMap，保证每个线程互相不干扰。在ThreadLocal的源码中，无论是它的put方法还是get方法， 都是先从获得当前用户的线程，然后从线程中取出线程的成员变量map，只要线程不一样，map就不一样，所以可以通过这种方式来做到线程隔离。

存入ThreadLocal中的主要原因

（1）避免后续业务操作频繁向session域中存取数据，减少session的访问开销。（2）避免线程安全问题。

登录验证功能页面请求

使用UserVo返回给前端，仅提供前端视图需要展示的属性，隐藏用户敏感信息

/**

* 用户Vo

*/

@Data

public class UserVo {

// 用户id

private Long id;

// 昵称

private String nickName;

// 头像

private String icon;

}

ThreadLocal工具类

/**

* ThreadLocal工具类

*/

public class BaseContext {

/** ThreadLocal对象 */

private static final ThreadLocal threadLocal = new ThreadLocal();

/**

* 根据键获取值

*/

public static T get() {

return (T) threadLocal.get();

}

/**

* 存储键值对

*/

public static void set(T value) {

threadLocal.set(value);

}

/**

* 清除ThreadLocal，销毁线程，防止内存泄漏

*/

public static void remove() {

threadLocal.remove();

}

}

拦截器代码

/**

* 登录拦截器：需要实现 HandlerInterceptor 接口

*/

@Slf4j

public class LoginInterceptor implements HandlerInterceptor {

/**

* 前置拦截，在Controller执行之前

* 做登录验证校验

*/

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

// 获取session

HttpSession session = request.getSession();

// 获取session中的用户

Object user = session.getAttribute("user");

// 判断用户是否存在

if (user == null) {

// 不存在，拦截，响应401状态码：未授权

response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);

return false;

}

// 存在，保存用户信息到ThreadLocal中

BaseContext.set((UserVo) user);

log.debug("拦截器BaseContext.UserVo = {}", (UserVo) BaseContext.get());

// 放行

return true;

}

/**

* 后置拦截，在Controller执行之后

*/

@Override

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);

}

/**

* 在视图渲染之后，返回给用户之前

* 业务执行完后，销毁用户信息，避免内存泄露

*/

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

// 移除用户信息，销毁当前线程，防止内存泄露

BaseContext.remove();

}

}

在SpringMVC配置类中注册拦截器，让拦截器生效

/**

* SpringMVC配置类：需要实现 WebMvcConfigurer 接口

*/

@Configuration

public class MvcConfig implements WebMvcConfigurer {

/**

* 向拦截器注册器中添加拦截器，使拦截器生效

* @param registry 拦截器注册器

*/

@Override

public void addInterceptors(InterceptorRegistry registry) {

// 本项目是前后端分离的，静态资源在nginx前端服务器中，因此访问静态资源的时候不会走到后端拦截器，所以不用放行前端静态资源

registry.addInterceptor(new LoginInterceptor())

// 排除不需要拦截的请求路径

.excludePathPatterns(

"/user/code",

"/user/login",

"/blog/hot",

"/shop/**",

"/shop-type/**",

"/voucher/**",

"/upload/**"

);

}

}

实现登录验证功能

/**

* 校验登录状态

*/

@GetMapping("/me")

public Result me(){

// 获取当前登录的用户并返回

UserVo userVo = BaseContext.get();

return Result.ok(userVo);

}

实现登出功能

/**

* 登出功能

*/

@PostMapping("/logout")

public Result logout(HttpSession session){

// 销毁ThreadLocal中的用户信息

BaseContext.remove();

// 销毁session

session.invalidate();

return Result.ok();

}

5、集群的Session共享问题

Session共享问题：当搭建多节点Tomcat服务器集群时，多台Tomcat并不共享session存储空间，当请求切换到不同tomcat服务时导致数据丢失的问题。

核心问题分析：

每个tomcat中都有一份属于自己的session，假设用户第一次访问第一台tomcat，并且把自己的信息存放到第一台服务器的session中，但是第二次这个用户访问到了第二台tomcat，那么在第二台服务器上，肯定没有第一台服务器存放的session，所以此时整个登录拦截功能就会出现问题。

我们能如何解决这个问题呢？早期的方案是session拷贝，就是说虽然每个tomcat上都有不同的session，但是每当任意一台服务器的session修改时，都会同步给其他的tomcat服务器的session，这样的话，就可以实现session的共享了。

但是这种方案具有两个大问题：

每台服务器中都有完整的一份session数据，服务器压力过大，冗余备份问题。session拷贝数据时，可能会出现延迟，数据一致性存在问题

此时适合解决这个场景的方案需要满足三点：

数据共享高并发下读写迅速存储结构为key-value

由于redis是基于内存存储，性能非常强，读写延迟基本在微秒级别。因此我们将session换成redis存储数据，redis脱离了tomcat存储数据，支持多台tomcat服务器共享数据，也就避免了session共享的问题。为了保证redis数据不丢失，后期还可以考虑搭建redis集群。

6、基于Redis实现共享Session登录流程梳理

（1）设计存储的数据结构

首先我们要思考一下利用redis来存储数据，那么到底使用哪种结构呢？由于存入的数据比较简单，我们可以考虑使用String 或者hash ，如下图。

String结构与Hash结构存储值的比较

String的值是将Java对象序列化为JSON字符串的形式保存，更加直观，操作也更加简单，但是 JSON 结构会有很多非必须的内存开销，比如双引号、大括号，内存占用比Hash更高。Hash的值是以hash表的形式保存，通过field单独存储对象中每个属性的值，对单个字段增删改查更加灵活，hash类型存储空间占用比String类型更小。

这里我们选择使用hash结构来实现存储。

（2）设计Key的细节

关于key的处理，session是每个用户都有自己独立的session，因此key可以写死为code，因为每个session有不同的sessionId来保证唯一性。但是redis的key是共享的，就不能使用硬编码的key了。

因此在设计key的适合，需要满足两点：

key要具有唯一性key要方便客户端携带，方便从redis中取出这个value

如果我们采用phone手机号作为key来存储当然是可以的，但是如果把这样的敏感数据存储到redis中并且从页面中带过来毕竟不太合适。所以我们在后台生成一个随机串token，tomcat并不会像sessionId那样把token自动写到客户端浏览器中，因此我们需要手动的把token返回给客户端，客户端保存token作为登录凭证，之后客户端携带着token来发送请求，后端服务器验证token后就可以基于token从redis中获取数据。

（3）整体访问流程

当注册完成后，用户去登录会去校验用户提交的手机号和验证码是否一致，如果一致，则根据手机号查询用户信息，不存在则新建，最后将用户数据保存到redis，并且生成token作为redis的key，当我们校验用户是否登录时，会去携带着token进行访问，从redis中取出token对应的value，判断是否存在这个数据，如果没有则拦截，如果存在则将其保存到threadLocal中，并且放行。

前端处理token的代码：

前端发送axios请求，被前端拦截器拦截，在请求头中填充token，经过后端拦截器，从请求头中的通过authorization获取token字符串，从而拿出redis中的用户数据。

7、基于Redis实现短信登录

UserServiceImpl

/**

* 登录、注册

* @param loginForm 验证码登录：手机号、验证码；密码登录：手机号、密码

* @return

*/

@Override

public Result login(LoginFormDTO loginForm) {

// 校验手机号

String phone = loginForm.getPhone();

if (RegexUtils.isPhoneInvalid(phone)) {

// 格式不符合，返回错误信息

Result.fail("手机号格式错误！");

}

// 从redis中获取验证码并校验

String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY_PREFIX + phone);

String code = loginForm.getCode();

// 如果没有发送验证码或者redis中验证码过期、验证码不一致

if (cacheCode == null || !cacheCode.equals(code)) {

// 不一致报错

return Result.fail("验证码错误");

}

// 一致，根据手机号查询用户

User user = query().eq("phone", phone).one();

// 判断用户是否存在

if (user == null) {

// 不存在，创建新用户保存并返回

user = createUserWithPhone(phone);

}

// 随机生成token，作为登录令牌，相当于JsessionId

String token = UUID.fastUUID().toString(true); // fastUUID比randomUUID生成速度更快，toString(true)表示生成的UUID不带-短横线分隔

// 将UserVo对象转为HashMap存储

UserVo userVo = BeanUtil.copyProperties(user, UserVo.class);

Map userMap = BeanUtil.beanToMap(userVo, new HashMap<>(),

CopyOptions.create()

// 忽略值为null的数据

.setIgnoreNullValue(true)

// 参数：字段名和字段值，返回值是修改后的字段值。将字段值转为字符串

.setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));

// 保存用户信息到redis中

String tokenKey = LOGIN_USER_KEY_PREFIX + token;

stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);

// 设置用户信息的有效期

stringRedisTemplate.expire(tokenKey, Duration.ofMinutes(LOGIN_USER_TTL));

// 返回token

return Result.ok(token);

}

LoginInterceptor

/**

* 登录拦截器：需要实现 HandlerInterceptor 接口

*/

@Slf4j

public class LoginInterceptor implements HandlerInterceptor {

private StringRedisTemplate stringRedisTemplate;

public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {

this.stringRedisTemplate = stringRedisTemplate;

}

/**

* 前置拦截，在Controller执行之前

* 做登录验证校验

*/

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

// 获取请求头中的token

String token = request.getHeader("authorization");

// 判断用户是否是已登录状态

if (StrUtil.isBlank(token)) {

// token为空说明未登录，拦截，响应401状态码：未授权

response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);

return false;

}

// 基于token获取redis中的用户信息（若entries的key为空默认返回空Map）

String tokenKey = LOGIN_USER_KEY_PREFIX + token;

Map userMap = stringRedisTemplate.opsForHash().entries(tokenKey);

// 判断用户是否存在

if (userMap.isEmpty()) {

// 不存在，拦截，响应401状态码：未授权

response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);

return false;

}

// 将查询到的Hash数据转为UserVo对象

UserVo userVo = BeanUtil.fillBeanWithMap(userMap, new UserVo(), false);

// 存在，保存用户信息到ThreadLocal中

BaseContext.set(userVo);

//log.debug("拦截器BaseContext.UserVo = {}", (UserVo) BaseContext.get());

// 只要用户在操作发送请求，就刷新token有效期

stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

// 放行

return true;

}

/**

* 在视图渲染之后，返回给用户之前

* 业务执行完后，销毁用户信息，避免内存泄露

*/

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

// 移除用户信息，销毁当前线程，防止内存泄露

BaseContext.remove();

}

}

8、解决登录状态刷新问题

（1）初始方案问题分析

在这个方案中，他确实可以使用对应路径的拦截，同时刷新登录token令牌的存活时间，但是现在这个拦截器他只是拦截需要被拦截的路径，假设当前用户访问了一些不需要拦截的路径，那么这个拦截器就不会生效，所以此时令牌刷新的动作实际上就不会执行，所以这个方案他是存在问题的。

（2）优化登录拦截器

单独配置一个拦截器用户刷新Redis中的token：在基于Session实现短信验证码登录时，我们只配置了一个拦截器，这里需要另外再配置一个拦截器专门用户刷新存入Redis中的token。因为我们现在改用Redis了，为了防止用户在操作网站时突然由于Redis中的token过期，导致直接退出网站，严重影响用户体验。

那为什么不把刷新的操作放到一个拦截器中呢？因为之前的那个拦截器只是用来拦截一些需要进行登录校验的请求，对于哪些不需要登录校验的请求是不会走拦截器的，刷新操作显然是要针对所有请求比较合理，所以单独创建一个拦截器拦截一切请求，对于已登录的用户刷新Redis中的token，对于未登录的用户请求，不需要刷新Redis中的token，直接放行交给第二个登录拦截器去做未授权拦截，完成整体刷新功能。

因为第一个拦截器有了ThreadLocal的数据，所以此时第二个拦截器只需要判断ThreadLocal中的用户信息是否存在即可，存在说明已登录放行，不存在说明未登录进行未授权拦截。

刷新token的拦截器

/**

* 刷新Token拦截器：需要实现 HandlerInterceptor 接口

*/

public class RefreshTokenInterceptor implements HandlerInterceptor {

private StringRedisTemplate stringRedisTemplate;

public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {

this.stringRedisTemplate = stringRedisTemplate;

}

/**

* 拦截一切用户请求

* 对于已登录的用户刷新Redis中的token

* 对于未登录的用户请求，不需要刷新Redis中的token，直接放行交给第二个登录拦截器去做未授权拦截

*/

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

// 获取请求头中的token

String token = request.getHeader("authorization");

// 判断用户是否是已登录状态

if (StrUtil.isBlank(token)) {

// token不存在，说明当前用户未登录，不需要刷新直接放行

return true;

}

// 基于token获取redis中的用户信息（若entries的key为空默认返回空Map）

String tokenKey = LOGIN_USER_KEY_PREFIX + token;

Map userMap = stringRedisTemplate.opsForHash().entries(tokenKey);

// 判断用户是否存在

if (userMap.isEmpty()) {

// 用户不存在，说明当前用户未登录，不需要刷新直接放行

return true;

}

// 将查询到的Hash数据转为UserVo对象

UserVo userVo = BeanUtil.fillBeanWithMap(userMap, new UserVo(), false);

// 存在，保存用户信息到ThreadLocal中

BaseContext.set(userVo);

// 只要用户在操作发送请求，就刷新token有效期

stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

// 放行

return true;

}

/**

* 在视图渲染之后，返回给用户之前

* 业务执行完后，销毁用户信息，避免内存泄露

*/

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

// 移除用户信息，销毁当前线程，防止内存泄露

BaseContext.remove();

}

}

登录拦截器

/**

* 登录拦截器：需要实现 HandlerInterceptor 接口

*/

public class LoginInterceptor implements HandlerInterceptor {

/**

* 前置拦截，在Controller执行之前

* 做登录验证校验，只需要判断ThreadLocal中的用户信息是否存在即可，存在说明已登录放行，不存在说明未登录进行未授权拦截。

*/

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

// 判断是否需要拦截（ThreadLocal中是否有用户）

if (BaseContext.get() == null) {

// 没有用户信息，未登录，设置状态码401

response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);

// 拦截

return false;

}

// 有用户信息，已登录，放行

return true;

}

}

改进登出功能

/**

* 登出功能

*/

@PostMapping("/logout")

public Result logout(HttpSession session, HttpServletRequest request) {

// 销毁ThreadLocal中的用户信息

BaseContext.remove();

// 销毁session

session.invalidate();

// 获取请求头中的token

String tokenKey = RedisConstants.LOGIN_USER_KEY_PREFIX + request.getHeader("authorization");

// 判断redis中的tokenKey是否存在

if (Boolean.TRUE.equals(stringRedisTemplate.hasKey(tokenKey))) {

// 使redis中的token失效

stringRedisTemplate.delete(tokenKey);

}

return Result.ok();

}

三、商户查询缓存

什么是缓存？

缓存就是数据交换的缓冲区（称作Cache），是存贮数据的临时地方，一般读写性能较高。

缓存数据存储于代码中，而代码运行在内存中，内存的读写性能远高于磁盘，缓存可以大大降低用户访问并发量带来的服务器读写压力。

但是缓存也会增加代码复杂度和运营的成本：

1、添加商户缓存

当我们根据id查询商户信息时，我们是直接操作从数据库中去进行查询的，所以我们需要增加缓存，

代码思路：如果缓存有，则直接返回，如果缓存不存在，则查询数据库，存入redis之后再返回。

/**

* 根据id查询商铺信息

* @param id 商铺id

* @return 商铺详情数据

*/

@Override

public Result queryById(Long id) {

// 从redis中查询店铺数据

String cacheKey = CACHE_SHOP_KEY_PREFIX + id;

String shopJson = stringRedisTemplate.opsForValue().get(cacheKey);

// 判断缓存是否命中

if (StrUtil.isNotBlank(shopJson)) {

// 缓存命中，直接返回店铺数据

Shop shop = JSONUtil.toBean(shopJson, Shop.class);

return Result.ok(shop);

}

// 缓存未命中，从数据库中查询店铺数据

Shop shop = getById(id);

// 判断数据库是否存在店铺数据

if (shop == null) {

// 数据库中不存在，返回失败信息

return Result.fail("店铺不存在");

}

// 数据库中存在，写入redis，并返回店铺数据

stringRedisTemplate.opsForValue().set(cacheKey, JSONUtil.toJsonStr(shop));

return Result.ok(shop);

}

对于店铺详细这类变化较为频繁的数据，我们是直接存入Redis中，后面还会进行优化，设置合适的缓存更新策略，确保Redis和MySQL的数据一致性，以及解决缓存常见的三大问题。

2、查询店铺类型缓存

对于店铺类型数据，一般变动会比较小，所以这里我们直接将店铺类型的数据持久化存储到Redis中

使用String类型的key-value结构缓存店铺类型数据

String存储写法

/**

* 查询店铺类型列表

* @return 店铺类型列表

*/

@Override

public Result queryTypeList() {

// 从redis中查询店铺类型数据

String shopTypeJson = stringRedisTemplate.opsForValue().get(CACHE_SHOP_TYPE_KEY);

List shopTypeList = null;

// 判断缓存是否命中

if (StrUtil.isNotBlank(shopTypeJson)) {

// 缓存命中，直接返回缓存数据

shopTypeList = JSONUtil.toList(shopTypeJson, ShopType.class);

return Result.ok(shopTypeList);

}

// 缓存未命中，查询数据库

shopTypeList = this.query().orderByAsc("sort").list();

// 判断数据库中是否存在该数据

if (shopTypeList == null) {

// 数据库中不存在该数据，返回失败信息

return Result.fail("店铺类型不存在");

}

// 数据库中的数据存在，写入Redis，并返回查询的数据

stringRedisTemplate.opsForValue().set(CACHE_SHOP_TYPE_KEY, JSONUtil.toJsonStr(shopTypeList), CACHE_SHOP_TYPE_TTL, TimeUnit.MINUTES);

// 将数据库查到的数据返回

return Result.ok(shopTypeList);

}

使用List类型缓存店铺类型数据

List存储写法

/**

* 查询店铺类型列表

* @return 店铺类型列表

*/

@Override

public Result queryTypeList() {

// 从redis中查询店铺类型数据

ListOperations ops = stringRedisTemplate.opsForList();

List shopTypeList;

// 0到-1表示查询List中所有元素

List shopTypeJsonList = ops.range(CACHE_SHOP_TYPE_KEY, 0, -1);

// 判断缓存是否命中

if (CollUtil.isNotEmpty(shopTypeJsonList)) {

// 缓存命中，直接返回缓存数据

shopTypeList = shopTypeJsonList.stream()

// 将 List 转换为 List 返回

.map((shopTypeJson) -> JSONUtil.toBean(shopTypeJson, ShopType.class))

.collect(Collectors.toList());

return Result.ok(shopTypeList);

}

// 缓存未命中，查询数据库

shopTypeList = this.query().orderByAsc("sort").list();

// 判断数据库中是否存在该数据

if (shopTypeList == null) {

// 数据库中不存在该数据，返回失败信息

return Result.fail("店铺类型不存在");

}

// 数据库中的数据存在，写入Redis，并返回查询的数据

ops.rightPushAll(CACHE_SHOP_TYPE_KEY, shopTypeList.stream().map(JSONUtil::toJsonStr).collect(Collectors.toList()));

// 设置key的过期时间

stringRedisTemplate.expire(CACHE_SHOP_TYPE_KEY, CACHE_SHOP_TYPE_TTL, TimeUnit.MINUTES);

// 将数据库查到的数据返回

return Result.ok(shopTypeList);

}

由于在店铺类型ShopType中定义的createTime和updateTime是LocalDateTime类型。如果不自定义配置RedisConfig，那么日期类型存入Redis中会序列化为无意义的数字。

// 创建时间

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")

private LocalDateTime createTime;

// 更新时间

@JsonFormat(pattern="yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")

private LocalDateTime updateTime;

因此我们可以写一个RedisConfig配置类，在里面配置序列化器与反序列化器，这次value和hashValue使用配置好的json对象映射器。下面给出Redis序列化器配置模板：

@Configuration

public class RedisConfig {

@Bean

public RedisTemplate redisTemplate(RedisConnectionFactory connectionFactory) {

// 创建RedisTemplate对象

RedisTemplate template = new RedisTemplate<>();

// 设置redis连接工厂

template.setConnectionFactory(connectionFactory);

// 使用StringRedisSerializer来序列化和反序列化Redis的key值

StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

// 配置对象映射器

Jackson2JsonRedisSerializer