찾다

집  >  기사  >  데이터 베이스  >  SpringBoot + Redis를 사용하여 인터페이스 전류 제한을 구현하는 방법

SpringBoot + Redis를 사용하여 인터페이스 전류 제한을 구현하는 방법

PHPz
PHPz앞으로
2023-05-27 15:01:191629검색

Configuration

먼저 Spring Boot 프로젝트를 생성하고 웹 및 Redis 종속성을 도입하고 인터페이스 현재 제한이 일반적으로 주석을 통해 표시되고 주석이 AOP를 통해 구문 분석되므로 AOP 종속성도 추가해야 한다는 점을 고려합니다. 최종 종속성은 다음과 같습니다. 

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

그런 다음 Redis 인스턴스를 미리 준비합니다. 프로젝트가 구성된 후 다음과 같이 Redis의 기본 정보를 직접 구성할 수 있습니다. 

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123

Current 제한 주석

다음으로 전류 제한 Note를 생성합니다. 전류 제한을 두 가지 상황으로 나눕니다.

  • 현재 인터페이스에 대한 전역 전류 제한, 예를 들어 인터페이스는 1분에 100회 액세스할 수 있습니다.

  • 특정 IP 주소에 대한 제한(예: IP 주소는 1분에 100회 액세스 가능)

이 두 가지 상황에 대해 열거형 클래스를 만듭니다. 

public enum LimitType {
    /**
     * 默认策略全局限流
     */
    DEFAULT,
    /**
     * 根据请求者IP进行限流
     */
    IP
}

다음으로 전류 제한 주석을 만듭니다. 

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimiter {
    /**
     * 限流key
     */
    String key() default "rate_limit:";

    /**
     * 限流时间,单位秒
     */
    int time() default 60;

    /**
     * 限流次数
     */
    int count() default 100;

    /**
     * 限流类型
     */
    LimitType limitType() default LimitType.DEFAULT;
}

첫 번째 매개변수는 전류 제한의 핵심입니다. 키는 이 접두사에 인터페이스 메서드의 전체 경로를 더한 것이며, 이 키는 Redis에 저장됩니다.

다른 세 가지 매개변수는 이해하기 쉬우므로 자세히 설명하지 않겠습니다.

좋아요. 나중에 인터페이스가 흐름을 제한해야 한다면 해당 인터페이스에 @RateLimiter 주석을 추가한 다음 관련 매개변수를 구성하면 됩니다. @RateLimiter 注解，然后配置相关参数即可。

定制 RedisTemplate

在 Spring Boot 中，我们其实更习惯使用 Spring Data Redis 来操作 Redis，不过默认的 RedisTemplate 有一个小坑，就是序列化用的是 JdkSerializationRedisSerializer，不知道小伙伴们有没有注意过，直接用这个序列化工具将来存到 Redis 上的 key 和 value 都会莫名其妙多一些前缀，这就导致你用命令读取的时候可能会出错。

例如存储的时候，key 是 name，value 是 test，但是当你在命令行操作的时候，get name 却获取不到你想要的数据，原因就是存到 redis 之后 name 前面多了一些字符，此时只能继续使用 RedisTemplate 将之读取出来。

我们用 Redis 做限流会用到 Lua 脚本，使用 Lua 脚本的时候，就会出现上面说的这种情况，所以我们需要修改 RedisTemplate 的序列化方案。

可能有小伙伴会说为什么不用 StringRedisTemplate 呢？StringRedisTemplate 确实不存在上面所说的问题，但是它能够存储的数据类型不够丰富，所以这里不考虑。

修改 RedisTemplate 序列化方案，代码如下：

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        redisTemplate.setKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

这个其实也没啥好说的，key 和 value 我们都使用 Spring Boot 中默认的 jackson 序列化方式来解决。

Lua 脚本

这个其实我在之前 vhr 那一套视频中讲过，Redis 中的一些原子操作我们可以借助 Lua 脚本来实现，想要调用 Lua 脚本，我们有两种不同的思路：

  • 在 Redis 服务端定义好 Lua 脚本，然后计算出来一个散列值，在 Java 代码中，通过这个散列值锁定要执行哪个 Lua 脚本。

  • 直接在 Java 代码中将 Lua 脚本定义好，然后发送到 Redis 服务端去执行。

Spring Data Redis 中也提供了操作 Lua 脚本的接口，还是比较方便的，所以我们这里就采用第二种方案。

我们在 resources 目录下新建 lua 文件夹专门用来存放 lua 脚本，脚本内容如下：

