# 定義計數(shù)變量
local count
# 獲取調(diào)用腳本時傳入的第一個key值（用作限流的 key）
count = redis.call('get',KEYS[1])
# 限流最大值比較，若超過最大值，則直接返回
if count and tonumber(count) > tonumber(ARGV[1]) then
return count;
end
# incr 命令 執(zhí)行計算器累加
count = redis.call('incr',KEYS[1])
# 從第一次調(diào)用開始限流,并設(shè)置失效時間
if tonumber(count) == 1 then
redis.call('expire',KEYS[1],ARGV[2])
end
return count;

/**
 * 描述: 限流注解
 *
 * @author 程序員小強(qiáng)
 **/
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {

    /**
     * 限流唯一標(biāo)示 key
     * 若同時使用 keyFiled 則當(dāng)前 key作為前綴
     */
    String key();

    /**
     * 限流時間-單位:秒數(shù)
     * 默認(rèn) 60s
     */
    int time() default 60;

    /**
     * 限流次數(shù)
     * 失效時間段內(nèi)最大放行次數(shù)
     */
    int count();

    /**
     * 可作為限流key-參數(shù)類中屬性名，動態(tài)值
     * 示例：phone、userId 等
     */
    String keyField() default "";

    /**
     * 超過最大訪問次數(shù)后的，提示內(nèi)容
     */
    String msg() default "over the max request times please try again";

}

@RateLimit(key = "limit-phone-key", time = 300, count = 10, keyField = "phone", msg = "5分鐘內(nèi)，驗(yàn)證碼最多發(fā)送10次")

/**
 * Redis限流組件
 *
 * @author 程序員小強(qiáng)
 */
@Component
public class RedisRateLimitComponent {
    private static final Logger logger = LoggerFactory.getLogger(RedisRateLimitComponent.class);

    private JedisPool jedisPool;

    @Autowired
    public RedisRateLimitComponent(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    /**
     * 限流方法
     * 1.執(zhí)行 lua 表達(dá)式
     * 2.通過 lua 表達(dá)式實(shí)現(xiàn)-限流計數(shù)器
     *
     * @param redisKey
     * @param time           超時時間-秒數(shù)
     * @param rateLimitCount 限流次數(shù)
     */
    public Long rateLimit(String redisKey, Integer time, Integer rateLimitCount) {
        Jedis jedis = null;
        try {
            jedis = jedisPool.getResource();
            Object obj = jedis.evalsha(jedis.scriptLoad(this.buildLuaScript()), Collections.singletonList(redisKey),
                    Arrays.asList(String.valueOf(rateLimitCount), String.valueOf(time)));
            return Long.valueOf(obj.toString());
        } catch (JedisException ex) {
            logger.error("[ executeLua ] >> messages:{}", ex.getMessage(), ex);
            throw new RateLimitException("[ RedisRateLimitComponent ] >> jedis run lua script exception" + ex.getMessage());
        } finally {
            if (jedis != null) {
                if (jedis.isConnected()) {
                    jedis.close();
                }
            }
        }
    }

    /**
     * 構(gòu)建lua 表達(dá)式
     * KEYS[1] -- 參數(shù)key
     * ARGV[1]-- 失效時間段內(nèi)最大放行次數(shù)
     * ARGV[2]-- 失效時間|秒
     */
    private String buildLuaScript() {
        StringBuilder luaBuilder = new StringBuilder();
        //定義變量
        luaBuilder.append("local count");
        //獲取調(diào)用腳本時傳入的第一個key值（用作限流的 key）
        luaBuilder.append("\ncount = redis.call('get',KEYS[1])");
        // 獲取調(diào)用腳本時傳入的第一個參數(shù)值（限流大?。?- 調(diào)用不超過最大值，則直接返回
        luaBuilder.append("\nif count and tonumber(count) > tonumber(ARGV[1]) then");
        luaBuilder.append("\nreturn count;");
        luaBuilder.append("\nend");
        //執(zhí)行計算器自增
        luaBuilder.append("\ncount = redis.call('incr',KEYS[1])");
        //從第一次調(diào)用開始限流
        luaBuilder.append("\nif tonumber(count) == 1 then");
        //設(shè)置過期時間
        luaBuilder.append("\nredis.call('expire',KEYS[1],ARGV[2])");
        luaBuilder.append("\nend");
        luaBuilder.append("\nreturn count;");
        return luaBuilder.toString();
    }
}

/**
 * 描述:限流切面實(shí)現(xiàn)
 *
 * @author 程序員小強(qiáng)
 **/
@Aspect
@Configuration
public class RateLimitAspect {
    private static final Logger logger = LoggerFactory.getLogger(RateLimitAspect.class);

    private RedisRateLimitComponent redisRateLimitComponent;

    @Autowired
    public RateLimitAspect(RedisRateLimitComponent redisRateLimitComponent) {
        this.redisRateLimitComponent = redisRateLimitComponent;
    }

    /**
     * 匹配所有使用以下注解的方法
     *
     * @see RateLimit
     */
    @Pointcut("@annotation(com.example.ratelimit.annotation.RateLimit)")
    public void pointCut() {
    }

