zuul1源码解析-请求处理流程

最新推荐文章于 2024-09-08 08:00:00 发布
最新推荐文章于 2024-09-08 08:00:00 发布
阅读量801 收藏
点赞数
分类专栏： zuul源码分析 文章标签： zuul 网关 zuul源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/missv5/article/details/91783178
版权

1.zuul是什么
Zuul 是 Netflix 开源的微服务网关，可以将非服务核心功能移至到网关中，比如：鉴权，请求日志等

2.zuul1系统架构图
zuul1系统架构
请求经过ZuulServlet，然后执行各种类型的过滤器链处理完毕之后，将处理后的结果响应出去。而且Zuul强化了其过滤器功能，支持热加载过滤器。

  1. 源码解析
    此次源码分析的版本是1.x，如果你看的是2.0版本以上的请忽略本文章。
    3.1 servlet源码解析
    我们知道一个web项目少不了一个servlet，它也是服务处理的入口和出口。所以先从ZuulServlet开始介绍。
public class ZuulServlet extends HttpServlet {

      private static final long serialVersionUID = -3374242278843351500L;
    // zuul执行器，ZuulServlet直接访问这个类的方法
    private ZuulRunner zuulRunner;

    /**
     * 初始化ZuulRunner
     * @param config
     * @throws ServletException
     */
    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        // 可以在servletConfig的配置中添加buffer-requests参数，表示缓存请求
        String bufferReqsStr = config.getInitParameter("buffer-requests");
        boolean bufferReqs = bufferReqsStr != null && bufferReqsStr.equals("true") ? true : false;
        // 创建ZuulRunner对象
        zuulRunner = new ZuulRunner(bufferReqs);
    }

    /**
     * 处理请求的核心方法
     * @param servletRequest 请求对象
     * @param servletResponse 响应对象
     * @throws ServletException
     * @throws IOException
     */
    @Override
    public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
        try {
            // 包装http请求和响应对象
            init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);

            // 请求上下文对象
            RequestContext context = RequestContext.getCurrentContext();
            // 表示zuul已经在执行
            context.setZuulEngineRan();

            try {
                // 执行路由的前置过滤器
                preRoute();
            } catch (ZuulException e) {
                // 如果执行出错，先执行错误处理，再执行后置过滤器
                error(e);
                postRoute();
                return;
            }
            try {
                route();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                postRoute();
            } catch (ZuulException e) {
                error(e);
                return;
            }

        } catch (Throwable e) {
            error(new ZuulException(e, 500, "UNHANDLED_EXCEPTION_" + e.getClass().getName()));
        } finally {
            RequestContext.getCurrentContext().unset();
        }
    }

    /**
     * executes "post" ZuulFilters
     *
     * @throws ZuulException
     */
    void postRoute() throws ZuulException {
        zuulRunner.postRoute();
    }

    /**
     * executes "route" filters
     *
     * @throws ZuulException
     */
    void route() throws ZuulException {
        zuulRunner.route();
    }

    /**
     * executes "pre" filters
     *
     * @throws ZuulException
     */
    void preRoute() throws ZuulException {
        zuulRunner.preRoute();
    }

    /**
     *  初始化请求对象
     *
     * @param servletRequest
     * @param servletResponse
     */
    void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
        zuulRunner.init(servletRequest, servletResponse);
    }

    /**
     * error过滤器
     *
     * @param e
     */
    void error(ZuulException e) {
        // 设置异常信息
        RequestContext.getCurrentContext().setThrowable(e);

        zuulRunner.error();
    }

