zuul概述及源码分析

àì夳堔傛蜴生んèń 2022-11-20 04:58 187阅读 0赞

# 一。 Zuul概述: #

Zuul路由是微服务架构的不可或缺的一部分，提供动态路由，监控，弹性，安全等的边缘服务。Zuul是Netflix出品的一个基于JVM路由和服务端的负载均衡器

zuul在集群中的地位如下图所示: Zuul扮演着”智能网关“的角色

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70][]

*  Zuul是接入网关，起到反向代理的作用，是外部消费者请求内部服务的唯一入口
 *  Zuul也具备过滤功能，通过在运行时注入过滤规则可实现用户鉴权、动态路由、灰度发布、A/B测试、负载限流等功能

# 二. zuul的核心: #

zuul由一系列的filters组成, 其作用类似Servlet框架的Filter，Zuul把客户端请求路由到业务处理逻辑的过程中，这些filter在路由的特定时期参与了一些过滤处理，比如实现鉴权、流量转发、请求统计等功能。Zuul的整个运行机制，可以用下图来描述:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 1][]

## 2.1 zuul有四种标准过滤器 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 2][]

*  Pre: 过滤规则在路由之前起作用。可以利用“Pre”过滤器实现用户鉴权，记录请求日志等；
 *   Routing：过滤规则在路由时发生作用。可以利用“Routing”过滤器实现动态路由、灰度发布、A/B测试、负载限流等。
 *   Post：过滤规则在路由之后发生作用。可以利用"Post"过滤器收集统计信息和指标，将微服务的相应写入Http响应并返回给服务消费者；
 *  Error：过滤规则路由过程中发生错误时发生作用。可以利用Error过滤器记录错误日志，并对错误进行二次处理等
 *  除了默认的过滤器类型，Zuul还允许我们创建自定义的过滤器类型

执行流程如下面

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 3][]

## 2.2 RequestContext ##

在过滤器之间用RequestContext传递消息。RequestContext存储的内容包括路由目标地址、错误信息、请求信息、响应信息等。Zuul的过滤规则也可以用基于JVM的语言编写，包括Java、Python、Groovy等

## 2.3 Zuul中默认实现的Filter ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 4][]

## 2.4 自定义实现Zuul Filter.  ##

public class MyFilter extends ZuulFilter {
        @Override
        String filterType() {
            return "pre"; // 定义filter的类型，有pre、route、post、error四种
        }
    
        @Override
        int filterOrder() {
            return 5; // 定义filter的顺序，数字越小表示顺序越高，越先执行
        }
    
        @Override
        boolean shouldFilter() {
            return true; // 表示是否需要执行该filter，true表示执行，false表示不执行
        }
    
        @Override
        Object run() {
            return null; // filter需要执行的具体操作
        }
    }

