SpringCloud-Zuul源码分析和路由改造

在使用SpringCloud的时候准备使用Zuul作为微服务的网关，Zuul的默认路由方式主要是两种，一种是在配置 文件里直接指定静态路由，另一种是根据注册在Eureka的服务名自动匹配。比如如果有一个名为service1的服 务，通过 http://www.domain.com/service1/xxx 就能访问到这个服务。但是这和我预想的需求还是有些差距。 网上有许多有关动态路由的实现方法，大致思想是不从Eureka拉取注册服务信息，而是在数据库里自己维护一 份路由表，定时读取数据库拉取路由，来实现自动更新。而我的需求更进一步，我希望对外暴露的网关接口是 一个固定的url，如http://www.domain.com/gateway ，然后根据一个头信息service来指定想要访问的服务，而不是在 url后面拼接服务名。同时我也不想将我注册到Eureka的服务名直接暴露在api中，而是做一层映射，让我可以 灵活指定serivce名。

例如：

• 访问 http://www.domain.com/gateway ,headers包含service=service.a，调用后端service1
• 访问 http://www.domain.com/gateway ,headers包含service=service.b，调用后端service2

现在研究一下Zuul的源码来看看怎么实现这个功能。

我们都知道在Springboot启动类上加一个@EnableZuulProxy就启用了Zuul。从这个注解点进去看看：

@EnableCircuitBreaker
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(ZuulProxyMarkerConfiguration.class)
public @interface EnableZuulProxy {
}

它引入了ZuulProxyMarkerConfiguration这个配置，进去看下。

/**
 * Responsible for adding in a marker bean to trigger activation of
 * {@link ZuulProxyAutoConfiguration}.
 *
 * @author Biju Kunjummen
 */

@Configuration
public class ZuulProxyMarkerConfiguration {

    @Bean
    public Marker zuulProxyMarkerBean() {
        return new Marker();
    }

    class Marker {

    }

}

从注释中看到这个是用于激活ZuulProxyAutoConfiguration，看看这个类

@Configuration
@Import({ RibbonCommandFactoryConfiguration.RestClientRibbonConfiguration.class,
        RibbonCommandFactoryConfiguration.OkHttpRibbonConfiguration.class,
        RibbonCommandFactoryConfiguration.HttpClientRibbonConfiguration.class,
        HttpClientConfiguration.class })
@ConditionalOnBean(ZuulProxyMarkerConfiguration.Marker.class)
public class ZuulProxyAutoConfiguration extends ZuulServerAutoConfiguration {
    //...
}

这个配置下面注册了很多组件，不过先暂时不看，它同时继承自ZuulServerAutoConfiguration，看看这个类：

@Configuration
@EnableConfigurationProperties({ ZuulProperties.class })
@ConditionalOnClass({ ZuulServlet.class, ZuulServletFilter.class })
@ConditionalOnBean(ZuulServerMarkerConfiguration.Marker.class)
// Make sure to get the ServerProperties from the same place as a normal web app would
// FIXME @Import(ServerPropertiesAutoConfiguration.class)
public class ZuulServerAutoConfiguration {

    @Autowired
    protected ZuulProperties zuulProperties;

    @Autowired
    protected ServerProperties server;

    @Autowired(required = false)
    private ErrorController errorController;

    private Map<String, CorsConfiguration> corsConfigurations;

    @Autowired(required = false)
    private List<WebMvcConfigurer> configurers = emptyList();

    @Bean
    public HasFeatures zuulFeature() {
        return HasFeatures.namedFeature("Zuul (Simple)",
                ZuulServerAutoConfiguration.class);
    }

    @Bean
    @Primary
    public CompositeRouteLocator primaryRouteLocator(
            Collection<RouteLocator> routeLocators) {
        return new CompositeRouteLocator(routeLocators);
    }

    @Bean
    @ConditionalOnMissingBean(SimpleRouteLocator.class)
    public SimpleRouteLocator simpleRouteLocator() {
        return new SimpleRouteLocator(this.server.getServlet().getContextPath(),
                this.zuulProperties);
    }

    @Bean
    public ZuulController zuulController() {
        return new ZuulController();
    }

