SpringBoot实现账号登录错误次数的限制和锁定功能

 <dependencies>
    <!-- Spring Boot Starter Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- Spring Boot Starter Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Boot Starter AOP -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginAttemptLimit {
    // 默认值依赖配置文件，可在此处设定默认值
    int maxAttempts() default 5;
    int lockTime() default 15;
}

@Aspect
@Slf4j
@Component
public class LoginAttemptLimitAspect {
    @Resource
    private LoginAttemptValidator loginAttemptValidator;
    @Resource
    private AdminAuthService authService;
    @Value("${supervision.max-attempts:2}")
    private int maxAttempts;
    @Value("${supervision.lock-time:5}")
    private long lockTime;
    @Around("@annotation(loginAttemptLimit)")
    public Object limitLoginAttempts(ProceedingJoinPoint joinPoint, LoginAttemptLimit loginAttemptLimit) throws Throwable {
        String attemptKey = "";
        String lockKey = "";
        // 根据登录类型获取对应的键
        // # 0 账号密码模式  1 key模式（默认）
        if (authService.getLoginType() == 1) {
            AuthKeyLoginReqVO authKeyLoginReqVO = (AuthKeyLoginReqVO) joinPoint.getArgs()[0];
            attemptKey = RedisKeyConstants.ATTEMP_KEY_PREFIX + authKeyLoginReqVO.getUsername();
            lockKey = RedisKeyConstants.LOCK_KEY_PREFIX + authKeyLoginReqVO.getUsername();
        } else {
            AuthLoginReqVO authLoginReqVO = (AuthLoginReqVO) joinPoint.getArgs()[0];
            attemptKey = RedisKeyConstants.ATTEMP_KEY_PREFIX + authLoginReqVO.getUsername();
            lockKey = RedisKeyConstants.LOCK_KEY_PREFIX + authLoginReqVO.getUsername();
        }
        // 检查账号是否已被锁定
        if (loginAttemptValidator.isLocked(lockKey)) {
            throw new ServiceException(TOO_MANY_REQUESTS.getCode(), "账号被锁定,请稍后重试");
        }
        // 获取登录次数
        int attempts = loginAttemptValidator.getAttempt(attemptKey);
        // 检查登录尝试次数是否超过最大限制
        if (attempts >= maxAttempts) {
            loginAttemptValidator.setLock(lockKey, lockTime);
            loginAttemptValidator.resetAttempt(attemptKey);
            throw new ServiceException(TOO_MANY_REQUESTS.getCode(), "账号被锁定,请稍后重试");
        }
        try {
            // 执行登录操作
            Object result = joinPoint.proceed();
            // 登录成功，重置登录尝试计数
            loginAttemptValidator.resetAttempt(attemptKey);
            return result;
        } catch (Exception e) {
            // 登录失败，增加登录尝试计数
            loginAttemptValidator.incrementAttempt(attemptKey);
            throw e;
        }
    }
}

import cn.hutool.core.util.ObjectUtil;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
@Component
public class LoginAttemptValidator {
    @Resource
    private RedisTemplate<String,Integer> redisTemplate;
    /**
     * 尝试次数自增
     *
     * @param key Redis中的键，用于标识特定的尝试计数
     */
    public void incrementAttempt(String key) {
        redisTemplate.opsForValue().increment(key);
    }
    /**
     * 获取尝试次数
     * 如果给定键的尝试次数在缓存中不存在，则初始化尝试次数为0
     * 此方法主要用于跟踪某些操作的尝试次数，例如登录尝试次数，以防止暴力破解
     *
     * @param key 缓存中的键，通常与特定用户或操作相关联
     * @return 尝试次数如果缓存中没有对应的尝试记录，则返回0
     */
    public int getAttempt(String key) {
        // 从Redis中获取尝试次数
        Integer attempts = redisTemplate.opsForValue().get(key);
        // 如果尝试次数为空，则初始化尝试次数
        if (attempts == null ) initAttempt(key);
        // 返回尝试次数如果为null，则返回0
        return attempts == null ? 0 : attempts;
    }
    /**
     * 初始化尝试次数
     * 该方法用于在Redis中初始化一个键的尝试次数为0
     * 主要用于记录和管理操作的尝试次数，以便进行后续的限制或监控
     *
     * @param key Redis中的键，用于唯一标识一个操作或请求
     */
    public void initAttempt(String key) {
        redisTemplate.opsForValue().set(key, 0);
    }
    /**
     * 重置尝试次数
     * 通过删除Redis中的键来重置特定尝试的计数
     *
     * @param key Redis中用于标识尝试计数的键
     */
    public void resetAttempt(String key) {
        redisTemplate.delete(key);
    }
    /**
     * 设置缓存锁
     *
     * @param key 锁的唯一标识，通常使用业务键作为锁的key
     * @param duration 锁的持有时间，单位为分钟
     *
     * 此方法旨在通过Redis实现分布式锁的功能，通过设置一个具有过期时间的键值对来实现
     * 键值对的key为业务键，值为锁定标志，过期时间由参数duration指定
     */
    public void setLock(String key, long duration) {
        redisTemplate.opsForValue().set(key, RedisKeyConstants.LOCK_FLAG, duration, TimeUnit.MINUTES);
    }
    /**
     * 检查给定键是否处于锁定状态
     *
     * @param key 要检查的键
     * @return 如果键未锁定，则返回false；如果键已锁定，则返回true
     */
    public boolean isLocked(String key) {
        // 从Redis中获取键对应的值
        Integer value = redisTemplate.opsForValue().get(key);
        // 如果值为空，则表明键未锁定，返回false
        if (ObjectUtil.isEmpty(value)) return  false ;
        // 比较键的值是否与锁定标志相等，如果相等则表明键已锁定，返回true
        return RedisKeyConstants.LOCK_FLAG == redisTemplate.opsForValue().get(key);
    }
}