Spring Cloud Zuul如何实现自定义过滤器

小编给大家分享一下Spring Cloud Zuul如何实现自定义过滤器，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！

构建Zuul自定义过滤器，限制ip频繁请求

自定义zuul过滤器其实很简单

1. 首先pom文件得先引入zuul依赖

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

2. 创建一个类，继承自ZuulFilter

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

自定义类上需要加上 @Component 注解
a. filterType()方法，定义过滤器的类型，返回的就是字符串，有以下4种类型

• pre：在请求被路由之前执行

• route：在路由请求的时候执行

• post：请求路由以后执行

• error：处理请求时发生错误的时候执行

b. filterOrder()方法，过滤器执行的顺序
c. shouldFilter()方法，是否开启过滤器，true开启，false不开启
d. run()方法，过滤器的业务实现，在这里写实现逻辑的具体代码

3. 限制ip频繁请求，示例代码

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

这里使用了redis来记录ip请求次数和控制时间间隔

获取ip工具类 IPUtil

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

看完了这篇文章，相信你对“Spring Cloud Zuul如何实现自定义过滤器”有了一定的了解，如果想了解更多相关知识，欢迎关注亿速云行业资讯频道，感谢各位的阅读！