    @Bean
    public ZuulHandlerMapping zuulHandlerMapping(RouteLocator routes) {
        ZuulHandlerMapping mapping = new ZuulHandlerMapping(routes, zuulController());
        mapping.setErrorController(this.errorController);
        mapping.setCorsConfigurations(getCorsConfigurations());
        return mapping;
    }

    protected final Map<String, CorsConfiguration> getCorsConfigurations() {
        if (this.corsConfigurations == null) {
            ZuulCorsRegistry registry = new ZuulCorsRegistry();
            this.configurers.forEach(configurer -> configurer.addCorsMappings(registry));
            this.corsConfigurations = registry.getCorsConfigurations();
        }
        return this.corsConfigurations;
    }

    @Bean
    public ApplicationListener<ApplicationEvent> zuulRefreshRoutesListener() {
        return new ZuulRefreshListener();
    }

    @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;
    }

    @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;
    }

    // pre filters

    @Bean
    public ServletDetectionFilter servletDetectionFilter() {
        return new ServletDetectionFilter();
    }

    @Bean
    public FormBodyWrapperFilter formBodyWrapperFilter() {
        return new FormBodyWrapperFilter();
    }

    @Bean
    public DebugFilter debugFilter() {
        return new DebugFilter();
    }

    @Bean
    public Servlet30WrapperFilter servlet30WrapperFilter() {
        return new Servlet30WrapperFilter();
    }

    // post filters

    @Bean
    public SendResponseFilter sendResponseFilter(ZuulProperties properties) {
        return new SendResponseFilter(zuulProperties);
    }

    @Bean
    public SendErrorFilter sendErrorFilter() {
        return new SendErrorFilter();
    }

    @Bean
    public SendForwardFilter sendForwardFilter() {
        return new SendForwardFilter();
    }

    @Bean
    @ConditionalOnProperty("zuul.ribbon.eager-load.enabled")
    public ZuulRouteApplicationContextInitializer zuulRoutesApplicationContextInitiazer(
            SpringClientFactory springClientFactory) {
        return new ZuulRouteApplicationContextInitializer(springClientFactory,
                zuulProperties);
    }

    @Configuration
    protected static class ZuulFilterConfiguration {

        @Autowired
        private Map<String, ZuulFilter> filters;

        @Bean
        public ZuulFilterInitializer zuulFilterInitializer(CounterFactory counterFactory,
                TracerFactory tracerFactory) {
            FilterLoader filterLoader = FilterLoader.getInstance();
            FilterRegistry filterRegistry = FilterRegistry.instance();
            return new ZuulFilterInitializer(this.filters, counterFactory, tracerFactory,
                    filterLoader, filterRegistry);
        }

    }

    @Configuration
    @ConditionalOnClass(MeterRegistry.class)
    protected static class ZuulCounterFactoryConfiguration {

        @Bean
        @ConditionalOnBean(MeterRegistry.class)
        @ConditionalOnMissingBean(CounterFactory.class)
        public CounterFactory counterFactory(MeterRegistry meterRegistry) {
            return new DefaultCounterFactory(meterRegistry);
        }

    }

    @Configuration
    protected static class ZuulMetricsConfiguration {

        @Bean
        @ConditionalOnMissingClass("io.micrometer.core.instrument.MeterRegistry")
        @ConditionalOnMissingBean(CounterFactory.class)
        public CounterFactory counterFactory() {
            return new EmptyCounterFactory();
        }

        @ConditionalOnMissingBean(TracerFactory.class)
        @Bean
        public TracerFactory tracerFactory() {
            return new EmptyTracerFactory();
        }

    }

    private static class ZuulRefreshListener
            implements ApplicationListener<ApplicationEvent> {

        @Autowired
        private ZuulHandlerMapping zuulHandlerMapping;

        private HeartbeatMonitor heartbeatMonitor = new HeartbeatMonitor();

        @Override
        public void onApplicationEvent(ApplicationEvent event) {
            if (event instanceof ContextRefreshedEvent
                    || event instanceof RefreshScopeRefreshedEvent
                    || event instanceof RoutesRefreshedEvent
                    || event instanceof InstanceRegisteredEvent) {
                reset();
            }
            else if (event instanceof ParentHeartbeatEvent) {
                ParentHeartbeatEvent e = (ParentHeartbeatEvent) event;
                resetIfNeeded(e.getValue());
            }
            else if (event instanceof HeartbeatEvent) {
                HeartbeatEvent e = (HeartbeatEvent) event;
                resetIfNeeded(e.getValue());
            }
        }

        private void resetIfNeeded(Object value) {
            if (this.heartbeatMonitor.update(value)) {
                reset();
            }
        }

        private void reset() {
            this.zuulHandlerMapping.setDirty(true);
        }

    }

    private static class ZuulCorsRegistry extends CorsRegistry {

        @Override
        protected Map<String, CorsConfiguration> getCorsConfigurations() {
            return super.getCorsConfigurations();
        }

    }

}

