Redis企业实战（黑马点评）

项目整体架构
项目部署
- 后端部署
- 前端部署
短信登陆
- 基于Session实现登录
- 集群的Session共享问题
- 基于Redis实现共享session登录
- 解决状态登录刷新的问题——登录拦截器的优化

本期学习路线

短信登陆:  Redis的共享session应用
商户查询缓存:  企业的缓存使用技巧；缓存雪崩、穿透等问题解决
达人探店:  基于List的点赞列表;基于SortedSet的点赞排行榜
优惠券秒杀:  Redis计数器、Lua脚本Redis;分布式锁;Redis的三种消息队列
好友关注:  基于Set集合的关注、取关、共同关注、消息推送等功能
附近商户功能:  Redis的GeoHash的应用
用户签到:  Redis的BitMap数据统计功能
UV统计:  Redis的HyperLogLog的统计功能

项目整体架构

采用前后端分离部署，前端部署到Nginx服务器中，后端部署到Tomcat服务器中; 移动端/PC端发送请求时，首先向nginx发起页面请求，页面资源通过ajax向服务端发起请求查询数据。将查询到的数据后返回前端，前端再做页面渲染即可。

在这里插入图片描述
项目资源
链接：https://pan.baidu.com/s/11kh42hq6QWFm5PtBvT2MHQ
提取码：GY66

项目部署

后端部署

将模块导入后，修改配置文件（application.yml），启动项目后，在浏览器访问：http://localhost:8081/shop-type/list，若访问数据成功则证明部署成功
在这里插入图片描述

前端部署

运行前端项目，在nginx所在目录下打开一个CMD窗口，输入命令:

start   nginx.exe

在这里插入图片描述

打开浏览器，在空白页面点击鼠标右键，选择检查，打开开发者工具，然后打开手机模式（前端项目模拟手机app形式）；访问：http://localhost:8080，即可看到页面：
在这里插入图片描述

短信登陆

基于Session实现登录

在这里插入图片描述

发送短信验证码

	说明
请求方式	POST
请求路径	/user/code
请求参数	phone:电话号码
返回值	无

    @Override
    public Result sendCode(String phone, HttpSession session) {
        // 1.校验手机号
        if(RegexUtils.isPhoneInvalid(phone)){
            // 2.不符合,返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.符合,生成验证码--->6位随机数
        String code = RandomUtil.randomNumbers(6);
        // 4.保存验证码到session
        session.setAttribute("code",code);
        // 5.发送验证码--->需调用第三方平台,这里记录日志(@Slf4j)模拟发送成功
        log.debug("发送短信验证码成功,验证码：{}",code);
        // 6.返回ok
        return Result.ok();
    }
}

重启服务
在这里插入图片描述

后台接收验证码成功
在这里插入图片描述

短信验证码登录

	说明