3.1.1 处理流程
通过service方法，可以看出整个servlet的处理流程：
pre异常: pre -> error -> post
route异常： pre -> route -> error -> post
post异常： pre -> route -> post -> error
正常: pre -> route -> post
[说明]
pre:表示路由的前置过滤器链，route:表示路由的过滤器链，post:表示路由的后置过滤器链，error：表示路由错误过滤器链。
由此可见，责任链模式是zuul的核心(如果对这个设计模式不清楚的同学，可以参考：责任链模式）

3.1.2 各种过滤器类型解析
由于pre,post,route,error的最终处理逻辑都是一样的，所以只介绍pre过滤器。
上面调用preRoute方法时，最终会调用到ZuulRunner的preRoute方法。

ZuulServlet.java

    void preRoute() throws ZuulException {
        zuulRunner.preRoute();
    }

而Zuul执行preRoute时，又是调用FilterProcessor的方法。由于FilterProcessor创建多个实例是没有任何意义的，所以使用了单例模式(参考:单例模式)

ZuulRunner.java

   public void preRoute() throws ZuulException {
        FilterProcessor.getInstance().preRoute();
    }

FilterProcessor中又调用了自身的runFilters方法

FilterProcessor.java

    public void preRoute() throws ZuulException {
        try {
            runFilters("pre");
        } catch (ZuulException e) {
            throw e;
        } catch (Throwable e) {
            // 其他异常转换为ZuulException异常
            throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_PRE_FILTER_" + e.getClass().getName());
        }
    }

    /**
     *
     * 运行某种类型的所有过滤器
     *
     * @param sType 过滤器类型:pre,route,post,error
     * @return
     * @throws Throwable throws up an arbitrary exception
     */
    public Object runFilters(String sType) throws Throwable {
       if (RequestContext.getCurrentContext().debugRouting()) {
            // 如果开启了路由的请求日志 ，将日志添加到RequestContext对象中
            Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
        }
        boolean bResult = false;
        // 【1】
        List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                ZuulFilter zuulFilter = list.get(i);
                // 【2】
                Object result = processZuulFilter(zuulFilter);
                if (result != null && result instanceof Boolean) {
                    // 如果结果是布尔类型
                    bResult |= ((Boolean) result);
                }
            }
        }
        return bResult;
    }

通过上面的逻辑可以知道，过滤器运行的步骤：
(1) 添加路由日志
(2) 根据过滤器的优先级排序整个过滤器链
(3) 依次执行过滤器，如果是布尔类型汇总结果

关键位置分析：
【1】调用FilterLoader（获取改对象也是使用单例模式）的getFiltersByType方法

/**
     * 返回指定的过滤器类型的过滤器列表（已经排序）
     *
     * @param filterType 过滤器类型
     * @return a List<ZuulFilter>
     */
    public List<ZuulFilter> getFiltersByType(String filterType) {
        // 检查缓存
        List<ZuulFilter> list = hashFiltersByType.get(filterType);
        if (list != null) return list;

        list = new ArrayList<ZuulFilter>();
        // 通过注册器找到所有的过滤器(所以如果要添加过滤器需要添加到注册器中)，由于注册器的代码比较简单，所以这里不做介绍
        Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
        // 查找指定类型的过滤器
        for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
            ZuulFilter filter = iterator.next();
            if (filter.filterType().equals(filterType)) {
                // 类型相同
                list.add(filter);
            }
        }
        // 根据filterOrder排序
        Collections.sort(list); // sort by priority

        // 添加到缓存中
        hashFiltersByType.putIfAbsent(filterType, list);
        return list;
    }