这个配置类里注册了很多bean：

• SimpleRouteLocator：默认的路由定位器，主要负责维护配置文件中的路由配置。
• DiscoveryClientRouteLocator：继承自SimpleRouteLocator，该类会将配置文件中的静态路由配置以及服务发现（比如eureka）中的路由信息进行合并，主要是靠它路由到具体服务。
• CompositeRouteLocator：组合路由定位器，看入参就知道应该是会保存好多个RouteLocator，构造过程中其实仅包括一个DiscoveryClientRouteLocator。
• ZuulController：Zuul创建的一个Controller，用于将请求交由ZuulServlet处理。
• ZuulHandlerMapping：这个会添加到SpringMvc的HandlerMapping链中，只有选择了ZuulHandlerMapping的请求才能出发到Zuul的后续流程。

还有一些其他的Filter，不一一看了。

其中，ZuulServlet是整个流程的核心，请求的过程是具体这样的，当Zuulservlet收到请求后， 会创建一个ZuulRunner对象，该对象中初始化了RequestContext：作为存储整个请求的一些数据，并被所有的Zuulfilter共享。ZuulRunner中还有一个 FilterProcessor，FilterProcessor作为执行所有的Zuulfilter的管理器。FilterProcessor从filterloader 中获取zuulfilter，而zuulfilter是被filterFileManager所 加载，并支持groovy热加载，采用了轮询的方式热加载。有了这些filter之后，zuulservelet首先执行的Pre类型的过滤器，再执行route类型的过滤器， 最后执行的是post 类型的过滤器，如果在执行这些过滤器有错误的时候则会执行error类型的过滤器。执行完这些过滤器，最终将请求的结果返回给客户端。 RequestContext就是会一直跟着整个请求周期的上下文对象，filters之间有什么信息需要传递就set一些值进去就行了。

有个示例图可以帮助理解一下：

 

 

ZuulServlet中的service方法:

@Override
    public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
        try {
            init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);

            // Marks this request as having passed through the "Zuul engine", as opposed to servlets
            // explicitly bound in web.xml, for which requests will not have the same data attached
            RequestContext context = RequestContext.getCurrentContext();
            context.setZuulEngineRan();

            try {
                //执行pre阶段的filters
                preRoute();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                //执行route阶段的filters
                route();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                //执行post阶段的filters
                postRoute();
            } catch (ZuulException e) {
                error(e);
                return;
            }

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

可以顺带说明一下ZuulFilter，他包括4个基本特征：过滤类型、执行顺序、执行条件、具体操作。

String filterType();

int filterOrder();

boolean shouldFilter();

Object run();

它们各自的含义与功能总结如下：

• filterType：该函数需要返回一个字符串来代表过滤器的类型，而这个类型就是在HTTP请求过程中定义的各个阶段。在Zuul中默认定义了四种不同生命周期的过滤器类型，具体如下：
• pre：可以在请求被路由之前调用。
• routing：在路由请求时候被调用。
• post：在routing和error过滤器之后被调用。
• error：处理请求时发生错误时被调用。
• filterOrder：通过int值来定义过滤器的执行顺序，数值越小优先级越高。
• shouldFilter：返回一个boolean类型来判断该过滤器是否要执行。我们可以通过此方法来指定过滤器的有效范围。
• run：过滤器的具体逻辑。在该函数中，我们可以实现自定义的过滤逻辑，来确定是否要拦截当前的请求，不对其进行后续的路由，或是在请求路由返回结果之后，对处理结果做一些加工等。

下图源自Zuul的官方WIKI中关于请求生命周期的图解，它描述了一个HTTP请求到达API网关之后，如何在各个不同类型的过滤器之间流转的详细过程。

 

 

