Redis实现短信登录设计

项目搭建

前期准备

导入SQL

CREATE TABLE `tb_user` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `phone` varchar(11) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '手机号码',
  `password` varchar(128) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT '' COMMENT '密码,加密存储',
  `nick_name` varchar(32) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT '' COMMENT '昵称,默认是用户id',
  `icon` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT '' COMMENT '人物头像',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `uniqe_key_phone` (`phone`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1011 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=COMPACT;

创建项目

导入依赖


    
        org.springframework.boot
        spring-boot-starter-web
    
   
        org.springframework.boot
        spring-boot-starter-test
        test
    
        
        com.baomidou
        mybatis-plus-boot-starter
        3.4.3
    
    
        mysql
        mysql-connector-java
        runtime
        8.0.33
    
    
    
        org.projectlombok
        lombok
        true
    

    
    
        cn.hutool
        hutool-all
        5.7.17
    

编写启动类

@MapperScan("com.liang.mapper")
@SpringBootApplication
public class HmDianPingApplication {

    public static void main(String[] args) {
        SpringApplication.run(HmDianPingApplication.class, args);
    }

}

编写配置文件

server:
  port: 8081
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: #配置自己的数据库url
    username: #配置自己的数据库用户名
    password: #配置自己的密码

编写实体类

/**
 * 登录信息
 */
@Data
public class LoginFormDTO {
    private String phone;
    private String code;

}

/**
 * 统一结果返回
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result {
    private Boolean success;
    private String errorMsg;
    private Object data;
    private Long total;

    public static Result ok(){
        return new Result(true, null, null, null);
    }
    public static Result ok(Object data){
        return new Result(true, null, data, null);
    }
    public static Result ok(List data, Long total){
        return new Result(true, null, data, total);
    }
    public static Result fail(String errorMsg){
        return new Result(false, errorMsg, null, null);
    }
}

/**
 * User实体类 对应数据库表tb_user
 */
@Data
@TableName("tb_user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 手机号码
     */
    private String phone;

    /**
     * 密码,加密存储
     */
    private String password;

    /**
     * 昵称,默认是随机字符
     */
    private String nickName;

    /**
     * 用户头像
     */
    private String icon = "";

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
}

/**
 * 存储用户非敏感信息
 */
@Data
public class UserDTO {
    private Long id;
    private String nickName;
    private String icon;
}

编写controller层

/**
 * User对象前端控制器
 */
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    @Resource
    private IUserService userService;

    /**
     * 发送手机验证码
     * @param phone 手机号
     * @param session
     * @return
     */
    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
        return userService.sendCode(phone, session)?Result.ok():Result.fail("手机号码不合规");
    }

    /**
     *  登录功能
     * @param loginForm
     * @param session
     * @return
     */
    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
        return userService.login(loginForm, session) ? Result.ok() : Result.fail("手机号或验证码错误");
    }

编写service层

public interface IUserService extends IService {

    boolean sendCode(String phone, HttpSession session);

    boolean login(LoginFormDTO loginForm, HttpSession session);
}

@Service
public class UserServiceImpl extends ServiceImpl implements IUserService {

    @Override
    public boolean sendCode(String phone, HttpSession session) {
     
        return true;
    }

    @Override
    public boolean login(LoginFormDTO loginForm, HttpSession session) {
   
        return true;
    }
}

Session实现登录

基于session实现登录流程

  • 发送验证码
    • 校验手机号是否合法
      • 合法,生成验证码,并保存到session中、发送验证码给用户
      • 不合法,提示用户手机号不合法

Redis实现短信登录设计_第1张图片

@Override
public boolean sendCode(String phone, HttpSession session) {
        //获取手机号,验证手机号是否合规
        boolean mobile = PhoneUtil.isMobile(phone);
        //不合规,则提示
        if (!mobile){
            return false;
        }
        //生成验证码
        String code = RandomUtil.randomNumbers(6);
        //将验证码保存到session中
        session.setAttribute("code",code);
        //发送验证码
        System.out.println("验证码:" + code);
        return true;
}

验证码登录、注册

  • 验证手机号是否合法,验证验证码是否正确
    • 手机号不合法或验证码不正确,提示用户
  • 验证成功后,查看该用户信息是否在数据库中
    • 该用户信息在数据库中,则表明该用户是登录
      • 用户信息保存到session中
    • 该用户信息不在数据库中,则表明该用户是注册
      • 在数据库中存储用户信息
      • 用户信息保存到session中

(将用户信息存储在session中,主要是方便后序获取当前登录信息)

Redis实现短信登录设计_第2张图片