local key = KEYS[1]
local count = tonumber(ARGV[1])
local time = tonumber(ARGV[2])
local current = redis.call(&#39;get&#39;, key)
if current and tonumber(current) > count then
    return tonumber(current)
end
current = redis.call(&#39;incr&#39;, key)
if tonumber(current) == 1 then
    redis.call(&#39;expire&#39;, key, time)
end
return tonumber(current)

这个脚本其实不难，大概瞅一眼就知道干啥用的。KEYS 和 ARGV 都是一会调用时候传进来的参数，tonumber 就是把字符串转为数字，redis.call 就是执行具体的 redis 指令，具体流程是这样：

  • 首先获取到传进来的 key 以及 限流的 count 和时间 time。

  • 通过 get 获取到这个 key 对应的值，这个值就是当前时间窗内这个接口可以访问多少次。

  • 如果是第一次访问，此时拿到的结果为 nil，否则拿到的结果应该是一个数字，所以接下来就判断，如果拿到的结果是一个数字，并且这个数字还大于 count，那就说明已经超过流量限制了，那么直接返回查询的结果即可。

  • 如果拿到的结果为 nil，说明是第一次访问，此时就给当前 key 自增 1，然后设置一个过期时间。

  • 最后把自增 1 后的值返回就可以了。

其实这段 Lua 脚本很好理解。

接下来我们在一个 Bean 中来加载这段 Lua 脚本，如下：

@Bean
public DefaultRedisScript<Long> limitScript() {
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("lua/limit.lua")));
    redisScript.setResultType(Long.class);
    return redisScript;
}

可以啦，我们的 Lua 脚本现在就准备好了。

注解解析

接下来我们就需要自定义切面，来解析这个注解了，我们来看看切面的定义：

@Aspect
@Component
public class RateLimiterAspect {
    private static final Logger log = LoggerFactory.getLogger(RateLimiterAspect.class);
    @Autowired
    private RedisTemplate<Object, Object> redisTemplate;
    @Autowired
    private RedisScript<Long> 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 (number==null || number.intValue() > count) {
                throw new ServiceException("访问过于频繁，请稍候再试");
            }
            log.info("限制请求&#39;{}&#39;,当前请求&#39;{}&#39;,缓存key&#39;{}&#39;", 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(((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest())).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();
    }
}

这个切面就是拦截所有加了 @RateLimiter

Customized RedisTemplate🎜🎜Spring Boot에서는 실제로 Redis를 운영하기 위해 Spring Data Redis를 사용하는 것이 더 익숙하지만, 기본 RedisTemplate에는 작은 함정이 있습니다. 즉, 직렬화를 위해 JdkSerializationRedisSerializer가 사용된다는 점을 눈치채셨는지 궁금합니다. 이 직렬화 도구를 직접 사용하면 Redis에 저장된 키와 값에 설명할 수 없이 더 많은 접두사가 생겨 명령으로 읽을 때 오류가 발생할 수 있습니다. 🎜🎜예를 들어 저장할 때 키는 name이고 값은 test인데, 명령줄에서 작업할 때 get name으로 원하는 데이터를 가져올 수 없는 이유는 저장되기 때문입니다. 이름 앞에 추가 문자가 있습니다. 현재로서는 RedisTemplate을 계속 사용해서만 읽을 수 있습니다. 🎜🎜현재 제한을 위해 Redis를 사용할 때 Lua 스크립트를 사용하게 됩니다. Lua 스크립트를 사용할 때 위에서 언급한 상황이 발생하므로 RedisTemplate의 직렬화 체계를 수정해야 합니다. 🎜
🎜어떤 친구들은 왜 StringRedisTemplate을 사용하지 않냐고 물을 수도 있습니다. StringRedisTemplate에는 위에서 언급한 문제가 없지만 저장할 수 있는 데이터 유형이 충분하지 않으므로 여기서는 고려하지 않습니다. 🎜
🎜RedisTemplate 직렬화 체계를 수정하면 코드는 다음과 같습니다. 🎜
@RestController
public class HelloController {
    @GetMapping("/hello")
    @RateLimiter(time = 5,count = 3,limitType = LimitType.IP)
    public String hello() {
        return "hello>>>"+new Date();
    }
}
🎜사실 이에 대해서는 말할 것도 없습니다. Spring Boot에서는 기본 jackson 직렬화 방법을 사용하여 키와 값을 해결합니다. 🎜🎜Lua 스크립트🎜🎜사실, Lua 스크립트의 도움으로 Redis에서 몇 가지 원자적 작업을 구현할 수 있다고 언급했습니다. 🎜🎜 🎜 🎜 Redis 서버에서 Lua 스크립트를 정의한 다음 해시 값을 계산합니다. Java 코드에서 이 해시 값을 사용하여 실행할 Lua 스크립트를 잠급니다. 🎜🎜🎜🎜 Java 코드에서 Lua 스크립트를 직접 정의한 다음 실행을 위해 Redis 서버로 보냅니다. 🎜🎜🎜🎜Spring Data Redis는 Lua 스크립트를 작동하기 위한 인터페이스도 제공하는데 이는 매우 편리하므로 여기서는 두 번째 옵션을 채택하겠습니다. 🎜🎜Lua 스크립트를 저장하기 위해 특별히 resources 디렉토리에 새 lua 폴더를 만듭니다. 🎜
@RestControllerAdvice
public class GlobalException {
    @ExceptionHandler(ServiceException.class)
    public Map<String,Object> serviceException(ServiceException e) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("status", 500);
        map.put("message", e.getMessage());
        return map;
    }
}
🎜이 스크립트는 실제로 어떤 용도로 사용되는지 알 수 있습니다. KEYS와 ARGV는 모두 호출 시 전달되는 매개변수입니다. Tonumber는 문자열을 숫자로 변환하는 것입니다. redis.call은 특정 redis 명령을 실행하는 것입니다. 🎜🎜🎜🎜먼저 전달된 키와 현재를 가져옵니다. 횟수와 시간을 제한합니다. 🎜🎜🎜🎜get을 통해 이 키에 해당하는 값을 가져옵니다. 이 값은 현재 시간 창에서 이 인터페이스에 액세스할 수 있는 횟수입니다. 🎜🎜🎜🎜처음 방문인 경우 이때 얻은 결과는 nil이고, 그렇지 않은 경우 얻은 결과는 숫자여야 하므로 다음 단계에서는 얻은 결과가 숫자이고 이 숫자가 더 큰지 판단하는 것입니다. 개수보다 트래픽 제한이 초과되었음을 의미하므로 쿼리 결과가 직접 반환될 수 있습니다. 🎜🎜🎜🎜얻은 결과가 nil이면 첫 번째 액세스라는 의미입니다. 이때 현재 키를 1 증가시킨 후 만료 시간을 설정합니다. 🎜🎜🎜🎜마지막으로 1만큼 증가된 값을 반환하면 됩니다. 🎜🎜🎜🎜사실 이 Lua 스크립트는 이해하기 쉽습니다. 🎜🎜다음으로 다음과 같이 이 Lua 스크립트를 Bean에 로드합니다. 🎜rrreee🎜자, 이제 Lua 스크립트가 준비되었습니다. 🎜🎜주석 분석🎜🎜다음으로 이 주석을 구문 분석하기 위해 측면을 사용자 정의해야 합니다. 측면의 정의를 살펴보겠습니다. 🎜rrreee🎜이 측면은 @RateLimiter 메서드를 사용하여 모든 주석을 가로채서 처리합니다. 사전 알림의 주석. 🎜

  • 首先获取到注解中的 key、time 以及 count 三个参数。

  • 获取一个组合的 key，所谓的组合的 key，就是在注解的 key 属性基础上，再加上方法的完整路径，如果是 IP 模式的话，就再加上 IP 地址。以 IP 模式为例，最终生成的 key 类似这样：rate_limit:127.0.0.1-org.javaboy.ratelimiter.controller.HelloController-hello（如果不是 IP 模式，那么生成的 key 中就不包含 IP 地址）。

  • 将生成的 key 放到集合中。

  • 通过 redisTemplate.execute 方法取执行一个 Lua 脚本，第一个参数是脚本所封装的对象，第二个参数是 key，对应了脚本中的 KEYS，后面是可变长度的参数，对应了脚本中的 ARGV。

  • 判断 Lua 脚本执行后的结果是否超过 count，若超过则视为过载，抛出异常处理即可。

接口测试

接下来我们就进行接口的一个简单测试，如下：

@RestController
public class HelloController {
    @GetMapping("/hello")
    @RateLimiter(time = 5,count = 3,limitType = LimitType.IP)
    public String hello() {
        return "hello>>>"+new Date();
    }
}

每一个 IP 地址，在 5 秒内只能访问 3 次。

这个自己手动刷新浏览器都能测试出来。

全局异常处理

由于过载的时候是抛异常出来，所以我们还需要一个全局异常处理器，如下：

@RestControllerAdvice
public class GlobalException {
    @ExceptionHandler(ServiceException.class)
    public Map<String,Object> serviceException(ServiceException e) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("status", 500);
        map.put("message", e.getMessage());
        return map;
    }
}

我将这句话重写成如下： 这个 demo 很小，所以我没有定义实体类，而是直接使用 Map 来返回 JSON。 最后我们看看过载时的测试效果：

SpringBoot + Redis를 사용하여 인터페이스 전류 제한을 구현하는 방법

위 내용은 SpringBoot + Redis를 사용하여 인터페이스 전류 제한을 구현하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

Java lua spring spring boot json 数据类型 count 封装 字符串 接口 nil map 对象 redis
성명：
이 기사는 yisu.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제
이전 기사：Redis 클러스터 원리 분석 예시다음 기사：Redis 클러스터 원리 분석 예시

관련 기사

더보기