【2】FilterProcessor.processZuulFilter方法介绍

 public Object processZuulFilter(ZuulFilter filter) throws ZuulException {

        RequestContext ctx = RequestContext.getCurrentContext();
        boolean bDebug = ctx.debugRouting();
        final String metricPrefix = "zuul.filter-";
        long execTime = 0;
        String filterName = "";
        try {
            long ltime = System.currentTimeMillis();
            // 过滤器名字
            filterName = filter.getClass().getSimpleName();
            
            RequestContext copy = null;
            Object o = null;
            Throwable t = null;

            if (bDebug) {
                Debug.addRoutingDebug("Filter " + filter.filterType() + " " + filter.filterOrder() + " " + filterName);
                // 在过滤器执行前添加快照
                copy = ctx.copy();
            }
            // 执行过滤器
            ZuulFilterResult result = filter.runFilter();
            // 获取执行状态
            ExecutionStatus s = result.getStatus();
            // 执行时间
            execTime = System.currentTimeMillis() - ltime;

            switch (s) {
                case FAILED:
                    // 执行失败
                    t = result.getException();
                    // context中添加过滤器的执行结果
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                    break;
                case SUCCESS:
                    // 执行成功
                    o = result.getResult();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.SUCCESS.name(), execTime);
                    if (bDebug) {
                        Debug.addRoutingDebug("Filter {" + filterName + " TYPE:" + filter.filterType() + " ORDER:" + filter.filterOrder() + "} Execution time = " + execTime + "ms");
                        // 用于记录过滤器是否添加了新的key到requestContext对象中
                        Debug.compareContextState(filterName, copy);
                    }
                    break;
                default:
                    break;
            }
            // 抛出异常
            if (t != null) throw t;
            // 过滤器结果通知
            usageNotifier.notify(filter, s);
            return o;

        } catch (Throwable e) {
            if (bDebug) {
                Debug.addRoutingDebug("Running Filter failed " + filterName + " type:" + filter.filterType() + " order:" + filter.filterOrder() + " " + e.getMessage());
            }
            // 过滤器结果通知
            usageNotifier.notify(filter, ExecutionStatus.FAILED);
            if (e instanceof ZuulException) {
                // ZuulException
                throw (ZuulException) e;
            } else {
                // 转换为ZuulException
                ZuulException ex = new ZuulException(e, "Filter threw Exception", 500, filter.filterType() + ":" + filterName);
                // 添加过滤器执行结果
                ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                throw ex;
            }
        }
    }

执行FilterProcessor.processZuulFilter的执行步骤：
(1) 记录requestContext的快照
(2) 执行真正执行过滤器
(3) 记录过滤器结果和状态，如果是执行成功，还记录requestContext增加的key
(4) 通知过滤器执行状态

现在来分析一下真正执行过滤器的逻辑，即ZuulFilter.runFilter:

ZuulFilter.java

    public ZuulFilterResult runFilter() {
        // 记录过滤器结果
        ZuulFilterResult zr = new ZuulFilterResult();
        if (!isFilterDisabled()) {
            // 过滤器有效
            if (shouldFilter()) {
                // 应该执行该过滤器

                // 开始记录轨迹
                Tracer t = TracerFactory.instance().startMicroTracer("ZUUL::" + this.getClass().getSimpleName());
                try {
                    // 运行过滤器并返回结果(新增的过滤器一定要重写这个方法)
                    Object res = run();
                    // 封装成Zuul过滤器结果对象(成功)
                    zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS);
                } catch (Throwable e) {
                    // 设置轨迹名称
                    t.setName("ZUUL::" + this.getClass().getSimpleName() + " failed");

                    // 封装成Zuul过滤器结果对象(异常)
                    zr = new ZuulFilterResult(ExecutionStatus.FAILED);
                    zr.setException(e);
                } finally {
                    // 停止轨迹记录
                    t.stopAndLog();
                }
            } else {
                // 如果不执行就表示跳过
                zr = new ZuulFilterResult(ExecutionStatus.SKIPPED);
            }
        }
        return zr;
    }
