package com.yang.prevent;
 
import java.lang.annotation.*;
 
/**
 * 接口防刷注解
 */
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Prevent {
 
    /**
     * 限制的時間值（秒）默認60s
     */
    long value() default 60;

    /**
     * 限制規(guī)定時間內訪問次數，默認只能訪問一次
     */
    long times() default 1;
 
    /**
     * 提示
     */
    String message() default "";
 
    /**
     * 策略
     */
    PreventStrategy strategy() default PreventStrategy.DEFAULT;
}

package com.yang.prevent;

/**
 * 防刷策略枚舉
 */
public enum PreventStrategy {

    /**
     * 默認(60s內不允許再次請求）
     */
    DEFAULT
}

package com.yang.prevent;

import com.yang.common.StatusCode;
import com.yang.constant.redis.RedisKey;
import com.yang.exception.BusinessException;
import com.yang.utils.IpUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * 防刷切面實現類
 */
@Aspect
@Component
public class PreventAop {

    @Resource
    private RedisTemplate<String, Long> redisTemplate;


    /**
     * 切入點
     */
    @Pointcut("@annotation(com.yang.prevent.Prevent)")
    public void pointcut() {}


    /**
     * 處理前
     */
    @Before("pointcut()")
    public void joinPoint(JoinPoint joinPoint) throws Exception {
        // 獲取調用者ip
        RequestAttributes requestAttributes = RequestContextHolder.currentRequestAttributes();
        HttpServletRequest httpServletRequest = ((ServletRequestAttributes) requestAttributes).getRequest();
        String userIP = IpUtils.getUserIP(httpServletRequest);
        // 獲取調用接口方法名
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = joinPoint.getTarget().getClass().getMethod(
                methodSignature.getName(),
                methodSignature.getParameterTypes()); // 獲取該接口方法
        String methodFullName = method.getDeclaringClass().getName() + method.getName(); // 獲取到方法名
        Prevent preventAnnotation = method.getAnnotation(Prevent.class); // 獲取該接口上的prevent注解（為了使用該注解內的參數）
        // 執(zhí)行對應策略
        entrance(preventAnnotation, userIP, methodFullName);
    }


    /**
     * 通過prevent注冊判斷執(zhí)行策略
     * @param prevent 該接口的prevent注解對象
     * @param userIP 訪問該接口的用戶ip
     * @param methodFullName 該接口方法名
     */
    private void entrance(Prevent prevent, String userIP, String methodFullName) throws Exception {
        PreventStrategy strategy = prevent.strategy(); // 獲取校驗策略
        if (Objects.requireNonNull(strategy) == PreventStrategy.DEFAULT) { // 默認就是default策略，執(zhí)行default策略方法
            defaultHandle(userIP, prevent, methodFullName);
        } else {
            throw new BusinessException(StatusCode.FORBIDDEN, "無效的策略");
        }
    }


    /**
     * Default測試執(zhí)行方法
     * @param userIP 訪問該接口的用戶ip
     * @param prevent 該接口的prevent注解對象
     * @param methodFullName 該接口方法名
     */
    private void defaultHandle(String userIP, Prevent prevent, String methodFullName) throws Exception {
        String base64StrIP = toBase64String(userIP); // 加密用戶ip（避免ip存在一些特殊字符作為redis的key不合法）
        long expire = prevent.value(); // 獲取訪問限制時間
        long times = prevent.times(); // 獲取訪問限制次數
        // 限制特定時間內訪問特定次數
        long count = redisTemplate.opsForValue().increment(
                RedisKey.PREVENT_METHOD_NAME + base64StrIP + ":" + methodFullName, 1); // 訪問次數+1
        if (count == 1) { // 如果訪問次數為1，則重置訪問限制時間（即redis超時時間）
            redisTemplate.expire(
                    RedisKey.PREVENT_METHOD_NAME + base64StrIP + ":" + methodFullName,
                    expire,
                    TimeUnit.SECONDS);
        }
        if (count > times) { // 如果訪問次數超出訪問限制次數，則禁止訪問
            // 如果有限制信息則使用限制信息，沒有則使用默認限制信息
            String errorMessage =
                    !StringUtils.isEmpty(prevent.message()) ? prevent.message() : expire + "秒內不允許重復請求";
            throw new BusinessException(StatusCode.FORBIDDEN, errorMessage);
        }
    }


    /**
     * 對象轉換為base64字符串
     * @param obj 對象值
     * @return base64字符串
     */
    private String toBase64String(String obj) throws Exception {
        if (StringUtils.isEmpty(obj)) {
            return null;
        }
        Base64.Encoder encoder = Base64.getEncoder();
        byte[] bytes = obj.getBytes(StandardCharsets.UTF_8);
        return encoder.encodeToString(bytes);
    }
}