@Override
 public boolean login(LoginFormDTO loginForm, HttpSession session) {
        //获取手机号
        String phone = loginForm.getPhone();
        //验证手机号是否合理
        boolean mobile = PhoneUtil.isMobile(phone);
        //如果不合理 提示
        if (!mobile){
            //提示用户手机号不合理
            return false;
        }
        //手机号合理 进行验证码验证
        String code = loginForm.getCode();
        String sessionCode = session.getAttribute("code").toString();
        //如果验证码输入的是错误的  提示
        if (!code.equals(sessionCode)){
            return false;
        }
        //如果验证码也正确 那么通过手机号进行查询
        User user = this.getOne(new LambdaQueryWrapper().eq(User::getPhone, phone));
        // 数据库中没查询到用户信息
        if (ObjectUtil.isNull(user)){
            user = new User();
            user.setPhone(phone);
            user.setNickName("user_"+ RandomUtil.randomString(10));
            this.save(user);
        }
        // 将该用户信息存入session中
        // 简化user,只存储必要信息以及不重要的信息
        UserDTO userDTO = BeanUtil.toBean(user, UserDTO.class);
        session.setAttribute("user", userDTO);
        return true;
 }

校验登录状态

  • 用户发送请求时,会从cookie中携带JsessionId到后台,后台通过JsessionId从session中获取用户信息,
    • 没获取到用户信息 则拦截,需要拦截器
    • 获取到用户信息,则将用户信息保存到ThreadLocal中,再放行

Redis实现短信登录设计_第3张图片

  • 自定义拦截器,实现HandlerInterceptor接口

    public class LoginInterceptor implements HandlerInterceptor {

     /**
      * preHandle方法的返回值决定是否放行,该方法在控制层方法执行前执行
      * @param request
      * @param response
      * @param handler
      * @return
      * @throws Exception
      */
     @Override
     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
         HttpSession session = request.getSession();
         UserDTO user = (UserDTO) session.getAttribute("user");
         //判断是否在session中获取到了用户
         if (ObjectUtil.isNull(user)){
             return false;
         }
         UserHolder.saveUser(user);
         return true;
     }
    
     /**
      * postHandle方法在控制层方法执行后,视图解析前执行(可以在这里修改控制层返回的视图和模型)
      * @param request
      * @param response
      * @param handler
      * @param modelAndView
      * @throws Exception
      */
     @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
         HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
     }
    
     /**
      * fterCompletion方法在视图解析完成后执行,多用于释放资源
      * @param request
      * @param response
      * @param handler
      * @param ex
      * @throws Exception
      */
     @Override
     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
         HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
     }
    

    }

  • 实现WebMvcConfigurer接口,通过重写addInterceptors方法添加自定义拦截器

    @Configuration
    public class MvcConfig implements WebMvcConfigurer {

     /**
      * 添加拦截器
      * @param registry
      */
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
         //添加拦截器
         registry.addInterceptor(new LoginInterceptor())
                 //放行资源
                 .excludePathPatterns(
                         "/shop/**",
                         "/voucher/**",
                         "/shop-type/**",
                         "/upload/**",
                         "/blog/hot",
                         "/user/code",
                         "/user/login"
                 )
                 // 设置拦截器优先级
                 .order(1);
     }
    

    }

注意隐藏用户敏感信息:
我们应当在返回用户信息之前,将用户敏感信息进行隐藏,采用的核心思路就是创建UserDTO类,该类没有用户敏感信息,在返回用户信息之前,将有用户敏感新的的User对象转换为没有敏感信息的UserDTO对象,就可以有效的避免用户信息被泄露的问题。

Session存在问题

  • 当单个tomcat服务器时,服务器崩溃,无法提供足够的处理能力时,系统可能不能使用,为了避免这些情况,提高系统的可用性、可伸缩性等,tomcat将会以集群的形式部署,集群部署的主要优势有:高可用性、可伸缩性、负载均衡、无中断升级。
  • 集群部署的tomcat又面临新的问题,即session共享问题,由于每个tomcat都有一份属于自己的session,某个用户第一次访问tomcat时,把自己的信息存放到了编号01的tomcat服务器的session中,当第二次访问时,没有访问01服务器,而是访问到了其他tomcat服务器,而其他tomcat服务器没有该用户存放的session,此时整个登录拦截都会出现问题。
    • 解决方式:
      • 早期方案是session拷贝,即每当任意一台服务器的session修改时,都会同步到其他的tomcat服务器的session中,实现session共享。但此方式存在问题:1、session数据拷贝时,可能会出现延时;2、每台服务器中都有完整的一份session数据,服务器压力较大
      • 现在方案是基于redis来完成,即把session换成redis,redis数据本身就是共享的,可以避免session共享问题。而且redis中数据是 key-value方式存储 和session一样便于操作,且都默认 存储在内存 中,响应速度快。

