【SpringCloud】Zuul在何种情况下使用Hystrix

protected Route getSimpleMatchingRoute(final String path) {
if (log.isDebugEnabled()) {
log.debug("Finding route for path: " + path);
}

// routes是保存路由信息的map，如果此时还未加载，调用locateRoutes()
if (this.routes.get() == null) {
    this.routes.set(locateRoutes());
}

if (log.isDebugEnabled()) {
    log.debug("servletPath=" + this.dispatcherServletPath);
    log.debug("zuulServletPath=" + this.zuulServletPath);
    log.debug("RequestUtils.isDispatcherServletRequest()="
            + RequestUtils.isDispatcherServletRequest());
    log.debug("RequestUtils.isZuulServletRequest()="
            + RequestUtils.isZuulServletRequest());
}

/**
 * 下面的方法主要是先对path做微调
 * 再根据path到routes中匹配到ZuulRoute
 * 最后根据 ZuulRoute 和 adjustedPath 生成 Route
 */
String adjustedPath = adjustPath(path);

ZuulRoute route = getZuulRoute(adjustedPath);

return getRoute(route, adjustedPath);

//调用父类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
        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;

// ==== 匹配到路由信息
if (route != null) {
    String location = route.getLocation();
    if (location != null) {
        ctx.put(REQUEST_URI_KEY, route.getPath());//RequestContext设置 requestURI：路由的pattern路径
        ctx.put(PROXY_KEY, route.getId());//RequestContext设置 proxy：路由id

        //设置需要忽略的敏感头信息，要么用全局默认的，要么用路由自定义的
        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());
        }

        //如果location是 http/https开头的，RequestContext设置 routeHost：URL
        //如果location是 forward:开头的，RequestContext设置 forward信息、routeHost：null
        //其它 RequestContext设置 serviceId、routeHost：null、X-Zuul-ServiceId
        if (location.startsWith(HTTP_SCHEME+":") || location.startsWith(HTTPS_SCHEME+":")) {
            ctx.setRouteHost(getUrl(location));
            ctx.addOriginResponseHeader(SERVICE_HEADER, location);
        }
        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;
        }
        else {
            // set serviceId for use in filters.route.RibbonRequest
            ctx.set(SERVICE_ID_KEY, location);
            ctx.setRouteHost(null);
            ctx.addOriginResponseHeader(SERVICE_ID_HEADER, location);
        }

        //是否添加代理头信息 X-Forwarded-For
        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);
        }

        //是否添加Host头信息
        if (this.properties.isAddHostHeader()) {
            ctx.addZuulRequestHeader(HttpHeaders.HOST, toHostHeader(ctx.getRequest()));
        }
    }
}
// ==== 没有匹配到路由信息
else {
    log.warn("No route found for uri: " + requestURI);

    String fallBackUri = requestURI;
    String fallbackPrefix = this.dispatcherServletPath; // default fallback
                                                        // servlet is
                                                        // DispatcherServlet

    if (RequestUtils.isZuulServletRequest()) {
        // remove the Zuul servletPath from the requestUri
        log.debug("zuulServletPath=" + this.properties.getServletPath());
        fallBackUri = fallBackUri.replaceFirst(this.properties.getServletPath(), "");
        log.debug("Replaced Zuul servlet path:" + fallBackUri);
    }
    else {
        // remove the DispatcherServlet servletPath from the requestUri
        log.debug("dispatcherServletPath=" + this.dispatcherServletPath);
        fallBackUri = fallBackUri.replaceFirst(this.dispatcherServletPath, "");
        log.debug("Replaced DispatcherServlet servlet path:" + fallBackUri);
    }
    if (!fallBackUri.startsWith("/")) {
        fallBackUri = "/" + fallBackUri;
    }
    String forwardURI = fallbackPrefix + fallBackUri;
    forwardURI = forwardURI.replaceAll("//", "/");
    ctx.set(FORWARD_TO_KEY, forwardURI);
}
return null;

}
总结：

只要引入了spring-cloud-starter-zuul就会间接引入Ribbon、Hystrix
路由信息可能是从配置文件中加载的，也可能是通过DiscoveryClient从注册中心加载的
zuul是通过前置过滤器PreDecorationFilter找到与当前requestURI匹配的路由信息，并在RequestContext中设置相关属性的，后续的Route Filter会根据RequestContext中的这些属性判断如何路由转发
Route Filter主要使用 SimpleHostRoutingFilter 和 RibbonRoutingFilter
当RequestContext请求上下文中存在routeHost，即URL直连信息时，使用SimpleHostRoutingFilter简单Host路由
当RequestContext请求上下文中存在serviceId，即服务id时（可能会与注册中心关联获取服务列表，或者读取配置文件中serviceId.ribbon.listOfServers的服务列表），使用RibbonRoutingFilter，会使用Ribbon、Hystrix