SpingBoot中使用Redis对接口进行限流的实现

request_limit_config    "/api2" : { "limit" : 10 , "time" : 1 , "timeUnit" : "SECONDS" }

request_limit:/api  1

public interface RedisKeys {

     /**

      * api的限制配置，hash key

      */

     String REQUEST_LIMIT_CONFIG = "request_limit_config" ;

     /**

      * api的请求的次数

      */

     String REQUEST_LIMIT = "request_limit" ;

}

import org.springframework.data.redis.core.RedisTemplate;

public class ObjectRedisTemplate extends RedisTemplate<String, Object> {

}

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;

     }

}

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 + "]" ;

     }

}

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 ;

     }

}

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 );

     }

}

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();

     }

}

@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);

}

request_limit_config    "/api2:{userId}" : { "limit" : 10 , "time" : 1 , "timeUnit" : "SECONDS" }

request_limit:{userId}:/api  1

@GetMapping ( "/user/{id}" )  // restful的检索接口，往往把ID信息放在了URI中