AOP+Redis+Lua打造严密防线，守护接口安全

2023-10-04 15:28:38

AOP：切入时机，精准把控

AOP（Aspect-Oriented Programming）是一种面向切面的编程技术，允许你以非侵入式的方式修改程序的行为。在接口限流场景中，我们可以使用AOP来拦截特定的方法调用，并在调用之前执行限流逻辑。

例如，在Spring Boot中，可以使用@Around注解来实现AOP拦截。以下代码演示了如何拦截delete()方法：

@Around("@annotation(com.example.aop.Limit)")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
    // 获取限流注解的参数
    Limit limit = joinPoint.getAnnotation(Limit.class);

    // 获取限流阈值
    int threshold = limit.value();

    // 使用Redis限流
    String key = "limit_" + joinPoint.getSignature().getName();
    long count = redisTemplate.opsForValue().increment(key, 1);
    if (count > threshold) {
        // 超过限流阈值，抛出异常
        throw new RuntimeException("接口限流");
    }

    // 执行原方法
    return joinPoint.proceed();
}

Redis：快速计数，高效限流

Redis是一款优秀的键值数据库，具有高性能和可扩展性。在接口限流场景中，我们可以使用Redis来存储限流计数器。

以下代码演示了如何使用Redis实现令牌桶算法：

public class TokenBucketLimiter {

    private RedisTemplate<String, Long> redisTemplate;

    // 令牌桶容量
    private int capacity;

    // 令牌生成速率
    private double rate;

    public TokenBucketLimiter(RedisTemplate<String, Long> redisTemplate, int capacity, double rate) {
        this.redisTemplate = redisTemplate;
        this.capacity = capacity;
        this.rate = rate;
    }

    public boolean acquire() {
        // 获取当前时间戳
        long now = System.currentTimeMillis();

        // 获取令牌桶的剩余容量
        long tokens = Math.min(capacity, redisTemplate.opsForValue().increment("token_bucket", 1));

        // 计算令牌桶的下次刷新时间
        long nextRefreshTime = now + (long) (capacity / rate * 1000);

        // 如果剩余容量大于0，则获取令牌成功
        if (tokens > 0) {
            // 更新令牌桶的下次刷新时间
            redisTemplate.opsForValue().set("next_refresh_time", nextRefreshTime);
            return true;
        } else {
            // 获取令牌失败
            return false;
        }
    }
}

Lua：原子操作，无缝衔接

Lua是一种轻量级脚本语言，具有强大的数据操作能力。在接口限流场景中，我们可以使用Lua来实现原子操作，确保限流逻辑的执行不会受到其他线程的干扰。

以下代码演示了如何使用Lua实现滑动窗口算法：

-- 限流阈值
local threshold = 1000

-- 滑动窗口大小
local windowSize = 1000

-- 获取当前时间戳
local now = redis.call("TIME")

-- 获取滑动窗口的起始时间戳
local startTimestamp = now - windowSize

-- 获取滑动窗口内的请求数
local count = redis.call("ZCOUNT", "sliding_window", startTimestamp, now)

-- 如果请求数超过限流阈值，则返回false
if count > threshold then
    return false
end

-- 将当前时间戳添加到滑动窗口中
redis.call("ZADD", "sliding_window", now, now)

-- 返回true，表示请求通过限流
return true

实战应用：守护接口安全

在实际应用中，我们可以将AOP、Redis和Lua这三剑客结合起来，打造一个严密而高效的接口限流系统。

以下代码演示了如何使用Spring Boot构建一个接口限流应用：

@SpringBootApplication
public class LimitApplication {

    public static void main(String[] args) {
        SpringApplication.run(LimitApplication.class, args);
    }
}

@RestController
class LimitController {

    @Limit(value = 100)
    @GetMapping("/test")
    public String test() {
        return "Hello, World!";
    }
}

@Aspect
class LimitAspect {

    @Around("@annotation(com.example.aop.Limit)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取限流注解的参数
        Limit limit = joinPoint.getAnnotation(Limit.class);

        // 获取限流阈值
        int threshold = limit.value();

        // 使用Redis限流
        String key = "limit_" + joinPoint.getSignature().getName();
        long count = redisTemplate.opsForValue().increment(key, 1);
        if (count > threshold) {
            // 超过限流阈值，抛出异常
            throw new RuntimeException("接口限流");
        }

        // 执行原方法
        return joinPoint.proceed();
    }
}

@Configuration
class RedisConfig {

    @Bean
    public RedisTemplate<String, Long> redisTemplate() {
        RedisTemplate<String, Long> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new LongRedisSerializer());
        return redisTemplate;
    }

    @Bean
    public RedisConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory();
    }
}