zuul实现模块异常统一拦截返回

参考地址：https://www.cnblogs.com/linjiqin/p/10202085.html

zuul网关中根据过滤器的生命周期有以下类型的过滤器：

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

b、routing: 这种过滤器将请求路由到微服务。这种过滤器用于构建发送给微服务的请求，并使用apache httpclient或netflix ribbon请求微服务。

c、post: 这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的http header、收集统计信息和指标、将响应从微服务发送给客户端等。

e、error: 在其他阶段发送错误时执行该过滤器。

除了默认的过滤器类型，zuul还允许创建自定义的过滤器类型。例如，可以定制一种static类型的过滤器，直接在zuul中生成响应，而不将请求转发到后端的微服务。

zuul请求的生命周期如下图，该图详细描述了各种类型的过滤器的执行顺序。

1、自定义pre过滤器@Component@Slf4j

public class MyZuulFilter extends ZuulFilter {

    //过滤器类型
    @Override
    public String filterType() {
        return "pre";
    }
    //zuul-core中的FilterLoader.java的getFilterByType中按类型pre、route、post取Filter后，再按照FilterOrder进行排序。
    //先执行pre>routing>post 然后再在同类型的过滤器按照order大小执行，越小的越先被执行
    @Override
    public int filterOrder() {
        return 0;
    }

    //过滤器是否执行，false不执行
    @Override
    public boolean shouldFilter() {
        return true;
    }

    //自定义执行逻辑
    @Override
    public Object run() throws ZuulException {
        RequestContext requestContext = RequestContext.getCurrentContext();
        HttpServletRequest request = requestContext.getRequest();

        log.info("自定义zuulFilter:" + request.getRequestURI());

        return null;
    }
}

2、自定义error过滤器

/**
 * @classname: MyErrorFilter
 * @desc: 异常过滤器：当请求发送异常时，调用该过滤器
 * @author: YZ
 * @date: 2020/5/26 14:14
 * @version: 1.0
 **/
@Component
@Slf4j
public class MyErrorFilter extends SendErrorFilter {


    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        ZuulException e = (ZuulException) findZuulException(ctx.getThrowable()).getThrowable();
        log.error("请求失败：", e);
        ctx.remove("throwable");
        ctx.set("message", e.getMessage());
        return null;
    }
}

3、自定义post过滤器

该过滤器只要设置为true，就一定会执行（即使执行了error过滤器）,在这里实现结果统一封装返回。

/**
 * @classname: MyErrorFilter
 * @desc: 后置过滤器：检验请求是否成功
 * @author: YZ
 * @date: 2020/5/26 14:14
 * @version: 1.0
 **/
@Component
@Slf4j
public class MyPostFilter extends ZuulFilter {


    @Autowired
    private SendResponseFilter sendResponseFilter;

    @Override
    public String filterType() {
        return FilterConstants.POST_TYPE;
    }

    @Override
    public int filterOrder() {
        return FilterConstants.SEND_RESPONSE_FILTER_ORDER;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletResponse response = ctx.getResponse();
        //只处理非200
        if (response.getStatus() != HttpStatus.OK.value()) {
            if (response.getStatus() != HttpStatus.UNAUTHORIZED.value()) {
                //返回状态非401的都改为200
                response.setStatus(HttpStatus.OK.value());
            }
            response.setHeader("Content-Type", "application/json");
            Object message = ctx.get("message");
            InputStream is;
            InputStreamReader ir;
            BufferedReader streamReader;
            List<Closeable> closeables = null;
            String msg = null;
            try (OutputStream out = response.getOutputStream()) {
                if (null != message) {
                    msg = message.toString();
                } else {
                    closeables = new ArrayList<>(3);
                    is = ctx.getResponseDataStream();
                    closeables.add(is);
                    ir = new InputStreamReader(is);
                    closeables.add(ir);
                    streamReader = new BufferedReader(ir);
                    closeables.add(streamReader);

                    StringBuilder respomseStrBuilder = new StringBuilder();
                    String inputStr = "";
                    while ((inputStr = streamReader.readLine()) != null) {
                        respomseStrBuilder.append(inputStr);
                    }
                    JSONObject jsonObject = JSONObject.parseObject(respomseStrBuilder.toString());
                    JSONArray errors;
                    //获取错误信息
                    if (null != (errors = jsonObject.getJSONArray("errors"))) {
                        String defaultMessage = errors.getJSONObject(0).getString("defaultMessage");
                        if (null != defaultMessage) {
                            msg = defaultMessage;
                        }
                    }
                    if (null == msg) {
                        msg = jsonObject.getString("message");
                    }
                    if (null == msg) {
                        msg = jsonObject.getString("error_description");
                    }
                    log.error("请求失败：{}", msg);
                }
                IOUtils.write(JSON.toJSONString(ResponseData.failed("请求失败：" + msg)).getBytes(StandardCharsets.UTF_8), out);
            } catch (IOException e) {
                log.error("请求失败：", e);
            } finally {
                //关闭流
                if (!CollectionUtil.isEmpty(closeables)) {
                    closeables.forEach(closeable -> {
                        if (null != closeable) {
                            try {
                                closeable.close();
                            } catch (IOException e) {
                            }
                        }
                    });
                }
            }
        } else {
            //使用默认的post拦截器
            sendResponseFilter.run();
        }
        return null;
    }

}

4、禁用zuul默认的过滤器

即使自定义了过滤器，如果不经用zuul的默认过滤器，默认过滤器也会被执行，造成结果被篡改。

禁用语法：zuul.filter名称.disable=true

#禁用指定过滤器
zuul:
  SendResponseFilter:
    post:
      disable: true
  SendErrorFilter:
    error:
      disable: true