<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 {
    // 默認(rèn)值依賴配置文件，可在此處設(shè)定默認(rèn)值
    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 = "";
        // 根據(jù)登錄類型獲取對(duì)應(yīng)的鍵
        // # 0 賬號(hào)密碼模式  1 key模式（默認(rèn)）
        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();
        }
        // 檢查賬號(hào)是否已被鎖定
        if (loginAttemptValidator.isLocked(lockKey)) {
            throw new ServiceException(TOO_MANY_REQUESTS.getCode(), "賬號(hào)被鎖定,請稍后重試");
        }
        // 獲取登錄次數(shù)
        int attempts = loginAttemptValidator.getAttempt(attemptKey);
        // 檢查登錄嘗試次數(shù)是否超過最大限制
        if (attempts >= maxAttempts) {
            loginAttemptValidator.setLock(lockKey, lockTime);
            loginAttemptValidator.resetAttempt(attemptKey);
            throw new ServiceException(TOO_MANY_REQUESTS.getCode(), "賬號(hào)被鎖定,請稍后重試");
        }
        try {
            // 執(zhí)行登錄操作
            Object result = joinPoint.proceed();
            // 登錄成功，重置登錄嘗試計(jì)數(shù)
            loginAttemptValidator.resetAttempt(attemptKey);
            return result;
        } catch (Exception e) {
            // 登錄失敗，增加登錄嘗試計(jì)數(shù)
            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;
    /**
     * 嘗試次數(shù)自增
     *
     * @param key Redis中的鍵，用于標(biāo)識(shí)特定的嘗試計(jì)數(shù)
     */
    public void incrementAttempt(String key) {
        redisTemplate.opsForValue().increment(key);
    }
    /**
     * 獲取嘗試次數(shù)
     * 如果給定鍵的嘗試次數(shù)在緩存中不存在，則初始化嘗試次數(shù)為0
     * 此方法主要用于跟蹤某些操作的嘗試次數(shù)，例如登錄嘗試次數(shù)，以防止暴力破解
     *
     * @param key 緩存中的鍵，通常與特定用戶或操作相關(guān)聯(lián)
     * @return 嘗試次數(shù)如果緩存中沒有對(duì)應(yīng)的嘗試記錄，則返回0
     */
    public int getAttempt(String key) {
        // 從Redis中獲取嘗試次數(shù)
        Integer attempts = redisTemplate.opsForValue().get(key);
        // 如果嘗試次數(shù)為空，則初始化嘗試次數(shù)
        if (attempts == null ) initAttempt(key);
        // 返回嘗試次數(shù)如果為null，則返回0
        return attempts == null ? 0 : attempts;
    }
    /**
     * 初始化嘗試次數(shù)
     * 該方法用于在Redis中初始化一個(gè)鍵的嘗試次數(shù)為0
     * 主要用于記錄和管理操作的嘗試次數(shù)，以便進(jìn)行后續(xù)的限制或監(jiān)控
     *
     * @param key Redis中的鍵，用于唯一標(biāo)識(shí)一個(gè)操作或請求
     */
    public void initAttempt(String key) {
        redisTemplate.opsForValue().set(key, 0);
    }
    /**
     * 重置嘗試次數(shù)
     * 通過刪除Redis中的鍵來重置特定嘗試的計(jì)數(shù)
     *
     * @param key Redis中用于標(biāo)識(shí)嘗試計(jì)數(shù)的鍵
     */
    public void resetAttempt(String key) {
        redisTemplate.delete(key);
    }
    /**
     * 設(shè)置緩存鎖
     *
     * @param key 鎖的唯一標(biāo)識(shí)，通常使用業(yè)務(wù)鍵作為鎖的key
     * @param duration 鎖的持有時(shí)間，單位為分鐘
     *
     * 此方法旨在通過Redis實(shí)現(xiàn)分布式鎖的功能，通過設(shè)置一個(gè)具有過期時(shí)間的鍵值對(duì)來實(shí)現(xiàn)
     * 鍵值對(duì)的key為業(yè)務(wù)鍵，值為鎖定標(biāo)志，過期時(shí)間由參數(shù)duration指定
     */
    public void setLock(String key, long duration) {
        redisTemplate.opsForValue().set(key, RedisKeyConstants.LOCK_FLAG, duration, TimeUnit.MINUTES);
    }
    /**
     * 檢查給定鍵是否處于鎖定狀態(tài)
     *
     * @param key 要檢查的鍵
     * @return 如果鍵未鎖定，則返回false；如果鍵已鎖定，則返回true
     */
    public boolean isLocked(String key) {
        // 從Redis中獲取鍵對(duì)應(yīng)的值
        Integer value = redisTemplate.opsForValue().get(key);
        // 如果值為空，則表明鍵未鎖定，返回false
        if (ObjectUtil.isEmpty(value)) return  false ;
        // 比較鍵的值是否與鎖定標(biāo)志相等，如果相等則表明鍵已鎖定，返回true
        return RedisKeyConstants.LOCK_FLAG == redisTemplate.opsForValue().get(key);
    }
}