请求方式	POST
请求路径	/user/login
请求参数	phone:电话号码; code:验证码
返回值	无

  @Override
    public Result login(LoginFormDTO loginForm,HttpSession session) {
        String phone = loginForm.getPhone();
        // 1.校验手机号
        if(RegexUtils.isPhoneInvalid(phone)){
            // 1.2 不符合,返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 2.校验验证码
        Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();
        if(cacheCode==null|| !cacheCode.toString().equals(code)){
            // 3.不一致,报错
            return Result.fail("验证码错误");
        }
        // 4.一致,根据手机号查询用户
        User user = query().eq("phone", phone).one();
        // 5.判断用户是否存在
        if (user == null) {
            // 6.不存在,创建新用户并保存
           user= createUser(phone);
        }
        // 7. 保存用户信息到session
        session.setAttribute("user",user);
        return Result.ok();
    }
    private User createUser(String phone) {
        // 1.创建用户(电话号，昵称)
        User user=new User(phone, RandomUtil.randomString(5));
        // 2.保存用户
        save(user);
        return user;
    }

为什么采用反向校验?
此种编码校验不需要多层if嵌套，若都为正向验证代码则不够优雅

登录验证功能（登录校验拦截器）
在这里插入图片描述
编写拦截器类

package com.hmdp.utils;


import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

//拦截器
public class LoginInterceptor implements HandlerInterceptor {
    // 前置拦截器--->进入controller之前做登录校验
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    // 1.获取session
        HttpSession session = request.getSession();
    // 2.获取session中的用户       .
        Object user = session.getAttribute("user");
        // 3.判断用户是否存在
        if (user == null) {
            // 4.不存在，拦截, 返回401状态码--->未授权
            response.setStatus(401);
           return false; 
        }
    // 5.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser( user);
    // 6.放行    
        return true;
    }
    // 渲染之后（返回给用户之前）--->销毁用户信息，避免内存泄露
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

拦截器的生效（在config）

package com.hmdp.config;

import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;


@Configuration
public class MvcConfig  implements WebMvcConfigurer {

    // 添加拦截器（实现addInterceptors方法）
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // excludePathPatterns("")-->排除不需要拦截的路径
     registry.addInterceptor(new LoginInterceptor())
             .excludePathPatterns("shop/**",
                                  "shop-type/**",
                                  "upload/**",
                                  "/blog/hot",
                                  "/user/code",
                                  "/user/login");
    }
}

实现controller层登录校验功能

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

重启服务测试
在这里插入图片描述
隐藏用户敏感信息
登录校验功能返回用户id、昵称、头像等信息即可。像时间、密码、电话等敏感信息存在泄露风险，无需返回，

在这里插入图片描述

  // 7.保存用户到session中  (将保存进session中的用户信息修改为UserDTO类型)
        session.setAttribute("user", BeanUtil.copyProperties(user,UserDTO.class));
        return Result.ok();

重启服务查看用户信息，此时避免返回用户敏感信息，也可减少内存的占用（只剩下三个字段）
在这里插入图片描述

集群的Session共享问题

session共享问题：多台Tomcat并不共享session存储空间，当请求切换到不同Tomcat服务时会导致数据丢失的问题。
session的替代方案应该满足：
● 数据共享
● 内存存储
● key、value结构
在这里插入图片描述

基于Redis实现共享session登录

在这里插入图片描述

保存登录的用户信息，可以使用String结构，以JSON字符串来保存，比较直观：

KEY	VALUE
SSS:user:1	{ name:“Jack”,age:21" }
SSS:user:2	{ name:“Rose”,age:18" }

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD，并且内存占用更少：
在这里插入图片描述

业务层实现类

@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {


   @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    // 发送短信验证码
    public Result sendcode(String phone, HttpSession session) {
        //  1. 校验手机号
        if(RegexUtils.isPhoneInvalid(phone)){
            // 2.如果不符合,返回错误信息
            return Result.fail("手机号格式错误!");
        }
        // 3.符合，生成验证码--->6位随机数
        String code = RandomUtil.randomNumbers(6);
        // 4.保存验证码到 Redis 并且设置有效期（给KEY添加一个业务前缀加以区分，防止与其他业务的KEY产生冲突，KEY也具有层次感）

        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone,code,RedisConstants.LOGIN_CODE_TTL, TimeUnit.MINUTES);

        // 5.发送验证码--->记录日志,模拟发送成功
        log.debug("发送短信验证码成功,验证码{}",code);
        // 返回ok
        return  Result.ok();
    }
    // 短信验证码登录、注册
    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        String phone = loginForm.getPhone();
        // 1.校验手机号
        if(RegexUtils.isPhoneInvalid(phone)){
            // 1.2 如果不符合,返回错误信息
            return Result.fail("手机号格式错误!");
        }
        // 2. 从Redis中获取验证码并校验
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        String code = loginForm.getCode();
        if (cacheCode==null||!cacheCode.equals(code)){
            // 3.不一致,报错
            return Result.fail("验证码错误");
        }
        // 4.一致,根据手机号查询用户
        User user=query().eq("phone",phone).one();
        // 5.判断用户是否存在
        if(user==null){
            // 6.不存在,创建新用户并保存
         user=createUser(phone);
        }

        /* 7.保存用户信息到Redis中 (用Hash结构存储)*/
        // 7.1 随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2 将User对象转为Hash存储
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(),
                CopyOptions.create().setIgnoreNullValue(true).setFieldValueEditor((fieldName,fieldValue)->fieldValue.toString()));
        // 7.3 存储
        stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY+token,userMap);
        // 7.4 设置token有效期  (若登录后不做任何操作,30分钟后中从内存中清除--->避免内存占用过多)
        stringRedisTemplate.expire(LOGIN_USER_KEY+token,LOGIN_USER_TTL,TimeUnit.MINUTES);

        // 8 返回token
        return Result.ok(token);
    }

    private User createUser(String phone) {
        // 1.创建用户
        User user=new User(phone,"GY_"+RandomUtil.randomString(4));
        // 2.保存用户
        save(user);
        return user;
    }
}

