SpingBoot中使用Redis對接口進行限流的實現
一個基於Redis實現的接口限流方案,先說要實現的功能
- 可以限制指定的接口,在一定時間內,隻能被請求N次,超過次數就返回異常信息
- 可以通過配置文件,或者管理後臺,動態的修改限流配置
實現的思路
使用 Hash 存儲接口的限流配置
request_limit_config "/api2" : {"limit": 10, "time": 1, "timeUnit": "SECONDS"}
hash中的key就是請求的uri路徑,value是一個對象。通過3個屬性,描述限制策略
- limit 最多請求次數
- time 時間
- timeUnit 時間單位
使用普通kv,存儲api的請求次數
request_limit:/api 1
處理請求的時候,通過increment對該key進行 +1 操作,如果返回1,則表示是第一次請求,此時設置它的過期時間。為限制策略中定義時間限制信息。再通過命名的返回值,判斷是否超出瞭限制。
increment 指令是線程安全的,不用擔心並發的問題。
使用SpringBoot實現
創建SpringBoot工程,添加
spring-boot-starter-data-redis依賴,並且給出正確的配置。
這裡不做工程的創建,配置,以及其他額外代碼的演示,僅僅給出關鍵的代碼。
RedisKeys
定義兩個Key,限流用到的2個Key
public interface RedisKeys { /** * api的限制配置,hash key */ String REQUEST_LIMIT_CONFIG = "request_limit_config"; /** * api的請求的次數 */ String REQUEST_LIMIT = "request_limit"; }
ObjectRedisTemplate
為瞭提高hash value的序列化效率,自定義一個RedisTemplate的實現。使用jdk的序列化,而不是json。
import org.springframework.data.redis.core.RedisTemplate; public class ObjectRedisTemplate extends RedisTemplate<String, Object> { }
RedisConfigration
把自定義的ObjectRedisTemplate配置到IOC
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.serializer.RedisSerializer; import io.springboot.jwt.redis.ObjectRedisTemplate; @Configuration public class RedisConfiguration { @Bean public ObjectRedisTemplate objectRedisTemplate(@Autowired RedisConnectionFactory redisConnectionFactory) { ObjectRedisTemplate objectRedisTemplate = new ObjectRedisTemplate(); objectRedisTemplate.setConnectionFactory(redisConnectionFactory); objectRedisTemplate.setKeySerializer(RedisSerializer.string()); objectRedisTemplate.setValueSerializer(RedisSerializer.java()); // hash的key使用String序列化 objectRedisTemplate.setHashKeySerializer(RedisSerializer.string()); // hash的value使用jdk的序列化 objectRedisTemplate.setHashValueSerializer(RedisSerializer.java()); return objectRedisTemplate; } }
RequestLimitConfig
用於描述限制策略的對象。
import java.io.Serializable; import java.util.concurrent.TimeUnit; public class RequestLimitConfig implements Serializable { /** * */ private static final long serialVersionUID = 1101875328323558092L; // 最大請求次數 private long limit; // 時間 private long time; // 時間單位 private TimeUnit timeUnit; public RequestLimitConfig() { super(); } public RequestLimitConfig(long limit, long time, TimeUnit timeUnit) { super(); this.limit = limit; this.time = time; this.timeUnit = timeUnit; } public long getLimit() { return limit; } public void setLimit(long limit) { this.limit = limit; } public long getTime() { return time; } public void setTime(long time) { this.time = time; } public TimeUnit getTimeUnit() { return timeUnit; } public void setTimeUnit(TimeUnit timeUnit) { this.timeUnit = timeUnit; } @Override public String toString() { return "RequestLimitConfig [limit=" + limit + ", time=" + time + ", timeUnit=" + timeUnit + "]"; } }
RequestLimitInterceptor
通過攔截器,來完成限流的實現。
import java.nio.charset.StandardCharsets; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.MediaType; import org.springframework.util.StringUtils; import org.springframework.web.servlet.handler.HandlerInterceptorAdapter; import io.springboot.jwt.redis.ObjectRedisTemplate; import io.springboot.jwt.redis.RedisKeys; import io.springboot.jwt.web.RequestLimitConfig; public class RequestLimitInterceptor extends HandlerInterceptorAdapter { private static final Logger LOGGER = LoggerFactory.getLogger(RequestLimitInterceptor.class); @Autowired private ObjectRedisTemplate objectRedisTemplate; @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { /** * 獲取到請求的URI */ String contentPath = request.getContextPath(); String uri = request.getRequestURI().toString(); if (!StringUtils.isEmpty(contentPath) && !contentPath.equals("/")) { uri = uri.substring(uri.indexOf(contentPath) + contentPath.length()); } LOGGER.info("uri={}", uri); /** * 嘗試從hash中讀取得到當前接口的限流配置 */ RequestLimitConfig requestLimitConfig = (RequestLimitConfig) this.objectRedisTemplate.opsForHash().get(RedisKeys.REQUEST_LIMIT_CONFIG, uri); if (requestLimitConfig == null) { LOGGER.info("該uri={}沒有限流配置", uri); return true; } String limitKey = RedisKeys.REQUEST_LIMIT + ":" + uri; /** * 當前接口的訪問次數 +1 */ long count = this.objectRedisTemplate.opsForValue().increment(limitKey); if (count == 1) { /** * 第一次請求,設置key的過期時間 */ this.objectRedisTemplate.expire(limitKey, requestLimitConfig.getTime(), requestLimitConfig.getTimeUnit()); LOGGER.info("設置過期時間:time={}, timeUnit={}", requestLimitConfig.getTime(), requestLimitConfig.getTimeUnit()); } LOGGER.info("請求限制。limit={}, count={}", requestLimitConfig.getLimit(), count); if (count > requestLimitConfig.getLimit()) { /** * 限定時間內,請求超出限制,響應客戶端錯誤信息。 */ response.setContentType(MediaType.TEXT_PLAIN_VALUE); response.setCharacterEncoding(StandardCharsets.UTF_8.name()); response.getWriter().write("服務器繁忙,稍後再試"); return false; } return true; } }
Controller
一個用於測試的接口類
import java.util.Collections; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/test") public class TestController { @GetMapping public Object test () { return Collections.singletonMap("success", true); } }
WebMvcConfigration
攔截器的配置
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import io.springboot.jwt.web.interceptor.RequestLimitInterceptor; @Configuration public class WebMvcConfiguration implements WebMvcConfigurer { @Override public void addInterceptors(InterceptorRegistry registry) { registry.addInterceptor(this.requestLimitInterceptor()) .addPathPatterns("/test"); } @Bean public RequestLimitInterceptor requestLimitInterceptor() { return new RequestLimitInterceptor(); } }
通過@Test測試,初始化一個限流配置
@Autowired private ObjectRedisTemplate objectRedisTemplate; @Test public void test () { // 3秒內,隻能請求2次 RequestLimitConfig requestLimitConfig = new RequestLimitConfig(2, 3, TimeUnit.SECONDS); // 限制的uri是 /test this.objectRedisTemplate.opsForHash().put(RedisKeys.REQUEST_LIMIT_CONFIG, "/test", requestLimitConfig); }
使用瀏覽器演示
最後一些問題
怎麼靈活的配置
都寫到這個份兒上瞭,如果熟悉Redis以及客戶端,我想提供一個“限流管理”接口的並不是難事兒。
針對指定的用戶限流
這裡演示的方法是,針對接口的限流。有時候,也有一些特殊的需求,需要“針對不同”的用戶來做限流。打個比方。針對A用戶,允許有他1分鐘請求20次接口,針對B用戶,允許他1分鐘請求10次接口。 這個其實也簡單,隻需要修改一下上面的兩個限制key,在key中添加用戶的唯一標識(例如:ID)
request_limit_config "/api2:{userId}" : {"limit": 10, "time": 1, "timeUnit": "SECONDS"}
request_limit:{userId}:/api 1
在攔截器中獲取到用戶的ID,加上用戶ID進行檢索和判斷,就可以完成針對用戶的限流。
Restful 接口的問題
@GetMapping("/user/{id}") // restful的檢索接口,往往把ID信息放在瞭URI中
這就會導致上面的代碼有問題,因為這裡采用的是根據URI來完成的限流操作。檢索不同ID的用戶,會導致URI不同。 解決辦法我認為也很簡單。那就不要使用URI,可以通過 自定義註解,方式,不同的接口,定義不同的唯一標識。在攔截器中獲取到註解,讀取到唯一的編碼,代替原來的URI,即可。
到此這篇關於SpingBoot中使用Redis對接口進行限流的實現的文章就介紹到這瞭,更多相關SpingBoot Redis接口限流內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet!
推薦閱讀:
- SpringBoot+SpringCache實現兩級緩存(Redis+Caffeine)
- Springboot使用redis實現接口Api限流的實例
- SpringBoot整合Redis將對象寫入redis的實現
- SpringBoot整合Redisson的步驟(單機版)
- springboot2.5.0和redis整合配置詳解