登录验证登录次数失败过多进行设置延时

现象结果示例截图

swagger示例效果

控制台示例效果

后端代码示例

package com.java.javamethod.service.impl;

import com.java.javamethod.dao.UserMapper;
import com.java.javamethod.domain.Result;
import com.java.javamethod.domain.User;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * @Author ww
 * @Date 2024/4/29 15:53
 * @Version 1.0
 */
@Service("loginService")
@Slf4j
public class LoginServiceImpl implements LoginService {

    @Resource
    private UserMapper userMapper;

    @Resource
    private RedisTemplate<String, Integer> redisTemplate;

    private static final String FAIL_COUNTER = "user_login_fail_counter";

    private static final String FAIL_LOCK = "user_login_fail_lock";


    /**
     * 登录失败计数器
     *
     * @param username
     */
    public void setCheckFailCounter(String username) {
        String key = String.join(":", FAIL_COUNTER, username);
        Integer count = redisTemplate.opsForValue().get(key);
        redisTemplate.opsForValue().increment(key);
        if (count == null) {
            //第一次操作设置过期时间，在没有达到5次之后，十分钟重新计时计算，只计算当前十分钟之内的登录次数
            redisTemplate.expire(key, 10, TimeUnit.MINUTES);
        }
        if (count!=null&&count.intValue() > 5) {
            // 失败达到五次 设置锁定缓存
            lock(username);
        }
    }

    /**
     * 移除计数器
     *
     * @param username
     */
    public void deleteLoginFailCounter(String username) {
        redisTemplate.delete(String.join(":", FAIL_COUNTER, username));
    }


    /**
     * 失败达到一定一定次数 锁定30分钟
     *
     * @param username
     */
    public void lock(String username) {
        String key = String.join(":", FAIL_LOCK, username);
        redisTemplate.opsForValue().set(key, 1, 30, TimeUnit.MINUTES);
    }

    /**
     * 是否被登录锁定
     *
     * @param username
     * @return
     */
    public boolean isLock(String username) {
        return redisTemplate.hasKey(String.join(":", FAIL_LOCK, username));
    }

    /**
     * 获取解锁的时间
     *
     * @param username
     * @return
     */
    public long unlockTime(String username) {
        String key = String.join(":", FAIL_LOCK, username);
        return redisTemplate.opsForValue().getOperations().getExpire(key, TimeUnit.MINUTES);
    }

    /**
     * 验证登录
     *
     * @param username
     * @param password
     * @return
     */
    public Result loginCheck(String username, String password) {

        User user = userMapper.queryByName(username);
        Integer passwordStr = redisTemplate.opsForValue().get(username);
        if (password.equals(passwordStr)) {
            return Result.success();
        } else {
            if (user != null) {
                if (user.getPassword().equals(password)) {
                    redisTemplate.opsForValue().set(username, Integer.valueOf(password));
                    return Result.success().setErrmsg("用户名密码正确登录成功");
                } else {
                    log.error("===========用户名密码对应错误{}==========", "密码错误");
                    return Result.failed();
                }
            } else {
                log.error("========用户名密码对应错误{}=========", "用户名错误");
                return Result.failed();
            }
        }
    }

    @Override
    public Result login(String username, String password) {
        // 1.验证用户是否被登录锁定
        boolean lock = isLock(username);
        if (lock) {
            // 获取过期时间
            long outtime = unlockTime(username);
            return new Result().setSuccess(false).setErrmsg("账号已经被锁定，请于"+outtime+"分钟后解锁");
        }
        Result result = loginCheck(username, password);
        if (!result.isSuccess()) {
            setCheckFailCounter(username);
            return new Result();
        }
        // 登录成功 移除失败计数器
        deleteLoginFailCounter(username);
        return new Result();
    }


}