Zuul默认实现了一批过滤器，如下：

|过滤器 |order |描述 |类型 |:---|:---:|:---:|---:| |ServletDetectionFilter| -3| 检测请求是用 DispatcherServlet还是 ZuulServlet| pre| |Servlet30WrapperFilter| -2| 在Servlet 3.0 下，包装 requests| pre| |FormBodyWrapperFilter| -1| 解析表单数据| pre| |SendErrorFilter| 0| 如果中途出现错误| error| |DebugFilter| 1| 设置请求过程是否开启debug| pre| |PreDecorationFilter| 5| 根据uri决定调用哪一个route过滤器| pre| |RibbonRoutingFilter| 10| 如果写配置的时候用ServiceId则用这个route过滤器，该过滤器可以用Ribbon 做负载均衡，用hystrix做熔断| route| |SimpleHostRoutingFilter| 100| 如果写配置的时候用url则用这个route过滤| route| |SendForwardFilter| 500| 用RequestDispatcher请求转发| route| |SendResponseFilter| 1000| 用RequestDispatcher请求转发| post|

回到我的需求，我不需要静态配置，所有请求都是调用在eureka注册的服务，所以每次请求都要在route阶段转到RibbonRoutingFilter，由它使用Ribbon向其它服务发起请求，因此看一下这个类的shouldFilter()方法：

@Override
public boolean shouldFilter() {
    RequestContext ctx = RequestContext.getCurrentContext();
    return (ctx.getRouteHost() == null && ctx.get(SERVICE_ID_KEY) != null
            && ctx.sendZuulResponse());
}

原来进入这个Filter的条件是RequestContext中getRouteHost为空且ctx.get(SERVICE_ID_KEY)不为空，即serviceId有值！ 那么Zuul在默认情况下是怎么选择route阶段的Filter的呢？看到上面的pre阶段有一个PreDecorationFilter，这个类主要就是根据uri来给RequestContext添加不同的内容来控制之后走哪个route过滤器。 看下它的Run方法：

@Override
public Object run() {
    RequestContext ctx = RequestContext.getCurrentContext();
    final String requestURI = this.urlPathHelper
            .getPathWithinApplication(ctx.getRequest());
    //已经包含的路由配置里是否有能匹配到的route
    Route route = this.routeLocator.getMatchingRoute(requestURI);
    if (route != null) {
        String location = route.getLocation();
        if (location != null) {
            ctx.put(REQUEST_URI_KEY, route.getPath());
            ctx.put(PROXY_KEY, route.getId());
            if (!route.isCustomSensitiveHeaders()) {
                this.proxyRequestHelper.addIgnoredHeaders(
                        this.properties.getSensitiveHeaders().toArray(new String[0]));
            }
            else {
                this.proxyRequestHelper.addIgnoredHeaders(
                        route.getSensitiveHeaders().toArray(new String[0]));
            }

            if (route.getRetryable() != null) {
                ctx.put(RETRYABLE_KEY, route.getRetryable());
            }
            //根据各种情况设置context
            //http:开头的
            if (location.startsWith(HTTP_SCHEME + ":")
                    || location.startsWith(HTTPS_SCHEME + ":")) {
                ctx.setRouteHost(getUrl(location));
                ctx.addOriginResponseHeader(SERVICE_HEADER, location);
            }
            //forward:开头的
            else if (location.startsWith(FORWARD_LOCATION_PREFIX)) {
                ctx.set(FORWARD_TO_KEY,
                        StringUtils.cleanPath(
                                location.substring(FORWARD_LOCATION_PREFIX.length())
                                        + route.getPath()));
                ctx.setRouteHost(null);
                return null;
            }
            //这里设置了serviceId，走Ribbon
            else {
                // set serviceId for use in filters.route.RibbonRequest
                ctx.set(SERVICE_ID_KEY, location);
                ctx.setRouteHost(null);
                ctx.addOriginResponseHeader(SERVICE_ID_HEADER, location);
            }
            if (this.properties.isAddProxyHeaders()) {
                addProxyHeaders(ctx, route);
                String xforwardedfor = ctx.getRequest()
                        .getHeader(X_FORWARDED_FOR_HEADER);
                String remoteAddr = ctx.getRequest().getRemoteAddr();
                if (xforwardedfor == null) {
                    xforwardedfor = remoteAddr;
                }
                else if (!xforwardedfor.contains(remoteAddr)) { // Prevent duplicates
                    xforwardedfor += ", " + remoteAddr;
                }
                ctx.addZuulRequestHeader(X_FORWARDED_FOR_HEADER, xforwardedfor);
            }
            if (this.properties.isAddHostHeader()) {
                ctx.addZuulRequestHeader(HttpHeaders.HOST,
                        toHostHeader(ctx.getRequest()));
            }
        }
    }
    else {
        log.warn("No route found for uri: " + requestURI);
        String forwardURI = getForwardUri(requestURI);
        //都不满足的话，设置一个forward.to，走SendForwardFilter
        ctx.set(FORWARD_TO_KEY, forwardURI);
    }
    return null;
}

