remove 删除无用注入

疯狂的狮子li

2021-12-07 df6759b0333a188ca871b0b51eb99841dec1e91a

 ruoyi-framework/src/main/java/com/ruoyi/framework/aspectj/RateLimiterAspect.java

@@ -1,93 +1,65 @@
package com.ruoyi.framework.aspectj;



import java.lang.reflect.Method;

import java.util.Collections;

import java.util.List;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.Signature;

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.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.script.RedisScript;

import org.springframework.stereotype.Component;

import com.ruoyi.common.annotation.RateLimiter;

import com.ruoyi.common.enums.LimitType;

import com.ruoyi.common.exception.ServiceException;

import com.ruoyi.common.utils.ServletUtils;

import com.ruoyi.common.utils.StringUtils;

import com.ruoyi.common.utils.ip.IpUtils;



/**

 * 限流处理

 *

 * @author ruoyi

 */

@Aspect

@Component

public class RateLimiterAspect

{

    private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);



    private RedisTemplate<Object, Object> redisTemplate;



    private RedisScript<Long> limitScript;



    @Autowired

    public void setRedisTemplate1(RedisTemplate<Object, Object> redisTemplate)

    {

        this.redisTemplate = redisTemplate;

    }



    @Autowired

    public void setLimitScript(RedisScript<Long> limitScript)

    {

        this.limitScript = limitScript;

    }



    @Before("@annotation(rateLimiter)")

    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable

    {

        String key = rateLimiter.key();

        int time = rateLimiter.time();

        int count = rateLimiter.count();



        String combineKey = getCombineKey(rateLimiter, point);

        List<Object> keys = Collections.singletonList(combineKey);

        try

        {

            Long number = redisTemplate.execute(limitScript, keys, count, time);

            if (StringUtils.isNull(number) || number.intValue() > count)

            {

                throw new ServiceException("访问过于频繁，请稍后再试");

            }

            log.info("限制请求'{}',当前请求'{}',缓存key'{}'", count, number.intValue(), key);

        }

        catch (ServiceException e)

        {

            throw e;

        }

        catch (Exception e)

        {

            throw new RuntimeException("服务器限流异常，请稍后再试");

        }

    }



    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point)

    {

        StringBuffer stringBuffer = new StringBuffer(rateLimiter.key());

        if (rateLimiter.limitType() == LimitType.IP)

        {

            stringBuffer.append(IpUtils.getIpAddr(ServletUtils.getRequest()));

        }

        MethodSignature signature = (MethodSignature) point.getSignature();

        Method method = signature.getMethod();

        Class<?> targetClass = method.getDeclaringClass();

        stringBuffer.append("-").append(targetClass.getName()).append("- ").append(method.getName());

        return stringBuffer.toString();

    }

}

package com.ruoyi.framework.aspectj;

import com.ruoyi.common.annotation.RateLimiter;
import com.ruoyi.common.enums.LimitType;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.RedisUtils;
import com.ruoyi.common.utils.ServletUtils;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RateType;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**
 * 限流处理
 *
 * @author Lion Li
 */
@Slf4j
@Aspect
@Component
public class RateLimiterAspect {

    @Before("@annotation(rateLimiter)")
    public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable {
        int time = rateLimiter.time();
        int count = rateLimiter.count();
        String combineKey = getCombineKey(rateLimiter, point);
        try {
            RateType rateType = RateType.OVERALL;
            if (rateLimiter.limitType() == LimitType.CLUSTER) {
                rateType = RateType.PER_CLIENT;
            }
            long number = RedisUtils.rateLimiter(combineKey, rateType, count, time);
            if (number == -1) {
                throw new ServiceException("访问过于频繁，请稍候再试");
            }
            log.info("限制令牌 => {}, 剩余令牌 => {}, 缓存key => '{}'", count, number, combineKey);
        } catch (ServiceException e) {
            throw e;
        } catch (Exception e) {
            throw new RuntimeException("服务器限流异常，请稍候再试");
        }
    }

    public String getCombineKey(RateLimiter rateLimiter, JoinPoint point) {
        StringBuilder stringBuffer = new StringBuilder(rateLimiter.key());
        if (rateLimiter.limitType() == LimitType.IP) {
            // 获取请求ip
            stringBuffer.append(ServletUtils.getClientIP()).append("-");
        } else if (rateLimiter.limitType() == LimitType.CLUSTER){
            // 获取客户端实例id
            stringBuffer.append(RedisUtils.getClient().getId()).append("-");
        }
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Class<?> targetClass = method.getDeclaringClass();
        stringBuffer.append(targetClass.getName()).append("-").append(method.getName());
        return stringBuffer.toString();
    }
}