具体的Zuul学习案例可以参照Zuul官方的例子:   [https://github.com/Netflix/zuul][https_github.com_Netflix_zuul]

# 三. Zuul源码解析: #

## 3.1. 引入依赖，在启动类中添加@EnableZuulProxy，声明这是一个Zuul代理。 ##

@SpringCloudApplication
    @EnableZuulProxy
    public class ZuulApp {
    
        public static void main(String[] args) {
                SpringApplication.run(ZuulApp.class,args);
        }
    }

## 3. 2. 查看@EnableZuulProxy注解源码.  ##

//开启断路器(hystrix)
    @EnableCircuitBreaker
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Import(ZuulProxyMarkerConfiguration.class)
    public @interface EnableZuulProxy {
    
    }

## 3.3 org.springframework.cloud.netflix.zuul.ZuulProxyMarkerConfiguration类 ##

//让ZuulProxyMarkerConfiguration 配置生效
    @Configuration
    public class ZuulProxyMarkerConfiguration {
         //创建Marker 实例，让ZuulProxyMarkerConfiguration 配置生效
    	@Bean
    	public Marker zuulProxyMarkerBean() {
    		return new Marker();
    	}
    	class Marker {
    	}
    }

## 3.4 接着要查看spring-cloud-netflix-zuul.2.15.RELEASE.jar中的 spring.factories中配置的自动化加载的类 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 5][]

在自动加载类中: org.springframework.cloud.netflix.zuul.ZuulProxyAutoConfiguration的父类是org.springframework.cloud.netflix.zuul.ZuulServerAutoConfiguration

所以，先请看 ZuulServerAutoConfiguration 完成了什么

## 3.5 ZuulServerAutoConfiguration  类: 自动装配了以下的对象 ##

//注册一个zuulServlet
        @Bean
    	@ConditionalOnMissingBean(name = "zuulServlet")
    	@ConditionalOnProperty(name = "zuul.use-filter", havingValue = "false", matchIfMissing = true)
    	public ServletRegistrationBean zuulServlet() {
    		ServletRegistrationBean<ZuulServlet> servlet = new ServletRegistrationBean<>(
    				new ZuulServlet(), this.zuulProperties.getServletPattern());
    		// The whole point of exposing this servlet is to provide a route that doesn't
    		// buffer requests.
    		servlet.addInitParameter("buffer-requests", "false");
    		return servlet;
    	}
    
    	//注册一个zuulServletFilter
    	@Bean
    	@ConditionalOnMissingBean(name = "zuulServletFilter")
    	@ConditionalOnProperty(name = "zuul.use-filter", havingValue = "true", matchIfMissing = false)
    	public FilterRegistrationBean zuulServletFilter() {
    		final FilterRegistrationBean<ZuulServletFilter> filterRegistration = new FilterRegistrationBean<>();
    		filterRegistration.setUrlPatterns(
    				Collections.singleton(this.zuulProperties.getServletPattern()));
    		filterRegistration.setFilter(new ZuulServletFilter());
    		filterRegistration.setOrder(Ordered.LOWEST_PRECEDENCE);
    		// The whole point of exposing this servlet is to provide a route that doesn't
    		// buffer requests.
    		filterRegistration.addInitParameter("buffer-requests", "false");
    		return filterRegistration;
    	}

根据前面所分析的 zuul过滤器的执行流程，对zuul的请求一定会先调用  ZuulServlet, 它是一个标准的 HttpServlet, 根据Servlet生命周期，它一定会调用ZuulServlet的service方法.

## 3.6  ZuulServlet中的Service ##

public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
            try {
                this.init((HttpServletRequest)servletRequest, (HttpServletResponse)servletResponse);
                RequestContext context = RequestContext.getCurrentContext();
                context.setZuulEngineRan();
    
                try {
     //执行前置过滤器
                    this.preRoute();
                } catch (ZuulException var12) {
    //实现前置过滤器出错，则执行出错过滤器
                    this.error(var12);
     //执行后置过滤
                    this.postRoute();
                    return;
                }
    
                try {
                    this.route();
                } catch (ZuulException var13) {
                    this.error(var13);
                    this.postRoute();
                    return;
                }
    
                try {
                    this.postRoute();
                } catch (ZuulException var11) {
                    this.error(var11);
                }
            } catch (Throwable var14) {
                this.error(new ZuulException(var14, 500, "UNHANDLED_EXCEPTION_" + var14.getClass().getName()));
            } finally {
                RequestContext.getCurrentContext().unset();
            }
        }

## 3.7 不管是哪一种过滤器，调用的都是 ZuulRunner 中的方法 ##

void postRoute() throws ZuulException {
        this.zuulRunner.postRoute();
    }
    
    void route() throws ZuulException {
        this.zuulRunner.route();
    }
    
    void preRoute() throws ZuulException {
        this.zuulRunner.preRoute();
    }
    
    void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
        this.zuulRunner.init(servletRequest, servletResponse);
    }
    
    void error(ZuulException e) {
        RequestContext.getCurrentContext().setThrowable(e);
        this.zuulRunner.error();
    }

## 3.8  再查看zuulRunner中的实现会发现, 不管是哪一种过滤器，最后都会落到com.netflix.zuul.FilterProcessor\#runFilters ##

而再看runFilters会发现它是根据filter类型取出同属这一类的filter集合，再循环调用  processZuulFilter(   filter )执行的.