情况比较复杂，实际根据我的需求，我只要让route阶段时候使用RibbonRoutingFilter，因此我只要保证进入route阶段时RequestContext里包含对应服务的serviceId就行了。 我可以在pre阶段将请求头内的service转化为所需要的服务serviceId，设置到context内，同时移除context中其它有影响的值就行了。

听上去挺简单的，我们自定义一个pre阶段的Filter。

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cloud.netflix.zuul.filters.Route;
import org.springframework.cloud.netflix.zuul.filters.RouteLocator;
import org.springframework.web.util.UrlPathHelper;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;

public class HeaderPreDecorationFilter extends ZuulFilter {

    private static final Log log = LogFactory.getLog(HeaderPreDecorationFilter.class);
    private RouteLocator routeLocator;
    private UrlPathHelper urlPathHelper = new UrlPathHelper();

    private Map<String, Service> serviceMap = new HashMap();

    public HeaderPreDecorationFilter(RouteLocator routeLocator, String dispatcherServletPath) {
        this.routeLocator = routeLocator;
        //举个小例子，假如我在后端有一个名为platform-server的服务，服务内有一个/mwd/client/test的接口
        serviceMap.put("mwd.service.test", new Service("platform-server", "/mwd/client/test"));
    }

    public String filterType() {
        return "pre";
    }

    public int filterOrder() {
        return 6;
    }

    public boolean shouldFilter() {
        return true;
    }

    public Object run() throws ZuulException {
        RequestContext ctx = RequestContext.getCurrentContext();
        HttpServletRequest request = ctx.getRequest();
        String requestURI = this.urlPathHelper.getPathWithinApplication(ctx.getRequest());
        //取得头信息
        String serviceName = request.getHeader("service");
        //获取头信息映射成对应的服务信息
        Service service = serviceMap.get(serviceName);
        String serviceURI = service.getServiceId() + service.getPath();
        //TODO 判断服务是否存在，可以做额外异常处理
        Route route = this.routeLocator.getMatchingRoute("/" + serviceURI);
        //设置context
        ctx.set("serviceId", service.getServiceId());
        ctx.put("requestURI", service.getPath());
        ctx.put("proxy", service.getServiceId());
        ctx.put("retryable", false);
//        ctx.remove("forward.to");  
        log.info(String.format("send %s request to %s", request.getMethod(), request.getRequestURL().toString()));
        return null;
    }

    class Service {

        public Service(String serviceId, String path) {
            this.serviceId = serviceId;
            this.path = path;
        }

        String serviceId;
        String path;

        public String getServiceId() {
            return serviceId;
        }

        public void setServiceId(String serviceId) {
            this.serviceId = serviceId;
        }

        public String getPath() {
            return path;
        }

        public void setPath(String path) {
            this.path = path;
        }
    }
}

然后可以将之前的PreDecorationFilter禁用，以免它对RequestContext的操作影响我们，例如，如果没有匹配到任何规则，它会在RequestContext中添加一个forward.to 这个key会调用post阶段的SendForwardFilter导致报错。

在配置文件设置zuul.PreDecorationFilter.pre.disable=true即可。

现在将这个类纳入spring容器中，写法可以参照ZuulProxyAutoConfiguration中其它Filter的实例化方式，我们也做一个自己的配置类：

@Configuration
@EnableConfigurationProperties({ZuulProperties.class})
public class Config {