登录拦截器类

//拦截器
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 {
    // 1. 获取请求头中的token
        String token = request.getHeader("authorization");
        if(StrUtil.isBlank(token)){
            // 不存在，拦截, 返回401状态码--->未授权
            response.setStatus(401);
        }
        // 2. 基于token获取Redis中的用户       .
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(RedisConstants.LOGIN_USER_KEY + token);
        // 3.判断用户是否存在
        if (userMap.isEmpty()) {
            // 4.不存在，拦截, 返回401状态码--->未授权
            response.setStatus(401);
           return false;
        }
    // 5. 将查询到的Hash数据转换为UserDTO对象    【islgnoreError:是否忽略转换过程中的错误】
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6. 存在，保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
    // 7. 刷新token有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
    // 8.放行
        return true;
    }
    // 渲染之后（返回给用户之前）--->销毁用户信息，避免内存泄露
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

拦截器实现类

@Configuration
public class MvcConfig  implements WebMvcConfigurer {

   @Resource
    private StringRedisTemplate stringRedisTemplate;

    // 添加拦截器（实现addInterceptors方法）
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // excludePathPatterns("")-->排除不需要拦截的路径
     registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
             .excludePathPatterns("shop/**",
                                  "shop-type/**",
                                  "upload/**",
                                  "/blog/hot",
                                  "/user/code",
                                  "/user/login");
    }
}

登录成功！！！
在这里插入图片描述

解决状态登录刷新的问题——登录拦截器的优化

在这里插入图片描述

token刷新拦截器类
刷新token有效期，并将用户保存到ThreadLocal

// token刷新拦截器
public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    // 前置拦截器--->进入controller之前做登录校验
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    // 1. 获取请求头中的token
        String token = request.getHeader("authorization");
        if(StrUtil.isBlank(token)){
           return true;
        }
        // 2. 基于token获取Redis中的用户       .
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(RedisConstants.LOGIN_USER_KEY + token);
        // 3.判断用户是否存在
        if (userMap.isEmpty()) {
            return true;
        }
    // 5. 将查询到的Hash数据转换为UserDTO对象    【islgnoreError:是否忽略转换过程中的错误】
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6. 存在，保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
    // 7. 刷新token有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
    // 8.放行
        return true;
    }
}

登录拦截器
从RefreshTokenInterceptor拦截器保存的ThreadLocal中查询用户

// 登录拦截器
public class LoginInterceptor implements HandlerInterceptor {


    // 前置拦截器--->进入controller之前做登录校验
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.判断是否需要拦截（ThreadLocal中是否有用户）
        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) {
        // excludePathPatterns("")-->排除不需要拦截的路径
     registry.addInterceptor(new LoginInterceptor())
             .excludePathPatterns("shop/**",
                                  "shop-type/**",
                                  "upload/**",
                                  "/blog/hot",
                                  "/user/code",
                                  "/user/login").order(1);
     // token刷新拦截器（默认拦截所有请求）
     registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);
    }
}