Redis实现短信登录设计_第4张图片

客户端发送请求,通过nginx负载均衡到下游的tomcat服务器(一台4核8G的tomcat服务器,在优化和处理简单业务的加持下,处理的并发量很有限),经过nginx负载均衡分流后,利用集群支撑整个项目,同时nginx在部署了前端项目后,做到了动静分离,进一步降低tomcat的压力,如果让tomcat直接访问mysql,一般16、32核CPU、32/64G内存,并发量在4k~7K左右,在高并发场景下也是容易崩溃,所有一般会使用mysql集群,同时为了进一步降低mysql压力,增加访问性能,一般会加入redis集群,以提供更好地服务。

Redis代替Session

  • redis中设计key
    • 在使用session时,每个用户都会有自己的session,这样虽然验证码的键都是“code”,但是相互不影响,从而确保每个用户获取到的验证码只能够自己使用,当使用redis时,redis的key是共享的,不分用户,就要求在redis中存储验证码时,不能直接将验证码的键设置为"code",这样无法保证其唯一性。
  • redis中设计value
    • String结构:以Json字符串来存储,比较直观
    • Hash结构:,每个对象中每个字段独立存储,可以针对单个字段做CRUD
    • 到底该使用redis中什么数据类型存储数据,主要需要看数据样式和使用方式,一般会考虑使用String、Hash,String存储时,会多占一点内存空间,则相对来说Hash存储时,会少占用一点内存空间。

Redis实现登录

发送验证码

Redis实现短信登录设计_第5张图片

添加Redis


    org.springframework.boot
    spring-boot-starter-data-redis

设置Redis的连接信息

spring:
  redis:
    host: 192.168.175.128
    port: 6379
    password: liang
    lettuce:
      pool:
        max-active: 10
        max-idle: 10
        min-idle: 1
        time-between-eviction-runs: 10s

增加相关常量

/**
 * 保存验证码的redis中的key
 */
public static final String LOGIN_CODE_KEY = "login:code:";
/**
 * 验证码的过期时间
 */
public static final Long LOGIN_CODE_TTL = 2L;

修改Service层

@Autowired
StringRedisTemplate stringRedisTemplate;

@Override
public boolean sendCode(String phone, HttpSession session) {
    //获取手机号,验证手机号是否合规
    boolean mobile = PhoneUtil.isMobile(phone);
    //不合规,则提示
    if (!mobile){
        return false;
    }
    //生成验证码
    String code = RandomUtil.randomNumbers(6);
    //保存验证码到redis,并设置过期时间
    stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);
    //发送验证码,这里就通过打印验证码模拟了下发送验证码
    System.out.println("验证码:" + code);
    return true;
}

修改Controller层

@PostMapping("code")
public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
    String uuid = userService.sendCode(phone, session);
    return uuid.equals("") ? Result.fail("手机号码不合规"): Result.ok(uuid);
}

验证码登录、注册

Redis实现短信登录设计_第6张图片

增加相关常量

public static final String LOGIN_USER_KEY = "login:token:";
public static final Long LOGIN_USER_TTL = 30L;

修改Service层

@Override
public String login(LoginFormDTO loginForm, HttpSession session) {
    //获取手机号
    String phone = loginForm.getPhone();
    //验证手机号是否合理
    boolean mobile = PhoneUtil.isMobile(phone);
    //如果不合理 提示
    if (!mobile){
        //提示用户手机号不合理
        return "";
    }
    //手机号合理 进行验证码验证
    String code = loginForm.getCode();
    //从redis中获取验证码
    String redisCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    //如果验证码输入的是错误的  提示
    if (!code.equals(redisCode)){
        return "";
    }
    //如果验证码也正确 那么通过手机号进行查询
    User user = this.getOne(new LambdaQueryWrapper().eq(User::getPhone, phone));
    // 数据库中没查询到用户信息
    if (ObjectUtil.isNull(user)){
        user = new User();
        user.setPhone(phone);
        user.setNickName("user_"+ RandomUtil.randomString(10));
        this.save(user);
    }
    // 将用户信息保存到Redis中,注意避免保存用户敏感信息
    UserDTO userDTO = BeanUtil.toBean(user, UserDTO.class);
    // 设置UUID保存用户信息
    String uuid = IdUtil.fastSimpleUUID();
    // 将user对象转化为Map,同时将Map中的值存储为String类型的
    Map userDTOMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
            CopyOptions.create().ignoreNullValue()
                    .setFieldValueEditor((key, value) -> value.toString()));
    stringRedisTemplate.opsForHash().putAll( LOGIN_USER_KEY + uuid, userDTOMap);
    //设置过期时间
    stringRedisTemplate.expire(LOGIN_USER_KEY + uuid, LOGIN_USER_TTL, TimeUnit.MINUTES);
    // 通过UUID生成简单的token
    String token = uuid + userDTO.getId();
    return token;
}