    @Autowired
    protected ZuulProperties zuulProperties;
    @Autowired
    protected ServerProperties server;

    @Bean
    public HeaderPreDecorationFilter geaderPreDecorationFilter(RouteLocator routeLocator) {
        return new HeaderPreDecorationFilter(routeLocator, this.server.getServlet().getContextPath());
    }
}

这样每次请求进来后，在pre阶段会去取service头信息，然后匹配成对应的serviceId（取不到或者匹配不到自然就报错了），在route阶段就直接触发RibbonRoutingFilter调用服务返回了！

现在还剩一个网关入口的问题，我是想让所有的请求走一个固定的url，先试着直接访问一下：localhost:8080/gateway ，直接报404了。很正常，我们还没有做这个url path的映射！ SpringMvc的DispatcherServlet没有查到这个path的处理方法自然报404了！怎样才能让gateway这个路由进入zuul中呢？

我们记得在上面Zuul的配置类中有一个ZuulHandlerMapping， 当一个请求进入SpringMvc的DispatchServlet后，会根据路由看能否匹配到ZuulHandlerMapping，匹配成功才会走zuul后续的流程。

以下是DispatcherServlet中doDispatch方法的代码：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;
    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        try {
            ModelAndView mv = null;
            Object dispatchException = null;

            try {
                processedRequest = this.checkMultipart(request);
                multipartRequestParsed = processedRequest != request;
                mappedHandler = this.getHandler(processedRequest);
                if (mappedHandler == null) {
                    this.noHandlerFound(processedRequest, response);
                    return;
                }
                //这里选择ZuulHandlerMapping，如果路由匹配成功，会返回包含ZuulController的ha
                HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.getHandler());

                // ... 省略代码

                //从这里进入调用ZuulController
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                if (asyncManager.isConcurrentHandlingStarted()) {
                    return;
                }

                this.applyDefaultViewName(processedRequest, mv);
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            } catch (Exception var20) {
                dispatchException = var20;
            } catch (Throwable var21) {
                dispatchException = new NestedServletException("Handler dispatch failed", var21);
            }

            this.processDispatchResult(processedRequest, response, mappedHandler, mv, (Exception)dispatchException);
        } catch (Exception var22) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, var22);
        } catch (Throwable var23) {
            this.triggerAfterCompletion(processedRequest, response, mappedHandler, new NestedServletException("Handler processing failed", var23));
        }

    } finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        } else if (multipartRequestParsed) {
            this.cleanupMultipart(processedRequest);
        }

    }
}

那么怎样才能让请求进入ZuulHandlerMapping呢，看下DispatchServlet中的的这个方法：

@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        Iterator var2 = this.handlerMappings.iterator();
        //按顺序遍历所有的HandlerMapping，直到取得一个
        while(var2.hasNext()) {
            HandlerMapping mapping = (HandlerMapping)var2.next();
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }

    return null;
}

我们需要ZuulHandlerMapping在mapping.getHandler的时候返回非空。研究下ZuulHandlerMapping，看下它的结构先：

 

 

ZuulHandlerMapping继承了AbstractUrlHandlerMapping，AbstractUrlHandlerMapping又继承自AbstractHandlerMapping。在上面的方法中调用ZuulHandlerMapping的mapping.getHandler(request)的时候 实际会调用到AbstractHandlerMapping的getHandlerInternal(request)，再进入ZuulHandlerMapping的lookupHandler(String urlPath, HttpServletRequest request)这个方法。

看下这个方法：

@Override
protected Object lookupHandler(String urlPath, HttpServletRequest request)
        throws Exception {
    if (this.errorController != null
            && urlPath.equals(this.errorController.getErrorPath())) {
        return null;
    }
    if (isIgnoredPath(urlPath, this.routeLocator.getIgnoredPaths())) {
        return null;
    }
    RequestContext ctx = RequestContext.getCurrentContext();
    if (ctx.containsKey("forward.to")) {
        return null;
    }
    if (this.dirty) {
        synchronized (this) {
            if (this.dirty) {
                registerHandlers();
                this.dirty = false;
            }
        }
    }
    //实际会调用这里
    return super.lookupHandler(urlPath, request);
}

