# csthink-limiter-spring-boot-starter

**Repository Path**: csthink/csthink-limiter

## Basic Information

- **Project Name**: csthink-limiter-spring-boot-starter
- **Description**: 自定义的 springboot starter 使用限流组件实现在SpringBoot中使用 Guava 或 Redis 进行接口限流
- **Primary Language**: Java
- **License**: MPL-2.0
- **Default Branch**: main
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-09-08
- **Last Updated**: 2024-05-21

## Categories & Tags

**Categories**: Uncategorized

**Tags**: SpringBoot

## README

# 如何使用 csthink limiter 限流组件实现在SpringBoot中使用 Guava 或 Redis 进行接口限流

- 支持两种限流机制
1. Guava 实现单机令牌桶限流
2. Redis 实现分布式限流

## 如何使用
1. SpringBoot 项目引入依赖

```xml
<dependency>
    <groupId>com.csthink</groupId>
    <artifactId>limiter-spring-boot-starter</artifactId>
    <version>1.0.0</version>
</dependency>
```

2. 在 application.properties 中设置加载的限流组件

- 当需要使用 Guava 单机版限流时，添加如下配置到 application.properties 中

```properties
csthink.limiter.enabled=true
csthink.limiter.type=guava
```

- 当需要使用 Redis 实现分布式限流时，项目中必须要已经支持了 Redis,然后添加如下配置到 application.properties

```properties
csthink.limiter.enabled=true
csthink.limiter.type=redis
```

3. 在需要限流的接口上加上注解

```java
package com.example.test;

import com.csthink.limiter.aop.Limit;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/limit")
public class LimitController {

    @GetMapping("/test")
    @Limit(key = "limit", permitsPerSecond = 10, timeout = 1) // 限流策略: 1秒钟允许通过10个请求
    public String test() {
        System.out.println("令牌桶limit获取令牌成功");
        return "ok";
    }
}
```

完成以上步骤后，就可以对接口实现限流功能了。

以下列出了如何在 SpringBoot 项目中整合 Redis,也许你能用上,仅供参考

1. 引入redis依赖

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
```

2. 在 application.properties 中添加 Redis 链接配置

```properties
spring.redis.database=1
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=xxx
spring.redis.timeout=60000
```

3. 根据需要设置 Redis 的序列化,以下用到的maven 依赖如下

```xml
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
```

```java
package com.example.test;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfiguration {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);

        // Use Jackson 2Json RedisSerializer to serialize and deserialize the value of redis
        // (default JDK serialization)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.PROPERTY);
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);

        // Use String RedisSerializer to serialize and deserialize the key value of redis
        RedisSerializer redisSerializer = new StringRedisSerializer();

        // redis key serialize setting
        redisTemplate.setKeySerializer(redisSerializer);
        redisTemplate.setHashKeySerializer(redisSerializer);

        // redis value serialize setting
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}
```