    @Around("pointCut()&&@annotation(rateLimit)")
    public Object logAround(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();

        //組裝限流key
        String rateLimitKey = this.getRateLimitKey(joinPoint, rateLimit);

        //限流組件-通過計數(shù)方式限流
        Long count = redisRateLimitComponent.rateLimit(rateLimitKey, rateLimit.time(), rateLimit.count());
        logger.debug("[ RateLimit ] method={},rateLimitKey={},count={}", methodName, rateLimitKey, count);

        if (null != count && count.intValue() <= rateLimit.count()) {
            //未超過限流次數(shù)-執(zhí)行業(yè)務(wù)方法
            return joinPoint.proceed();
        } else {
            //超過限流次數(shù)
            logger.info("[ RateLimit ] >> over the max request times method={},rateLimitKey={},currentCount={},rateLimitCount={}",
                    methodName, rateLimitKey, count, rateLimit.count());
            throw new RateLimitException(rateLimit.msg());
        }
    }

    /**
     * 獲取限流key
     * 默認(rèn)取 RateLimit > key 屬性值 
     * 若設(shè)置了 keyField 則從參數(shù)中獲取該字段的值拼接到key中
     * 示例：user_phone_login_max_times:13235777777
     *
     * @param joinPoint
     * @param rateLimit
     */
    private String getRateLimitKey(ProceedingJoinPoint joinPoint, RateLimit rateLimit) {
        String fieldName = rateLimit.keyField();
        if ("".equals(fieldName)) {
            return rateLimit.key();
        }

        //處理自定義-參數(shù)名-動態(tài)屬性key
        StringBuilder rateLimitKeyBuilder = new StringBuilder(rateLimit.key());
        for (Object obj : joinPoint.getArgs()) {
            if (null == obj) {
                continue;
            }
            //過濾基本類型參數(shù)
            if (ReflectionUtil.isBaseType(obj.getClass())) {
                continue;
            }
            //屬性值
            Object fieldValue = ReflectionUtil.getFieldByClazz(fieldName, obj);
            if (null != fieldValue) {
                rateLimitKeyBuilder.append(":").append(fieldValue.toString());
                break;
            }
        }
        return rateLimitKeyBuilder.toString();
    }
}

/**
 * 反射工具
 *
 * @author 程序員小強(qiáng)
 */
public class ReflectionUtil {

    private static final Logger logger = LoggerFactory.getLogger(ReflectionUtil.class);

    /**
     * 根據(jù)屬性名獲取屬性元素，
     * 包括各種安全范圍和所有父類
     *
     * @param fieldName
     * @param object
     * @return
     */
    public static Object getFieldByClazz(String fieldName, Object object) {
        Field field = null;
        Class<?> clazz = object.getClass();
        try {
            for (; clazz != Object.class; clazz = clazz.getSuperclass()) {
                try {
                    //子類中查詢不到屬性-繼續(xù)向父類查
                    field = clazz.getDeclaredField(fieldName);
                } catch (NoSuchFieldException ignored) {
                }
            }
            if (null == field) {
                return null;
            }
            field.setAccessible(true);
            return field.get(object);
        } catch (Exception e) {
            //通過反射獲取 屬性值失敗
            logger.error("[ ReflectionUtil ] >> [getFieldByClazz] fieldName:{} ", fieldName, e);
        }
        return null;
    }

    /**
     * 判斷對象屬性是否是基本數(shù)據(jù)類型,包括是否包括string | BigDecimal
     *
     * @param clazz
     * @return
     */
    public static boolean isBaseType(Class clazz) {
        if (null == clazz) {
            return false;
        }
        //基本類型
        if (clazz.isPrimitive()) {
            return true;
        }
        //String
        if (clazz.equals(String.class)) {
            return true;
        }
        //Integer
        if (clazz.equals(Integer.class)) {
            return true;
        }
        //Boolean
        if (clazz.equals(Boolean.class)) {
            return true;
        }
        //BigDecimal
        if (clazz.equals(BigDecimal.class)) {
            return true;
        }
        //Byte
        if (clazz.equals(Byte.class)) {
            return true;
        }
        //Long
        if (clazz.equals(Long.class)) {
            return true;
        }
        //Double
        if (clazz.equals(Double.class)) {
            return true;
        }
        //Float
        if (clazz.equals(Float.class)) {
            return true;
        }
        //Character
        if (clazz.equals(Character.class)) {
            return true;
        }
        //Short
        return clazz.equals(Short.class);
    }
}

  /**
   * 計數(shù)器
   * 演示 demo 為了方便計數(shù)
   */
  private static final AtomicInteger COUNTER = new AtomicInteger();    

  /**
   * 普通限流
   * <p>
   * 30 秒中，可以訪問10次
   */
  @RequestMapping("/limitTest")
  @RateLimit(key = "limit-test-key", time = 30, count = 10)
  public Response limitTest() {
      Map<String, Object> dataMap = new HashMap<>();
      dataMap.put("date", DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss.SSS"));
      dataMap.put("times", COUNTER.incrementAndGet());
      return Response.success(dataMap);
  }