Zuul源码解读
虾米的博客
01-17 2663
最近这段时间在使用Zuul，顺便简单阅读了一下源码。本文旨在对自己阅读到的源码做一点小结，以后日后回顾。不追求面面俱到，细致入微，看到哪里写到哪里吧关于Zuul的介绍及基本使用就不在此赘述了，网上有很多这方面的文章入口：系统启动时处理@EnableZuulProxy，重点是其中的ZuulProxyConfiguration.class底层http库：ZuulProxyConfiguration.c
SpringCloud 网关组件 Zuul-1.0 原理深度解析
BASK2311的博客
12-24 1186
Zuul 是 Spring Cloud 中的微服务网关，是为微服务架构中的服务提供了统一的访问入口。Zuul 本质上是一个Web servlet应用，为微服务架构中的服务提供了统一的访问入口，客户端通过 API 网关访问相关服务。
zuul源码解析
qq1805696978的博客
10-06 628
zuul——springcloud的网关。如果看过我之前的博客，可以知道feign的坑是比较多的，但是网关这块做的是比较好的，不管是性能还是灵活性。 一、网关的作用：        ①路由        ②利用filter可以实现限流（也可以使用ratelimit），鉴权，验签，黑白名单，对请求处理等等。 二、zuul源码及其工作流程： 我们首先从开启网关注解进行跟踪——@EnableZ...
Zuul详细解释
最新发布
Flying_Fish_roe的博客
09-08 1815
除了使用serviceIdspring:cloud:zuul:routes:这种配置表示：所有匹配的请求将被路由到外部的服务。要编写自定义过滤器，需要继承ZuulFilter：过滤器类型。它决定了过滤器在哪个阶段执行（前置、路由、后置、错误）。：过滤器的执行顺序。：判断过滤器是否需要执行。run()：过滤器的具体逻辑。@Component@Override// 前置过滤器@Overridereturn 1;// 执行顺序@Override// 是否启用过滤器@Override。
zuul源码分析
donglebron的专栏
09-05 512
Zuul请求处理流程 zuul框架在处理http请求时，由springmvc所管理，一起看下具体流程： 请求由DispatchServlet分发，查找HandlerMapping，zuul框架定义了ZuulHandlerMapping，它是将路由规则绑定到了ZuulController上面； 查找HandlerMappingAdapter映射器处理器，由SimpleControllerH...
zuul源码分析-探究原生zuul的工作原理
weixin_30387339的博客
09-15 240
前提 最近在项目中使用了SpringCloud，基于zuul搭建了一个提供加解密、鉴权等功能的网关服务。鉴于之前没怎么使用过Zuul，于是顺便仔细阅读了它的源码。实际上，zuul原来提供的功能是很单一的：通过一个统一的Servlet入口(ZuulServlet，或者Filter入口，使用ZuulServletFilter)拦截所有的请求，然后通过内建的com.netflix.zuul.I...
zuul-2.1.3.zip
05-18
学习Zuul源码有助于我们定制化开发，例如实现自定义过滤器，或对接特定的身份认证系统。同时，理解Zuul的工作原理也有助于我们在微服务架构中更好地部署和维护API网关。 总结，Zuul 2.1.3作为一款优秀的API网关，其...
SpringCloud-Zuul（二）：自定义Filter及内部路由源码解析
jsbintask的博客
04-03 533
本文原创地址，我的博客：https://jsbintask.cn/2019/04/03/springcloud/springcloud-zuul-customfilters/(食用效果最佳)，转载请注明出处! 前言 上一篇介绍了SpringCloud使用Zuul的调用流程,明白了Zuul的工作原理关键在于ZuulServlet和它的内置Filter，所以在实际工作中，编写业务逻辑的关键就在...
SpringCloud- 第十三篇 Zuul高层架构(二)
weixin_48598018的博客
07-22 218
1：架构图 2：ZuulServlet Zuul的核心是一系列的filters，Zuul大部分功能都是通过过滤器来实现的 1：ZuulServlet是Zuul的核心类，用来调度不同阶段的filters，处理请求，并处理异常等，路径是/zuul，可以使用zuul.servlet-path属性更改此路径 2：功能类似于SpringMvc的DispatcherServlet，所有的Request都要经过它的处理 3：里面有三个核心方法：preRoute(),route(), postRoute()
第六章 Zuul网关路由及源码分析笔记
hankin的博客
03-24 873
前面所有的微服务都是通过Eureka找到的，但是在很多开发中为了规范微服务的使用，提供有一个处理控制器Zuul。Zuul其实是一个API网关，类似于设计模式里面的Facade门面模式，他的存在就像是整个微服务的门面，所有的外部客户端访问都需要经过它来进行调度与过滤。 代码Git地址：https://gitee.com/hankin_chj/springcloud-micro-service.gi...
zuul-2.1.5:zuul原始码解析-源码解析
03-24
祖尔 Zuul是一种边缘服务，提供动态路由，监视，弹性，安全性等 原始解析目录 1，zuul使用场景，主要实现技术栈，系统架构整体概述（含系统架构图） 2，动态路由，静态路由，鉴权，限流等实战..... 3，从0到1实现一个网关
Zuul的核心源码解析
qq_29860591的博客
02-09 254
在 Zuul中， 整个请求的过程是这样的，首先将请求给zuulservlet处理，zuulservlet中有一个zuulRunner对象，该对象中初始化了RequestContext：作为存储整个请求的一些数据，并被所有的zuulfilter共享。zuulRunner中还有 FilterProcessor，FilterProcessor作为执行所有的zuulfilter的管...
zuul 1.x 源码解析
weixin_33912246的博客
06-15 176
2019独角兽企业重金招聘Python工程师标准>>> ...
zuul概述及源码分析
ForestCat的专栏
11-07 1269
一。 Zuul概述: Zuul路由是微服务架构的不可或缺的一部分，提供动态路由，监控，弹性，安全等的边缘服务。Zuul是Netflix出品的一个基于JVM路由和服务端的负载均衡器 zuul在集群中的地位如下图所示:Zuul扮演着”智能网关“的角色 Zuul是接入网关，起到反向代理的作用，是外部消费者请求内部服务的唯一入口 Zuul也具备过滤功能，通过在运行时注入过滤规则可实现用户鉴权、动态路由、灰度发布、A/B测试、负载限流等功能 二. zuul的核心: zuul由一系列的filters...
ZuulServlet源码分析及ZuulFilter加载
bajiaoyan5785的博客
06-26 98
参考https://yq.aliyun.com/wenji/2...https://blog.csdn.net/lds2227... 1.声明ZuulServlet @Configuration @EnableConfigurationProperties({ZuulProperties.class}) @ConditionalOnClass(ZuulServlet.clas...
zuul源码（2）
weixin_34377065的博客
11-18 259
路由 路由是网关的核心功能，既然在spring的框架下，那就要按Spring的规矩来。 路由规则类：org.springframework.cloud.netflix.zuul.filters.Route 维护这以下信息： private String id; private String fullPath; private String path; private String locat...
Zuul 一
文报的博客
02-09 344
Zuul 网关，联想一下就和海关之类的差不多，可以帮我们拦截一些非法请求，或者未授权的请求等等。Zuul网关还有一个作用就是让用户的请求不直接和微服务挂钩，而是通过Zuu网关去分发请求。首先通过我们之前的学习，可以搭建一个初步的架构在该架构中，我们的服务集群包含内部服务ServiceA和ServiceB, 它们都会向EurekaServer集群进行注册与订阅服务，而OpenService是一个对外...
Zuul1.x核心源码解析
hxt的博客
11-07 411
1、Zuul架构图 如上图，Zuul网关分为三个部分：过滤器管理模块（绿色模块）、过滤器加载模块（粉红色模块）、过滤器运行时模块（蓝色模块） 1）过滤器管理模块：让开发人员管理过滤器，过滤器管理主要是上传的动作和激活的动作。过滤器上传完是保存到数据库中的，开发人员可以通过界面管理过滤器的状态 2）过滤器加载模块：是过滤器加载模块。定期的扫描过滤器，看看过滤器有没有变更。过滤器管理器会先将变更的过滤器拉到本地的过滤器目录当中。如果变更了，就会执行Filter Loader进行加载，加载到网关运行时的Filt
Spring Cloud与Spring MVC整合Mybatis项目源码解析
1. **项目开发流程**： - 在Spring Cloud框架下搭建微服务架构。 - 使用Spring MVC处理前端发送的请求。 - 通过Mybatis实现数据库持久化操作。 2. **项目中电子商务的应用**： - 电子商务系统通常需要实现商品...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值