SpringSecurity下，使用Redis实现验证码验证，用户错误登陆次数限制，锁定/释放用户

落日映苍穹つ 2023-07-11 06:18 54阅读 0赞

### SpringSecurity下，使用Redis实现验证码验证，用户错误登陆次数限制，锁定/释放用户 ###

*   *  写在前面
     *  一、接口设计
     *   *  1.1、验证码接口
         *  1.2、登陆接口
     *  二、验证码验证逻辑
     *   *  2.1、验证码生成，几种生成方式可供参考，\[参考链接\](https://blog.csdn.net/qq\_42105629/article/details/104630283)
         *  2.2、验证码文本，临时存储，基于Redis,有效期 1 分钟
         *  2.3、初次登陆不需要验证码
         *  2.4、验证码错误不计入错误登录次数
     *  三、错误登录控制(5次)（锁定/释放用户）
     *   *  3.1、使用 Redis 临时存储错误次数（10分钟内，记录连续错误次数，最多五次）
         *  3.2、10分钟内，连续登陆错误（用户名/密码错误）5次后，锁定用户 4 小时
         *  3.3、锁定用户，Redis 临时存储 锁定用户记录 4 小时，4h 后自动释放，可重新登陆
     *  四、详细代码如下

## 写在前面 ##

本篇涉及两个场景

*  验证码验证逻辑
 *  错误登录控制（锁定/释放用户）

本篇只是对这两种场景的一种实现，可供参考，还有别的实现方式，可自行学习探索、使用

## 一、接口设计 ##

### 1.1、验证码接口 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTA1NjI5_size_16_color_FFFFFF_t_70]

### 1.2、登陆接口 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTA1NjI5_size_16_color_FFFFFF_t_70 1]

## 二、验证码验证逻辑 ##

### 2.1、验证码生成，几种生成方式可供参考，[参考链接][Link 1] ###

参考中都是写到文件，实际使用时，是请求验证码生成接口，接口响应写到输出流到页面

/** * 生成验证码 */
    @RestController
    public class CaptchaImageController { 
    
        @Autowired
        private StringRedisTemplate stringRedisTemplate;
    
        @GetMapping("/code/image")
        public ResultBean createCode(String captchaId, HttpServletRequest request, HttpServletResponse response) throws IOException { 
    
            if (StringUtil.isNullStr(captchaId)) { 
                return ResultBean.error(CodeEnum.CUSTON_ERROR, "缺少参数");
            }
    
            // 设置大小，以及位数
            SpecCaptcha specCaptcha = new SpecCaptcha(129, 48, 4);
            // 设置字体
            specCaptcha.setFont(new Font("Times New Roman", Font.ITALIC, 34));
            // 设置类型
            specCaptcha.setCharType(Captcha.TYPE_NUM_AND_UPPER);
    
            stringRedisTemplate.opsForValue().set(
                    RedisKeyGen.getCaptcha(captchaId),
                    specCaptcha.text(),
                    60,
                    TimeUnit.SECONDS);
            specCaptcha.out(response.getOutputStream());
            return null;
        }
        
    }

### 2.2、验证码文本，临时存储，基于Redis,有效期 1 分钟 ###

参考生成代码中，存储

stringRedisTemplate.opsForValue().set(
                    RedisKeyGen.getCaptcha(captchaId),
                    specCaptcha.text(),
                    60,
                    TimeUnit.SECONDS);

除了Redis临时存储之外，还有以下方式作为存储

*  使用关系型数据库表作为临时存储，校验功能
 *  使用 Session 临时存储，校验时从 Request 中获取已生成的验证码文本与登录接口传参验证码文本比较

### 2.3、初次登陆不需要验证码 ###

只是当前业务场景

### 2.4、验证码错误不计入错误登录次数 ###

验证码可无限刷新登录，验证码错误不计入错误登录控制 / 锁定

## 三、错误登录控制(5次)（锁定/释放用户） ##

### 3.1、使用 Redis 临时存储错误次数（10分钟内，记录连续错误次数，最多五次） ###

### 3.2、10分钟内，连续登陆错误（用户名/密码错误）5次后，锁定用户 4 小时 ###

### 3.3、锁定用户，Redis 临时存储 锁定用户记录 4 小时，4h 后自动释放，可重新登陆 ###

## 四、详细代码如下 ##

@PostMapping("/login")
        public ResultBean login(
                HttpServletRequest request,
                HttpServletResponse response,
                String username,
                String password,
                String captchaId,
                String captchaCode) { 
            // 验证用户是否被锁定
            String lockUser = stringRedisTemplate.opsForValue().get(RedisKeyGen.getLockUser(username));
            if (!StringUtil.isNullStr(lockUser)) { 
                return ResultBean.error(CodeEnum.USER_LOCKED);
            }
            //在去redis获取登录次数的一个key，有效期10分钟，如果没获取这个key，但是验证码不为空的时候，
            // 直接返回提示，验证码已过期，请刷新浏览器，
            String loginErrTimes = stringRedisTemplate.opsForValue().get(RedisKeyGen.getLoginErr(username));
            if (StringUtil.isNullStr(loginErrTimes) && !StringUtil.isNullStr(captchaCode)) { 
                return ResultBean.error(CodeEnum.CAPTCHA_EXPIRED_ERROR);
            }
    
            Integer loginErrorTime = 0;
            if (!StringUtil.isNullStr(loginErrTimes)) { 
                loginErrorTime = Integer.valueOf(loginErrTimes);
            }
    
            // 如果验证吗为空(缓存刷新，首次登陆)，那不需判断验证吗，否则如果有，必须判断验证吗是否正确
            if (!StringUtil.isNullStr(captchaCode)) { 
                String code = stringRedisTemplate.opsForValue().get(RedisKeyGen.getCaptcha(captchaId));
                if (StringUtil.isNullStr(code)) { 
                    return ResultBean.error(CodeEnum.CAPTCHA_EXPIRED_ERROR);
                }
                if (!captchaCode.equalsIgnoreCase(code)) {  // 忽略大小写
                    return ResultBean.error(CodeEnum.CAPTCHA_ERROR);
                }
            }
    
            // 10分钟内，不可连续用户/密码错误 5 次
            Authentication authentication = null;
            try { 
                UsernamePasswordAuthenticationToken upToken = new UsernamePasswordAuthenticationToken(username, password);
                authentication = authenticationManager.authenticate(upToken);
                SecurityContextHolder.getContext().setAuthentication(authentication);
                String token = jwtTokenProvider.generateToken(username);
                Cookie cookie = new Cookie(HEADER, token);
                cookie.setHttpOnly(true);
                cookie.setPath("/");
                //设置过期时间4小时
                cookie.setMaxAge(4 * 60 * 1000);
                cookie.setSecure(request.isSecure());
                cookie.setDomain(request.getServerName().toLowerCase());
                response.addCookie(cookie);
            } catch (AuthenticationException e) { 
                int i = loginErrorTime + 1;
                stringRedisTemplate.opsForValue().set(RedisKeyGen.getLoginErr(username), String.valueOf(i), 10, TimeUnit.MINUTES);
                if (i == 4) { 
                    return ResultBean.error(CodeEnum.ERROR_FOUR);
                }
                if (i >= 5) { 
                    stringRedisTemplate.opsForValue().set(RedisKeyGen.getLockUser(username), "1", 4, TimeUnit.HOURS);
                    return ResultBean.error(CodeEnum.USER_LOCKED);
                }
    // stringRedisTemplate.delete(Lists.newArrayList(RedisKeyGen.getUserInfo(username), RedisKeyGen.getUserResource(username)));
                return ResultBean.error(CodeEnum.PSAA_ERROR);
            }
            // 登陆成功，删除缓存的锁定用户和错误登陆次数
            stringRedisTemplate.delete(Lists.newArrayList(RedisKeyGen.getLockUser(username), RedisKeyGen.getLoginErr(username)));
            return ResultBean.ok(getLoginVO(username));
        }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTA1NjI5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200304172945977.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTA1NjI5,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTA1NjI5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200304173450307.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyMTA1NjI5,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/qq_42105629/article/details/104630283