public Object runFilters(String sType) throws Throwable {
            if(RequestContext.getCurrentContext().debugRouting()) {
                Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
            }
    
            boolean bResult = false;
    //据filter类型，获取排过序的filter
            List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);
            if(list != null) {
                for(int i = 0; i < list.size(); ++i) {
     //处理filter执行
                    ZuulFilter zuulFilter = (ZuulFilter)list.get(i);
                    Object result = this.processZuulFilter(zuulFilter);
                    if(result != null && result instanceof Boolean) {
                        bResult |= ((Boolean)result).booleanValue();
                    }
                }
            }
    
            return Boolean.valueOf(bResult);
        }
    
    
    public Object processZuulFilter(ZuulFilter filter) throws ZuulException {
            RequestContext ctx = RequestContext.getCurrentContext();
            boolean bDebug = ctx.debugRouting();
            String metricPrefix = "zuul.filter-";
            long execTime = 0L;
            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();
                }
    //真正执行ZuulFilter内部方法
                ZuulFilterResult result = filter.runFilter();
                ExecutionStatus s = result.getStatus();
                execTime = System.currentTimeMillis() - ltime;
                switch(null.$SwitchMap$com$netflix$zuul$ExecutionStatus[s.ordinal()]) {
                case 1:
                    t = result.getException();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                    break;
                case 2:
                    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");
                        Debug.compareContextState(filterName, copy);
                    }
                }
    
                if(t != null) {
                    throw t;
                } else {
                    this.usageNotifier.notify(filter, s);
                    return o;
                }
            } catch (Throwable var15) {
                if(bDebug) {
                    Debug.addRoutingDebug("Running Filter failed " + filterName + " type:" + filter.filterType() + " order:" + filter.filterOrder() + " " + var15.getMessage());
                }
    
                this.usageNotifier.notify(filter, ExecutionStatus.FAILED);
                if(var15 instanceof ZuulException) {
                    throw (ZuulException)var15;
                } else {
                    ZuulException ex = new ZuulException(var15, "Filter threw Exception", 500, filter.filterType() + ":" + filterName);
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                    throw ex;
                }
            }
        }

这里留一个问题:   List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);

FilterLoader.getInstance()像是一个Filter加载器，它里面应该保存了所有的Filter实例。那它是在哪里完成这一步的????

## 3.9   真正执行ZuulFilter内部方法    ZuulFilterResult result = filter.runFilter(); ##

public ZuulFilterResult runFilter() {
            ZuulFilterResult zr = new ZuulFilterResult();
            if (!isFilterDisabled()) {
                if (shouldFilter()) {
                    Tracer t = TracerFactory.instance().startMicroTracer("ZUUL::" + this.getClass().getSimpleName());
                    try {
    //执行，run方法就是具体filter 实现的run方法
                        Object res = run();
                        zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS);
                    } catch (Throwable e) {
                        t.setName("ZUUL::" + this.getClass().getSimpleName() + " failed");
                        zr = new ZuulFilterResult(ExecutionStatus.FAILED);
                        zr.setException(e);
                    } finally {
                        t.stopAndLog();
                    }
                } else {
                    zr = new ZuulFilterResult(ExecutionStatus.SKIPPED);
                }
            }
            return zr;
        }

最后在runFilter()中可以看到它会调用具体的filter中的  run() 方法，这就是我们在自定义filter中的重写的run()方法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70]: /images/20221120/97965220602c41f0aba7364ce7502064.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 1]: /images/20221120/6cede000a49047ca952b78a1b72c3510.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 2]: /images/20221120/e3f9dca0206447aca9d3a3b2c550b5da.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 3]: /images/20221120/ba763dc804204e92983538d3e7f85b98.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 4]: /images/20221120/2cd1b12014904bdbb78d818218766b8e.png
[https_github.com_Netflix_zuul]: https://github.com/Netflix/zuul
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5neWluZ2NoZW5ncWk_size_16_color_FFFFFF_t_70 5]: /images/20221120/2812ee0bbd33462d94361d6eb59380fc.png