Spring Cloud Zuul自定义过滤器的实现

< dependency >

   < groupId >org.springframework.cloud</ groupId >

   < artifactId >spring-cloud-starter-netflix-zuul</ artifactId >

</ dependency >

import com.netflix.zuul.ZuulFilter;

import com.netflix.zuul.exception.ZuulException;

import org.springframework.stereotype.Component;

/**

  * 构建zuul自定义过滤器

  */

@Component

public class MyFilter extends ZuulFilter {

   /**

    * 定义过滤器的类型

    * pre:在请求被路由之前执行

    * route:在路由请求的时候执行

    * post:请求路由以后执行

    * error:处理请求时发生错误的时候执行

    *

    * @return 过滤器的类型

    */

   @Override

   public String filterType() {

     return "pre" ;

   }

   /**

    * 过滤器执行的顺序，配置多个有顺序的过滤

    * 执行顺序从小到大

    *

    * @return 执行顺序

    */

   @Override

   public int filterOrder() {

     return 1 ;

   }

   /**

    * 是否开启过滤器

    * true:开启

    * false:禁用

    *

    * @return 是否开启过滤器

    */

   @Override

   public boolean shouldFilter() {

     return true ;

   }

   /**

    * 过滤器的业务实现

    *

    * @return null 没有意义

    * @throws ZuulException 异常信息

    */

   @Override

   public Object run() throws ZuulException {

     System.out.println( "per zuul filter..." );

     return null ;

   }

}

import com.imooc.grace.result.GraceJsonResult;

import com.imooc.grace.result.ResponseStatusEnum;

import com.imooc.utils.IPUtil;

import com.imooc.utils.JsonUtils;

import com.imooc.utils.RedisOperator;

import com.netflix.zuul.ZuulFilter;

import com.netflix.zuul.context.RequestContext;

import com.netflix.zuul.exception.ZuulException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.MediaType;

import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**

  * 限制ip频繁请求

  */

@Component

public class BlackIpFilter extends ZuulFilter {

   /**

    * ip连续请求的次数

    */

   private static final int CONTINUE_COUNTS = 10 ;

   /**

    * ip判断的时间间隔，单位秒

    */

   private static final int TIME_INTERVAL = 10 ;

   /**

    * 限制的时间，单位秒

    */

   private static final int LIMIT_TIMES = 15 ;

   @Autowired

   private RedisOperator redisOperator;

   @Override

   public String filterType() {

     return "pre" ;

   }

   @Override

   public int filterOrder() {

     // 这里设置为2，上面那个过滤器设置为1，则执行顺序为 1->2，大家可以测试一下

     return 2 ;

   }

   @Override

   public boolean shouldFilter() {

     return true ;

   }

   @Override

   public Object run() throws ZuulException {

     // 获取上下文对象

     RequestContext currentContext = RequestContext.getCurrentContext();

     HttpServletRequest request = currentContext.getRequest();

     // 获取ip

     String requestIp = IPUtil.getRequestIp(request);

     // 判断该ip在10秒内请求次数是否超过10次，超过则限制该ip15秒内不能访问，15秒后再放行

     final String ipRedisKey = "zuul-ip:" + requestIp;

     final String ipRedisLimitKey = "zuul-ip-limit:" + requestIp;

     // 获取当前ip这个key的剩余时间

     long limitLeftTime = redisOperator.ttl(ipRedisLimitKey);

     // 判断该ip是否还有剩余时间

     if (limitLeftTime > 0 ) {

       stopRequest(currentContext);

       return null ;

     }

     // 在redis中累加ip的请求次数

     long requestCounts = redisOperator.increment(ipRedisKey, 1 );

     if (requestCounts == 1 ) {

       redisOperator.expire(ipRedisKey, TIME_INTERVAL);

     }

     if (requestCounts > CONTINUE_COUNTS) {

       // 限制ip访问

       redisOperator.set(ipRedisLimitKey, ipRedisLimitKey, LIMIT_TIMES);

       stopRequest(currentContext);

     }

     return null ;

   }

   private void stopRequest(RequestContext context) {

     // 停止zuul继续向下路由，禁止请求通信

     context.setSendZuulResponse( false );

     // 返回响应码200

     context.setResponseStatusCode( 200 );

     // TODO 要返回提示的json内容（可以自定义任何响应内容）

     // 例如 {"status":544,"msg":"请求过于频繁，请稍后再试","success":false,"data":null}

     String result = "json内容" ;

     // 设置返回内容

     context.setResponseBody(result);

     // 设置编码

     context.getResponse().setCharacterEncoding( "utf-8" );

     // 设置返回内容格式为json

     context.getResponse().setContentType(MediaType.APPLICATION_JSON_VALUE);

   }

}

import javax.servlet.http.HttpServletRequest;

/**

  * 获取ip工具类

  */

public class IPUtil {

   /**

    * 获取请求IP:

    * 用户的真实IP不能使用request.getRemoteAddr()

    * 这是因为可能会使用一些代理软件，这样ip获取就不准确了

    * 此外我们如果使用了多级（LVS/Nginx）反向代理的话，ip需要从X-Forwarded-For中获得第一个非unknown的IP才是用户的有效ip。

    */

   public static String getRequestIp(HttpServletRequest request) {

     String ip = request.getHeader( "x-forwarded-for" );

     if (ip == null || ip.length() == 0 || "unknown" .equalsIgnoreCase(ip)) {

       ip = request.getHeader( "Proxy-Client-IP" );

     }

     if (ip == null || ip.length() == 0 || "unknown" .equalsIgnoreCase(ip)) {

       ip = request.getHeader( "WL-Proxy-Client-IP" );

     }

     if (ip == null || ip.length() == 0 || "unknown" .equalsIgnoreCase(ip)) {

       ip = request.getHeader( "HTTP_CLIENT_IP" );

     }

     if (ip == null || ip.length() == 0 || "unknown" .equalsIgnoreCase(ip)) {

       ip = request.getHeader( "HTTP_X_FORWARDED_FOR" );

     }

     if (ip == null || ip.length() == 0 || "unknown" .equalsIgnoreCase(ip)) {

       ip = request.getRemoteAddr();

     }

     return ip;

   }

}