修改Controller层

@PostMapping("/login")
public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
    String token = userService.login(loginForm, session);
    return StrUtil.isNotBlank(token) ? Result.ok(token) : Result.fail("手机号或验证码错误");
}

校验登录状态

Redis实现短信登录设计_第7张图片

修改LoginInterceptor拦截器

private StringRedisTemplate stringRedisTemplate;

/**
 * 构造函数
 * @param stringRedisTemplate
 */
public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
    this.stringRedisTemplate = stringRedisTemplate;
}

/**
 * preHandle方法的返回值决定是否放行,该方法在控制层方法执行前执行
 * @param request
 * @param response
 * @param handler
 * @return
 * @throws Exception
 */
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //从请求头中获取token
    String token = request.getHeader("authorization");
    if (StrUtil.isBlank(token)){
        return false;
    }

    String uuid = token.substring(0,token.lastIndexOf("-"));
    System.out.println(uuid);
    //从redis中获取值
    Map entries = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + uuid);
    if (ObjectUtil.isNull(entries)){
        return false;
    }
    //将map转化为UserDTO对象
    UserDTO userDTO = BeanUtil.fillBeanWithMap(entries, new UserDTO(), true);
    //将用户信息保存到 ThreadLocal
    UserHolder.saveUser(userDTO);
    return true;
}


@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    StringRedisTemplate stringRedisTemplate;

    /**
     * 添加拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加拦截器
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
                //放行资源
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                )
                // 设置拦截器优先级
                .order(1);
    }
}

登录状态的刷新问题

因为设置了redis中存储的用户的有效期,所以在用户访问界面的时,需要更新token令牌的存活时间,例如修改LoginInterceptor拦截器,在此拦截器中刷新过期时间

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //从请求头中获取token
    String token = request.getHeader("authorization");
    if (StrUtil.isBlank(token)){
        return false;
    }

    String uuid = token.substring(0,token.lastIndexOf("-"));
    System.out.println(uuid);
    //从redis中获取值
    Map entries = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + uuid);
    if (ObjectUtil.isNull(entries)){
        return false;
    }
    //将map转化为UserDTO对象
    UserDTO userDTO = BeanUtil.fillBeanWithMap(entries, new UserDTO(), true);
    //将用户信息保存到 ThreadLocal
    UserHolder.saveUser(userDTO);
    //刷新token有效期
    stringRedisTemplate.expire(LOGIN_USER_KEY + uuid, LOGIN_USER_TTL, TimeUnit.MINUTES);
    return true;
}

但是需要注意的是,自定义的登录拦截器只是针对需要登录访问的请求进行了拦截,如果用户访问没被拦截的请求,该拦截器不会生效,则token令牌不能进行更新,当用户长时间访问不需要登录的页面,token令牌失效,再去访问被拦截的请求,则需要重新登录,这是不合理的。所有我们还需要在定义一个拦截器,进行token令牌刷新。

Redis实现短信登录设计_第8张图片

刷新令牌的Interceptor

/**
 * 刷新令牌的拦截器
 * @author liang
 */
public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate redisTemplate;

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

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

        //从请求头中获取token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)){
            return false;
        }
        String uuid = token.substring(0, token.lastIndexOf("-"));
        //从Redis中获取值
        Map userMap = redisTemplate.opsForHash().entries(LOGIN_USER_KEY + uuid);
        if (ObjectUtil.isNull(userMap)){
            return false;
        }
        //将map转换为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //将用户信息保存到 ThreadLocal
        UserHolder.saveUser(userDTO);
        //刷新token有效期
        redisTemplate.expire(LOGIN_USER_KEY + uuid, LOGIN_USER_TTL, TimeUnit.MINUTES);
        return true;

    }

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

修改登录的Interceptor

public class LoginInterceptor implements HandlerInterceptor {

    /**
     * preHandle方法的返回值决定是否放行,该方法在控制层方法执行前执行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        UserDTO user = UserHolder.getUser();
        return ObjectUtil.isNotNull(user);
    }
}    

修改WebMvcConfigurer配置类

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    StringRedisTemplate stringRedisTemplate;

    /**
     * 添加拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate));
        registry.addInterceptor(new LoginInterceptor())
                //放行资源
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                )
                // 设置拦截器优先级
                .order(1);
    }
}

你可能感兴趣的:(redis,数据库,缓存)