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

pre

springboot - 优雅的实现【流控】

需求

需求描述：

登录错误次数限制：在用户登录时，记录每个账号的登录错误次数，并限制连续错误的次数。
账号锁定机制：当一个账号连续输入错误密码超过5次时，该账号将被锁定15分钟。在15分钟后，账号会自动解锁。
自动解锁功能：账号在连续错误输入超过5次后，将触发锁定机制，并且5分钟后自动解锁，利用redis的键值存储来管理错误次数和锁定时间。
配置文件：登录错误次数的限制（如5次错误）和账号锁定时间（如15分钟）应该能通过配置文件进行设置，以便灵活配置。
自定义注解实现：使用自定义注解来实现登录错误次数限制与账号锁定功能的逻辑。

技术细节：

使用redis的key来存储和管理每个用户的错误登录次数和锁定状态。
自定义注解实现错误次数和锁定时长的判断与控制。
错误次数和锁定时长通过配置文件（如application.yml或application.properties）进行配置，支持灵活调整。

实现步骤

简易实现

1. 添加依赖

首先，在pom.xml中添加必要的依赖：

 <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>

2. 配置文件

在application.yml中配置相关参数：

3. 自定义注解

创建一个自定义注解@loginattemptlimit：

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;
}

4. aop切面

创建一个aop切面来处理登录错误次数的限制和锁定逻辑：

@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;
        }
    }
}

5. 使用自定义注解：

在服务的方法上添加自定义注解

6. 测试

创建一个控制器来处理登录请求

连续错误5次后，

redis中key的ttl

附

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);
    }
}