调用父类的AbstractUrlHandlerMapping.lookupHandler(urlPath, request)。

这个方法里代码比较多，其中的关键信息是：this.handlerMap.get(urlPath)，也就是说我们输入的url path只要能从handlerMap里匹配到，就可以了！ 现在需要看下ZuulHandlerMapping里的这个handlerMap是怎么维护的。类中有这么一个方法：

private void registerHandlers() {
    Collection<Route> routes = this.routeLocator.getRoutes();
    if (routes.isEmpty()) {
        this.logger.warn("No routes found from RouteLocator");
    }
    else {
        for (Route route : routes) {
            registerHandler(route.getFullPath(), this.zuul);
        }
    }
}

它会从routeLocator里取出所有的route，一个一个注册到handlerMap里。这样的话就简单了，我只要自己定义一个RouteLocator，把我想要的路由设置好，再让它自动被注册进去就行了吧！

定义一个GatewayRouteLocator：

public class GatewayRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator {

    public final static Logger logger = LoggerFactory.getLogger(GatewayRouteLocator.class);

    public GatewayRouteLocator(String servletPath, ZuulProperties properties) {
        super(servletPath, properties);
    }
    public void refresh() {
        doRefresh();
    }

    @Override
    protected Map<String, ZuulProperties.ZuulRoute> locateRoutes() {
        LinkedHashMap<String, ZuulProperties.ZuulRoute> routesMap = new LinkedHashMap<String, ZuulProperties.ZuulRoute>();
        routesMap.put("gateway", new ZuulProperties.ZuulRoute());
        return routesMap;
    }

    @Override
    public List<Route> getRoutes() {
        //假设我希望网关API为http://www.domain.com/gateway
        List<Route> values = new ArrayList<Route>();
        values.add(new Route("gateway1", "/gateway/", "/gateway", "", true, new HashSet<String>()));
        values.add(new Route("gateway2", "/gateway", "/gateway", "", true, new HashSet<String>()));
        return values;
    }
}

现在我要将这个类也实例化到spring容器中。

观察下ZuulProxyAutoConfiguration中的RouteLocator是怎么实例化的，照葫芦画瓢弄一下，把这个类也添加到配置类里：

@Configuration
@EnableConfigurationProperties({ZuulProperties.class})
public class Config {

    @Autowired
    protected ZuulProperties zuulProperties;
    @Autowired
    protected ServerProperties server;

    @Bean
    public GatewayRouteLocator gatewayRouteLocator() {
        return new GatewayRouteLocator(this.server.getServlet().getContextPath(), zuulProperties);
    }

    @Bean
    public HeaderPreDecorationFilter geaderPreDecorationFilter(RouteLocator routeLocator) {
        return new HeaderPreDecorationFilter(routeLocator, this.server.getServlet().getContextPath());
    }
}

好了！这样每次输入http://www.domain.com/gateway 的时候，DispatchServlet就会为我们匹配到ZuulHandlerMapping，进而往下走到ZuulController中了。

再看下ZuulController的代码：

ZuulController:

public class ZuulController extends ServletWrappingController {

    public ZuulController() {
        //在这里已经设置了ZuulServlet
        setServletClass(ZuulServlet.class);
        setServletName("zuul");
        setSupportedMethods((String[]) null); // Allow all
    }

    @Override
    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws Exception {
        try {
            //在这里面会调用ZuulServlet的service方法
            return super.handleRequestInternal(request, response);
        }
        finally {
            // @see com.netflix.zuul.context.ContextLifecycleFilter.doFilter
            RequestContext.getCurrentContext().unset();
        }
    }

}

就是将Request送入ZuulServlet，这样就跟上面的流程衔接上了！

总结一下，一次请求流程为 DispatcherServlet->ZuulHandlerMapping->ZuulController->ZuulServlet->ZuulRunner-> FilterProcessor->ZuulFilter->PreDecorationFilter(替换为自定义的HeaderPreDecorationFilter)->RibbonRoutingFilter

至此，对Zuul的改造就完成了！现在我对外暴露一个统一的api：http://www.domain.com/gateway，所有的服务都从这里调用，同时通过传入一个service的头信息来指定调用具体 的服务，服务列表可以维护在其它地方动态刷新，这样就不会将serviceName暴露出去了！