SpringCloud - Spring Cloud Netflix 之 Zuul网关；过滤器filter（十二）

小灰灰 2023-09-28 10:52 130阅读 0赞

#### 阅读本文前可先参考 ####

#### [SpringCloud - Spring Cloud根/父项目，开发准备（二）\_MinggeQingchun的博客-CSDN博客][SpringCloud - Spring Cloud_MinggeQingchun_-CSDN] ####

[https://blog.csdn.net/MinggeQingchun/article/details/125326667][https_blog.csdn.net_MinggeQingchun_article_details_125326667]

Zuul 包含了对请求的**路由**和**过滤**两个最主要的功能，外加代理功能：

**1、路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础**。

**2、过滤器功能则负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础**

## 2、过滤器 ##

**过滤器 (filter) 是zuul的核心组件**，主要作用：限流、权限验证、记录日志。

zuul中定义了4种标准过滤器类型，这些过滤器类型对应于请求的典型生命周期。

**PRE：**这种过滤器在请求被路由之前调用。可利用这种过滤器实现身份验证、在 集群中选择请求的微服务、记录调试信息等。

**ROUTING：**这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服 务的请求，并使用 Apache HttpClient或 Netfilx Ribbon请求微服务

**POST：**这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准 的 HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。 ERROR：在其他阶段发生错误时执行该过滤器。

**ERROR**：在其他阶段发生错误时执行该过滤器。

![512f149e1002426dba20209dca9d3d64.png][]

### 1、Zuul 过滤器使用 ###

编写一个过滤器，则需继承ZuulFilter类实现其中的方法

public class LogFilter extends ZuulFilter {
        /**
         * filterType: 返回过滤器的类型。有 pre、 route、 post、 error等几种取值，分别对应上文的几种过滤器。
         * 在路由的时候执行
         * 详细可以参考 com.netflix.zuul.ZuulFilter.filterType()中的注释
         */
        @Override
        public String filterType() {
            return FilterConstants.ROUTE_TYPE;
        }
    
        /**
         * filter0rder: 返回一个 int值来指定过滤器的执行顺序，不同的过滤器允许返回相同的数字
         */
        @Override
        public int filterOrder() {
            return FilterConstants.PRE_DECORATION_FILTER_ORDER;
        }
    
        /**
         * shouldFilter：是否要使用过滤器
         * 返回一个 boolean值来判断该过滤器是否要执行， true表示执行， false表示不执行
         */
        @Override
        public boolean shouldFilter() {
            //true表示要使用该过滤，false表示不使用该过滤器(默认false)
            return true;
        }
    
        /**
         * run：过滤器的具体逻辑
         * 在路由的时候执行run方法
         */
        @Override
        public Object run() throws ZuulException {
            RequestContext context = RequestContext.getCurrentContext();
            HttpServletRequest request = context.getRequest();
            String remoteAddress = request.getServerName();
            System.out.println("访问地址:" + remoteAddress + request.getRequestURI());
    
            //接收到参数
            /*request.getParameter("username");
            HttpServletResponse response = currentContext.getResponse();
            try {
                //重定向
                response.sendRedirect("");
    
                //forward跳转
                RequestDispatcher dispatcher = request.getRequestDispatcher("/path");
                dispatcher.forward(request, response);
    
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ServletException e) {
                e.printStackTrace();
            }*/
    
            //异常处理使用
            int a = 10 / 0;
    
            //返回值目前是没有什么意义的，返回null即可
            return null;
        }
    }

自定义的 zuul Filter需实现以下几个方法

> filterType: 返回过滤器的类型。有 pre、 route、 post、 error等几种取值，分别对应上文的几种过滤器。详细可以参考 com.netflix.zuul.ZuulFilter.filterType()中的注释；
> 
> filter0rder: 返回一个 int值来指定过滤器的执行顺序，不同的过滤器允许返回相同的数字。
> 
> shouldFilter：返回一个 boolean值来判断该过滤器是否要执行， true表示执行， false表示不执行。
> 
> run：过滤器的具体逻辑；

### 2、Zuul 过滤器禁用 ###

Spring Cloud默认为Zuul编写并启用了一些过滤器，例如DebugFilter、 FormBodyWrapperFilter等，这些过滤器都存放在spring-cloud-netflix-zuul这个jar包里，一些场景下，想要禁用掉部分过滤器，该怎么办呢？ 只需在application.properties里设置zuul...disable=true 例如，要禁用上面我们写的过滤器，这样配置

#禁用过滤器
    zuul.LogFilter.route.disable=true

### 3、Zuul 异常处理 ###

Zuul 请求的生命周期图

![1a5c4318aac349639e35203ba7d2ff63.png][]

1、正常情况下所有的请求都是按照 pre、route、post 的顺序来执行，然后由 post 返回 response

2、在 pre 阶段，如果有自定义的过滤器则执行自定义的过滤器

3、pre、routing、post 的任意一个阶段如果抛异常了，则执行 error 过滤器，可以统一处理异常：

1、禁用 zuul 默认的异常处理 SendErrorFilter 过滤器

#禁用 zuul 默认的异常处理 SendErrorFilter 过滤器，然后自定义 Errorfilter 过滤器
    zuul.SendErrorFilter.error.disable=true

2、自定义Errorfilter 过滤器

public class ErrorFilter extends ZuulFilter {
        @Override
        public String filterType() {
            return "error";
        }
    
        @Override
        public int filterOrder() {
            return 1;
        }
    
        @Override
        public boolean shouldFilter() {
            return true;
        }
    
        @Override
        public Object run() throws ZuulException {
            try {
                RequestContext context = RequestContext.getCurrentContext();
                ZuulException exception = (ZuulException)context.getThrowable();
                System.out.println("进入系统异常拦截" + exception.getMessage());
    
                HttpServletResponse response = context.getResponse();
                response.setContentType("application/json; charset=utf8");
                response.setStatus(exception.nStatusCode);
    
                PrintWriter writer = null;
                try {
                    writer = response.getWriter();
                    writer.print("{code:"+ exception.nStatusCode +",message:\""+ exception.getMessage() +"\"}");
                } catch (IOException e) {
                    e.printStackTrace();
                } finally {
                    if(writer!=null){
                        writer.close();
                    }
                }
            } catch (Exception e) {
                ReflectionUtils.rethrowRuntimeException(e);
            }
    
            return null;
        }
    }

### 4、Zuul 熔断处理 ###

zuul是一个代理服务，但如果被代理的服务突然断了，这个时候zuul上面会有出错信息，例如，停止了被调用的微服务；一般服务方自己会进行服务的熔断降级，但对于zuul本身，也应该进行zuul的降级处理

我们需要一个zuul的降级

/**
     * zuul服务降级
     */
    @Component
    public class ZuulFallback implements FallbackProvider {
    
        @Override
        public String getRoute() {
            return "*";
        }
    
        @Override
        public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
            //匿名内部类实现ClientHttpResponse
            return new ClientHttpResponse() {
                @Override
                public HttpHeaders getHeaders() {
                    HttpHeaders headers = new HttpHeaders();
                    headers.set("Content-Type", "text/html; charset=UTF-8");
                    return headers;
                }
    
                @Override
                public InputStream getBody() throws IOException {
                    // 响应体
                    return new ByteArrayInputStream("服务正在维护，请稍后再试.".getBytes());
                }
    
                @Override
                public HttpStatus getStatusCode() throws IOException {
                    return HttpStatus.BAD_REQUEST;
                }
    
                @Override
                public int getRawStatusCode() throws IOException {
                    return HttpStatus.BAD_REQUEST.value();
                }
    
                @Override
                public String getStatusText() throws IOException {
                    return HttpStatus.BAD_REQUEST.getReasonPhrase();
                }
    
                @Override
                public void close() {
                    //关闭了response流，可以做一些清理工作
                }
            };
        }
    }

[SpringCloud - Spring Cloud_MinggeQingchun_-CSDN]: https://blog.csdn.net/MinggeQingchun/article/details/125273584?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22125273584%22%2C%22source%22%3A%22MinggeQingchun%22%7D&ctrtid=LyK5x
[https_blog.csdn.net_MinggeQingchun_article_details_125326667]: https://blog.csdn.net/MinggeQingchun/article/details/125326667
[512f149e1002426dba20209dca9d3d64.png]: https://img-blog.csdnimg.cn/512f149e1002426dba20209dca9d3d64.png
[1a5c4318aac349639e35203ba7d2ff63.png]: https://img-blog.csdnimg.cn/1a5c4318aac349639e35203ba7d2ff63.png