官方图
1.Servlet
zuul.servletPath默认配置为/zuul,故请求为/zuul开头的会跳过dispatcherServlet直接进入ZuulServlet,该配置可以自定义配置,例如用于大文件上传
2.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 { //运行pre过滤器 this.preRoute(); } catch (ZuulException var12) { //有异常,执行errorFilter this.error(var12); //再执行postFilter this.postRoute(); return; } try { //运行rote过滤器 this.route(); } catch (ZuulException var13) { //有异常,执行errorFilter this.error(var13); //再执行postFilter this.postRoute(); return; } try { //运行post过滤器 this.postRoute(); } catch (ZuulException var11) { //有异常,执行errorFilter this.error(var11); } } catch (Throwable var14) { this.error(new ZuulException(var14, 500, "UNHANDLED_EXCEPTION_" + var14.getClass().getName())); } finally { RequestContext.getCurrentContext().unset(); } }
3.FilterProcessor
其运行交由FilterProcessor中的方法runFilters,根据service中的顺序,取不同的filter类型,执行其中的run方法
public Object runFilters(String sType) throws Throwable { if (RequestContext.getCurrentContext().debugRouting()) { Debug.addRoutingDebug("Invoking {" + sType + "} type filters"); } boolean bResult = false; List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType); if (list != null) { for(int i = 0; i < list.size(); ++i) { ZuulFilter zuulFilter = (ZuulFilter)list.get(i); Object result = this.processZuulFilter(zuulFilter);//见下面zuulFilter的runFilter() if (result != null && result instanceof Boolean) { bResult |= ((Boolean)result).booleanValue(); } } } return bResult; }
zuulFilter的runFilter方法，当filter的shouldFilter()返回true时才执行run()方法
public ZuulFilterResult runFilter() { ZuulFilterResult zr = new ZuulFilterResult(); if (!this.isFilterDisabled()) { if (this.shouldFilter()) { Tracer t = TracerFactory.instance().startMicroTracer("ZUUL::" + this.getClass().getSimpleName()); try { Object res = this.run(); zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS); } catch (Throwable var7) { t.setName("ZUUL::" + this.getClass().getSimpleName() + " failed"); zr = new ZuulFilterResult(ExecutionStatus.FAILED); zr.setException(var7); } finally { t.stopAndLog(); } } else { zr = new ZuulFilterResult(ExecutionStatus.SKIPPED); } } return zr; }
4.获取过滤器FilterRegistry
其中的属性private final ConcurrentHashMap<String, ZuulFilter> filters = new ConcurrentHashMap();
保存所有的过滤器
例子中有12个(其中有两个为自定义的)：
[org.springframework.cloud.netflix.zuul.filters.route.SimpleHostRoutingFilter@3dc68586, org.springframework.cloud.netflix.zuul.filters.pre.Servlet30WrapperFilter@4001d8c1, org.springframework.cloud.netflix.zuul.filters.pre.ServletDetectionFilter@60dc1a4e, org.springframework.cloud.netflix.zuul.filters.pre.PreDecorationFilter@7a2fce12, com.example.springbootzuul.filters.AuthFilter@14fc9bd, org.springframework.cloud.netflix.zuul.filters.pre.DebugFilter@74960e9d, org.springframework.cloud.netflix.zuul.filters.post.SendResponseFilter@61037caf, org.springframework.cloud.netflix.zuul.filters.pre.FormBodyWrapperFilter@3c88191b, org.springframework.cloud.netflix.zuul.filters.post.SendErrorFilter@670342a2, com.example.springbootzuul.filters.LoginPostFilter@7ed49a7f, org.springframework.cloud.netflix.zuul.filters.route.RibbonRoutingFilter@357bc488, org.springframework.cloud.netflix.zuul.filters.route.SendForwardFilter@d5e575c]
5.各个filter作用
pre过滤器:
org.springframework.cloud.netflix.zuul.filters.pre.ServletDetectionFilter:
该过滤器order值为-3，是pre阶段第一个过滤器，并且总是会运行。主要用途是判断该请求是被spring的DispatcherServlet处理还是被zuul的ZuulServlet处理，并且将判断结果设置到context中，后续处理中可以依照此结果进行个性化处理
org.springframework.cloud.netflix.zuul.filters.pre.Servlet30WrapperFilter:
该过滤器order值为-2，是pre阶段第二个过滤器，并且总是会运行。Zuul默认仅对servlet2.5兼容，该过滤器可以将request包装成3.0兼容的形式
org.springframework.cloud.netflix.zuul.filters.pre.FormBodyWrapperFilter:
该过滤器order值为-1，是pre阶段第三个过滤器，仅针对两类请求生效，第一种是Context-Type为application/x-www-form-urlencoded，第二种是由spring的DispatcherServlet处理的Context-Type为multipart/form-data的请求。该过滤器的主要目的是将上述两种请求包装成FormBodyRequestWrapper
org.springframework.cloud.netflix.zuul.filters.pre.DebugFilter:
该过滤器order值为1，是pre阶段第四个过滤器，仅在请求参数中出现debug=true（参数名称可设置）时执行。具体执行逻辑就是在context中设置debugRouting=true及debugRequest=true。在后续执行中可以通过这两个值来预埋一些debug信息，用于出现问题时提供排查所需的信息
org.springframework.cloud.netflix.zuul.filters.pre.PreDecorationFilter:
该过滤器order值为5，是pre阶段最后一个过滤器，仅在forward.to和serviceId都没有出现在context中的时候才执行。具体来说就是对请求做一些预处理，包括使用RouteLocator获取路由信息，在context中设置一些后续处理需要的信息，还有就是在请求头中添加一些代理信息，比如X-Forwarded-For
com.example.springbootzuul.filters.AuthFilter 自定义的。。
route:
org.springframework.cloud.netflix.zuul.filters.route.RibbonRoutingFilter:
该过滤器order值为10，是route阶段第一个过滤器，仅在context中存在serviceId的情况下运行。存在serviceId，就是说需要面向服务进行路由，服务的路由信息就是我们上面讲过的两种方式，配置文件（静态）及服务注册。具体就是创建RibbonCommandContext，然后交由ribbon和hystrix向下游服务进行请求
org.springframework.cloud.netflix.zuul.filters.route.SimpleHostRoutingFilter:
该过滤器order值为100，是route阶段第二个过滤器，仅在context中存在routeHost的情况下运行。存在routeHost，就是说我们配置了具体的http或者https url的请求信息。具体逻辑就是通过HttpClient直接向目标url发起请求，不再经过ribbon及hystrix，所以也就没有负载均衡以及熔断
org.springframework.cloud.netflix.zuul.filters.route.SendForwardFilter:
该过滤器order值为500，是route阶段第三个（最后一个）过滤器，仅在context中存在forward.to的情况下运行。存在forward.to，就是说我们配置了类似forward:/index的请求信息。具体就是通过RequestDispatcher进行forward
post:
com.example.springbootzuul.filters.LoginPostFilter 自定义的。。
org.springframework.cloud.netflix.zuul.filters.post.SendResponseFilter:
该过滤器order值为1000，是post阶段最后一个过滤器，仅在context中存在zuulResponseHeaders、responseDataStream、responseBody（三者是或的关系）的情况下运行，简单来说，就是在有响应数据的时候运行。我们以responseBody举例，来看下responseBody是什么时候被设置到context中的。还记得RibbonRoutingFilter吧，在他的run方法中会调用一个setResponse方法，responseBody就是在这个方法中被设置到context中
error:
org.springframework.cloud.netflix.zuul.filters.post.SendErrorFilter@670342a2,
该过滤器order值为0，是error阶段唯一一个过滤器，仅在context中存在throwable的情况下运行，也就是说有异常产生的情况下运行。将错误状态码、错误信息、异常对象设置到request中，然后forward到/error（默认，可配置）。之后我们可以自己定义一个/error端口对错误进行响应
6.关于路由处理
6.1 Zuul在自动配置加载时注入了2个RouteLocator
CompositeRouteLocator:是 @Primary的,它是组合多个RouteLocator的Locator
DiscoveryClientRouteLocator:存放至CompositeRouteLocator的属性routeLocators中,当调用RouteLocator时会调用CompositeRouteLocator中的
DiscoveryClientRouteLocator中的locateRoutes方法运行后就已经加载了配置文件中所有路由信息，以及注册中心中的服务路由信息，有的通过URL路由，有的通过serviceId路由
protected LinkedHashMap<String, ZuulRoute> locateRoutes() { //保存ZuulRoute的LinkedHashMap LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap<String, ZuulRoute>(); //调用父类SimpleRouteLocator#locateRoutes() //加载ZuulProperties中的所有配置文件中的路由信息 routesMap.putAll(super.locateRoutes()); //如果服务发现客户端discovery存在 if (this.discovery != null) { //将routesMap已经存在的配置文件中的ZuulRoute放入staticServices<serviceId, ZuulRoute> Map<String, ZuulRoute> staticServices = new LinkedHashMap<String, ZuulRoute>(); for (ZuulRoute route : routesMap.values()) { String serviceId = route.getServiceId(); //如果serviceId为null，以id作为serviceId，此情况适合 zuul.routes.xxxx=/xxxx/** 的情况 if (serviceId == null) { serviceId = route.getId(); } if (serviceId != null) { staticServices.put(serviceId, route); } } // Add routes for discovery services by default List<String> services = this.discovery.getServices(); //到注册中心找到所有service String[] ignored = this.properties.getIgnoredServices() .toArray(new String[0]); //遍历services for (String serviceId : services) { // Ignore specifically ignored services and those that were manually // configured String key = "/" + mapRouteToService(serviceId) + "/**"; //如果注册中心的serviceId在staticServices集合中，并且此路由没有配置URL //那么，更新路由的location为serviceId if (staticServices.containsKey(serviceId) && staticServices.get(serviceId).getUrl() == null) { // Explicitly configured with no URL, cannot be ignored // all static routes are already in routesMap // Update location using serviceId if location is null ZuulRoute staticRoute = staticServices.get(serviceId); if (!StringUtils.hasText(staticRoute.getLocation())) { staticRoute.setLocation(serviceId); } } //如果注册中心的serviceId不在忽略范围内，且routesMap中还没有包含，添加到routesMap //(例子中的配置#忽略所有服务 ignoredServices: '*') if (!PatternMatchUtils.simpleMatch(ignored, serviceId) && !routesMap.containsKey(key)) { // Not ignored routesMap.put(key, new ZuulRoute(key, serviceId)); } } } // 如果routesMap中有 /** 的默认路由配置 if (routesMap.get(DEFAULT_ROUTE) != null) { ZuulRoute defaultRoute = routesMap.get(DEFAULT_ROUTE); // Move the defaultServiceId to the end routesMap.remove(DEFAULT_ROUTE); routesMap.put(DEFAULT_ROUTE, defaultRoute); } //将routesMap中的数据微调后，放到values<String, ZuulRoute>，返回 LinkedHashMap<String, ZuulRoute> values = new LinkedHashMap<>(); for (Entry<String, ZuulRoute> entry : routesMap.entrySet()) { String path = entry.getKey(); // Prepend with slash if not already present. if (!path.startsWith("/")) { path = "/" + path; } if (StringUtils.hasText(this.properties.getPrefix())) { path = this.properties.getPrefix() + path; if (!path.startsWith("/")) { path = "/" + path; } } values.put(path, entry.getValue()); } return values; }
6.2 路由前的预处理:PreDecorationFilter.run()
public Object run() { RequestContext ctx = RequestContext.getCurrentContext(); final String requestURI = this.urlPathHelper.getPathWithinApplication(ctx.getRequest()); Route route = this.routeLocator.getMatchingRoute(requestURI); //如下.找到匹配的路由 // ==== 匹配到路由信息 if (route != null) { String location = route.getLocation(); if (location != null) { /** //RequestContext设置 requestURI：路由的pattern路径 //RequestContext设置 proxy：路由id //设置需要忽略的敏感头信息，要么用全局默认的，要么用路由自定义的 //设置重试信息 //如果location是 http/https开头的，RequestContext设置 routeHost：URL //如果location是 forward:开头的，RequestContext设置 forward信息、routeHost：null //其它 RequestContext设置 serviceId、routeHost：null、X-Zuul-ServiceId //是否添加代理头信息 X-Forwarded-For //是否添加Host头信息 */ } } // ==== 没有匹配到路由信息 else { /**............*/ } return null; }
RouteLocator.getMatchingRoute(requestURI)
public Route getMatchingRoute(final String path) { return getSimpleMatchingRoute(path); } protected Map<String, ZuulRoute> getRoutesMap() { if (this.routes.get() == null) { this.routes.set(locateRoutes()); } return this.routes.get(); } protected Route getSimpleMatchingRoute(final String path) { //未初始化则初始化 getRoutesMap(); //获取准确的path:根据servlet的类型将path中的serveletPath截取掉 String adjustedPath = adjustPath(path); //通过path匹配已初化的ZuulRoute ZuulRoute route = getZuulRoute(adjustedPath); //通过ZuulRoute 获取route return getRoute(route, adjustedPath); }
在获取Zuulroute后通过getRoute获取到最后的Route
protected Route getRoute(ZuulRoute route, String path) { if (route == null) { return null; } String targetPath = path; //配置的前缀prefix String prefix = this.properties.getPrefix(); if(prefix.endsWith("/")) { prefix = prefix.substring(0, prefix.length() - 1); } //访问path以前缀开头且配置截取前缀为true(不配置默认为true),截取前缀 if (path.startsWith(prefix + "/") && this.properties.isStripPrefix()) { targetPath = path.substring(prefix.length()); } //配置截取前缀为true(不配置默认为true) if (route.isStripPrefix()) { //路由path有通配符 int index = route.getPath().indexOf("*") - 1; if (index > 0) { //最后的targetPath即为各个服务里的路径 String routePrefix = route.getPath().substring(0, index); targetPath = targetPath.replaceFirst(routePrefix, ""); prefix = prefix + routePrefix; } } //标记是否默认支持重试(未配置默认false) Boolean retryable = this.properties.getRetryable(); if (route.getRetryable() != null) { retryable = route.getRetryable(); } return new Route(route.getId(), targetPath, route.getLocation(), prefix, retryable, route.isCustomSensitiveHeaders() ? route.getSensitiveHeaders() : null, route.isStripPrefix()); }
6.3 处理路由
RibbonRoutingFilter:使用Ribbon、Hystrix和可插入的http客户端发送请求
public Object run() { RequestContext context = RequestContext.getCurrentContext(); this.helper.addIgnoredHeaders(); try { RibbonCommandContext commandContext = buildCommandContext(context); ClientHttpResponse response = forward(commandContext); setResponse(response); return response; } catch (ZuulException ex) { throw new ZuulRuntimeException(ex); } catch (Exception ex) { throw new ZuulRuntimeException(ex); } }
SimpleHostRoutingFilter:简单路由，通过HttpClient向预定的URL发送请求
public Object run() { RequestContext context = RequestContext.getCurrentContext(); HttpServletRequest request = context.getRequest(); MultiValueMap<String, String> headers = this.helper .buildZuulRequestHeaders(request); MultiValueMap<String, String> params = this.helper .buildZuulRequestQueryParams(request); String verb = getVerb(request); InputStream requestEntity = getRequestBody(request); if (request.getContentLength() < 0) { context.setChunkedRequestBody(); } String uri = this.helper.buildZuulRequestURI(request); this.helper.addIgnoredHeaders(); try { CloseableHttpResponse response = forward(this.httpClient, verb, uri, request, headers, params, requestEntity); setResponse(response); } catch (Exception ex) { throw new ZuulRuntimeException(ex); } return null; }
SendForwardFilter:forward到本地URL
public Object run() { try { RequestContext ctx = RequestContext.getCurrentContext(); String path = (String) ctx.get(FORWARD_TO_KEY); RequestDispatcher dispatcher = ctx.getRequest().getRequestDispatcher(path); if (dispatcher != null) { ctx.set(SEND_FORWARD_FILTER_RAN, true); if (!ctx.getResponse().isCommitted()) { dispatcher.forward(ctx.getRequest(), ctx.getResponse()); ctx.getResponse().flushBuffer(); } } } catch (Exception ex) { ReflectionUtils.rethrowRuntimeException(ex); } return null; }
7.其他重要组件
FilterRegistry:使用ConcurrentHashMap存储全部的filter
RequestContext:请求上下文对象,继承于ConcurrentHashMap<String, Object>,用于请求时的所有参数或其他信息,该对象放入线程中的,故在各个filter中都可获取到
//注意这里的ThreadLocal实例的initialValue()方法，当ThreadLocal的get()方法返回null的时候总是会调用initialValue()方法
protected static final ThreadLocal<? extends RequestContext> threadLocal = new ThreadLocal<RequestContext>() { @Override protected RequestContext initialValue() { try { return contextClass.newInstance(); } catch (Throwable e) { throw new RuntimeException(e); } } }; public RequestContext() { super(); } public static RequestContext getCurrentContext() { /**省略*/ if (testContext != null) return testContext; //当ThreadLocal的get()方法返回null的时候总是会调用initialValue()方法，所以这里是"无则新建RequestContext"的逻辑 RequestContext context = threadLocal.get(); return context; }
参考资料:
https://www.cnblogs.com/liangzs/p/8946740.html
https://www.jianshu.com/p/2cc9e2ba2256