SpringCloud源码剖析-Zuul的自动配置和核心Filter详解

/*** Sets up a Zuul server endpoint and installs some reverse proxy filters in it, so it can* forward requests to backend servers. The backends can be registered manually through* configuration or via DiscoveryClient.** @see EnableZuulServer for how to get a Zuul server without any proxying*/@EnableCircuitBreaker@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(ZuulProxyMarkerConfiguration.class)
public@interfaceEnableZuulProxy {
}

/**负责添加标记bean以触发 {@link ZuulProxyAutoConfiguration}的激活* Responsible for adding in a marker bean to trigger activation of * {@link ZuulProxyAutoConfiguration}** @author Biju Kunjummen*/@ConfigurationpublicclassZuulProxyMarkerConfiguration {
@BeanpublicMarkerzuulProxyMarkerBean() {
returnnewMarker();
    }
classMarker {
    }
}

@Configuration//这里引入了几种客户端配置@Import({ RibbonCommandFactoryConfiguration.RestClientRibbonConfiguration.class,
RibbonCommandFactoryConfiguration.OkHttpRibbonConfiguration.class,
RibbonCommandFactoryConfiguration.HttpClientRibbonConfiguration.class,
HttpClientConfiguration.class })
//注册Bean的条件，必须有 ZuulProxyMarkerConfiguration.Marker 的实例@ConditionalOnBean(ZuulProxyMarkerConfiguration.Marker.class)
publicclassZuulProxyAutoConfigurationextendsZuulServerAutoConfiguration {
...省略...

/*** @author Spencer Gibb* @author Dave Syer* @author Biju Kunjummen*/@Configuration//开启配置：ZuulProperties ，这里面是以 zuul 打头的配置@EnableConfigurationProperties({ ZuulProperties.class })
@ConditionalOnClass(ZuulServlet.class)
//必须满足有 ZuulServerMarkerConfiguration.Marker 的实例才能被注册@ConditionalOnBean(ZuulServerMarkerConfiguration.Marker.class)
// Make sure to get the ServerProperties from the same place as a normal web app would// FIXME @Import(ServerPropertiesAutoConfiguration.class)publicclassZuulServerAutoConfiguration {
//绑定zuul的配置信息，这里面是以 zuul 打头的配置@AutowiredprotectedZuulPropertieszuulProperties;
//以server打头的服务器配置@AutowiredprotectedServerPropertiesserver;
//注入请求错误的控制器，主要返回错误页面的路径@Autowired(required=false)
privateErrorControllererrorController;
@BeanpublicHasFeatureszuulFeature() {
returnHasFeatures.namedFeature("Zuul (Simple)", ZuulServerAutoConfiguration.class);
    }
//RouteLocator that composes multiple RouteLocators. ：//多路由组合定位器@Bean@PrimarypublicCompositeRouteLocatorprimaryRouteLocator(
Collection<RouteLocator>routeLocators) {
returnnewCompositeRouteLocator(routeLocators);
    }
//简单的路由定位器@Bean@ConditionalOnMissingBean(SimpleRouteLocator.class)
publicSimpleRouteLocatorsimpleRouteLocator() {
returnnewSimpleRouteLocator(this.server.getServlet().getServletPrefix(),
this.zuulProperties);
    }
//Zuul的请求入口控制器@BeanpublicZuulControllerzuulController() {
returnnewZuulController();
    }
// MVC HandlerMapping that maps incoming request paths to remote services.//他是做请求路径和远程服务的映射的，是 HandlerMapping的实现@BeanpublicZuulHandlerMappingzuulHandlerMapping(RouteLocatorroutes) {
ZuulHandlerMappingmapping=newZuulHandlerMapping(routes, zuulController());
mapping.setErrorController(this.errorController);
returnmapping;
    }
//定义ZuulRefreshListener  zuul刷新的监听器@BeanpublicApplicationListener<ApplicationEvent>zuulRefreshRoutesListener() {
returnnewZuulRefreshListener();
    }
// Core Zuul servlet which intializes and orchestrates zuulFilter execution//这里在注册ZuulServlet 这样的一个servlet, 这个东西了不得了，//他是负责核心ZuulServlet初始化和调用zuulFilter执行，跟DispatcherServlet差不多@Bean@ConditionalOnMissingBean(name="zuulServlet")
publicServletRegistrationBeanzuulServlet() {
ServletRegistrationBean<ZuulServlet>servlet=newServletRegistrationBean<>(newZuulServlet(),
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");
returnservlet;
    }
// pre filters  : //在pre过滤器中，它是第一个执行的过滤器，检测请求是用 DispatcherServlet还是 ZuulServlet，将结果设置到RequestContext中@BeanpublicServletDetectionFilterservletDetectionFilter() {
returnnewServletDetectionFilter();
    }
//前置过滤器，用于解析表单数据并将其重新编码,只是针对于表单数据，即：content-type中必须带有“application/x-www-form-urlencoded”或“multipart/form-data”@BeanpublicFormBodyWrapperFilterformBodyWrapperFilter() {
returnnewFormBodyWrapperFilter();
    }
//设置请求过程是否开启debug,将当前请求上下文中的debugRouting和debugRequest参数设置为true@BeanpublicDebugFilterdebugFilter() {
returnnewDebugFilter();
    }
//主要是将原始请求进行包装，将原始的HttpServletRequest请求包装成Servlet30RequestWrapper类型@BeanpublicServlet30WrapperFilterservlet30WrapperFilter() {
returnnewServlet30WrapperFilter();
    }
// post filters//下面是定义一系列的后置过滤器,SendResponseFilter是Zuul的最后一个Filter，负责最终响应结果的输出@BeanpublicSendResponseFiltersendResponseFilter(ZuulPropertiesproperties) {
returnnewSendResponseFilter(zuulProperties);
    }
//这个是用来发送错误的Filter@BeanpublicSendErrorFiltersendErrorFilter() {
returnnewSendErrorFilter();
    }
//它使用RequestDispatcher转发请求@BeanpublicSendForwardFiltersendForwardFilter() {
returnnewSendForwardFilter();
    } 
}

/*** @author Spencer Gibb* @author Dave Syer* @author Biju Kunjummen*/@Configuration@Import({ RibbonCommandFactoryConfiguration.RestClientRibbonConfiguration.class,
RibbonCommandFactoryConfiguration.OkHttpRibbonConfiguration.class,
RibbonCommandFactoryConfiguration.HttpClientRibbonConfiguration.class,
HttpClientConfiguration.class })
//配置激活条件，必须有ZuulProxyMarkerConfiguration.Marker的实例@ConditionalOnBean(ZuulProxyMarkerConfiguration.Marker.class)
publicclassZuulProxyAutoConfigurationextendsZuulServerAutoConfiguration {
    ...省略代码...
//服务发现的路由定位器，它将静态的配置RouteLocator路由与DiscoveryClient路由组合在一起， 通过服务发现的方式进行路由@Bean@ConditionalOnMissingBean(DiscoveryClientRouteLocator.class)
publicDiscoveryClientRouteLocatordiscoveryRouteLocator() {
returnnewDiscoveryClientRouteLocator(this.server.getServlet().getServletPrefix(), this.discovery, this.zuulProperties,
this.serviceRouteMapper, this.registration);
    }
// pre filters  ： 前置过滤//Pre ZuulFilter可以根据提供的RouteLocator确定在哪里以及如何进行路由。 还为下游请求设置各种与代理相关的标头。@BeanpublicPreDecorationFilterpreDecorationFilter(RouteLocatorrouteLocator, ProxyRequestHelperproxyRequestHelper) {
returnnewPreDecorationFilter(routeLocator, this.server.getServlet().getServletPrefix(), this.zuulProperties,
proxyRequestHelper);
    }
// route filters   ：路由过滤，实现了Ribbon的负载均衡和hystrix@BeanpublicRibbonRoutingFilterribbonRoutingFilter(ProxyRequestHelperhelper,
RibbonCommandFactory<?>ribbonCommandFactory) {
RibbonRoutingFilterfilter=newRibbonRoutingFilter(helper, ribbonCommandFactory,
this.requestCustomizers);
returnfilter;
    }
//简单主机的路由Filter@Bean@ConditionalOnMissingBean({SimpleHostRoutingFilter.class, CloseableHttpClient.class})
publicSimpleHostRoutingFiltersimpleHostRoutingFilter(ProxyRequestHelperhelper,
ZuulPropertieszuulProperties,
ApacheHttpClientConnectionManagerFactoryconnectionManagerFactory,
ApacheHttpClientFactoryhttpClientFactory) {
returnnewSimpleHostRoutingFilter(helper, zuulProperties,
connectionManagerFactory, httpClientFactory);
    }
@Bean@ConditionalOnMissingBean({SimpleHostRoutingFilter.class})
publicSimpleHostRoutingFiltersimpleHostRoutingFilter2(ProxyRequestHelperhelper,
ZuulPropertieszuulProperties,
CloseableHttpClienthttpClient) {
returnnewSimpleHostRoutingFilter(helper, zuulProperties,
httpClient);
    }
//服务名和路由组件的映射器，提供一种在路由和发现的服务名称之间应用约定的方法@Bean@ConditionalOnMissingBean(ServiceRouteMapper.class)
publicServiceRouteMapperserviceRouteMapper() {
returnnewSimpleServiceRouteMapper();
    }
}

publicclassZuulControllerextendsServletWrappingController {
publicZuulController() {
//把 ZuulServlet 设置给父类setServletClass(ZuulServlet.class);
setServletName("zuul");
setSupportedMethods((String[]) null); // Allow all    }
@OverridepublicModelAndViewhandleRequest(HttpServletRequestrequest, HttpServletResponseresponse) throwsException {
try {
// We don't care about the other features of the base class, just want to// handle the request//执行父类的请求方法returnsuper.handleRequestInternal(request, response);
        }
finally {
// @see com.netflix.zuul.context.ContextLifecycleFilter.doFilterRequestContext.getCurrentContext().unset();
        }
    }
}

publicclassServletWrappingControllerextendsAbstractControllerimplementsBeanNameAware, InitializingBean, DisposableBean {
    ...省略...
@NullableprivateServletservletInstance;
//反射创建 ZuulServlet和初始化publicvoidafterPropertiesSet() throwsException {
if (this.servletClass==null) {
thrownewIllegalArgumentException("'servletClass' is required");
        } else {
if (this.servletName==null) {
this.servletName=this.beanName;
            }
//反射创建 ZuulServlet和初始化this.servletInstance= (Servlet)ReflectionUtils.accessibleConstructor(this.servletClass, newClass[0]).newInstance();
this.servletInstance.init(newServletWrappingController.DelegatingServletConfig());
        }
    }
//核心方法，调用 servletInstance 执行请求protectedModelAndViewhandleRequestInternal(HttpServletRequestrequest, HttpServletResponseresponse) throwsException {
Assert.state(this.servletInstance!=null, "No Servlet instance");
//调用 ZuulServlet执行请求this.servletInstance.service(request, response);
returnnull;
    }

publicinterfaceRouteLocator {
/*** Ignored route paths (or patterns), if any.*/Collection<String>getIgnoredPaths();
/*** A map of route path (pattern) to location (e.g. service id or URL).*/List<Route>getRoutes();
/*** Maps a path to an actual route with full metadata.*/RoutegetMatchingRoute(Stringpath);
}

publicclassCompositeRouteLocatorimplementsRefreshableRouteLocator {
//省略@OverridepublicRoutegetMatchingRoute(Stringpath) {
//遍历所有的 routeLocatorsfor (RouteLocatorlocator : routeLocators) {
//通过 path找到 RouteRouteroute=locator.getMatchingRoute(path);
if (route!=null) {
returnroute;
            }
        }
returnnull;
    }
}

protectedRoutegetSimpleMatchingRoute(finalStringpath) {
if (log.isDebugEnabled()) {
log.debug("Finding route for path: "+path);
    }
//获取所有的路由// This is called for the initialization done in getRoutesMap()getRoutesMap();
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());
    }
//调整路径StringadjustedPath=adjustPath(path);
//根据Path查找RouteZuulRouteroute=getZuulRoute(adjustedPath);
returngetRoute(route, adjustedPath);
}
//根据path匹配RouteprotectedZuulRoutegetZuulRoute(StringadjustedPath) {
//不忽略if (!matchesIgnoredPatterns(adjustedPath)) {
//遍历所有的routefor (Entry<String, ZuulRoute>entry : getRoutesMap().entrySet()) {
Stringpattern=entry.getKey();
log.debug("Matching pattern:"+pattern);
//根据path简单匹配 route,返回routeif (this.pathMatcher.match(pattern, adjustedPath)) {
returnentry.getValue();
            }
        }
    }
returnnull;
}

/*** A {@link RouteLocator} that combines static, configured routes with those from a* {@link DiscoveryClient}. The discovery client takes precedence.** @author Spencer Gibb* @author Dave Syer*/publicclassDiscoveryClientRouteLocatorextendsSimpleRouteLocatorimplementsRefreshableRouteLocator {
privatestaticfinalLoglog=LogFactory.getLog(DiscoveryClientRouteLocator.class);
publicstaticfinalStringDEFAULT_ROUTE="/**";
//服务发现客户端，用来从注册中心找服务的privateDiscoveryClientdiscovery;
//zuul的配置，以zuul开头的配置项privateZuulPropertiesproperties;
//提供一种在 路由 和 发现的服务名称 之间应用约定的方法privateServiceRouteMapperserviceRouteMapper;
//初始化publicDiscoveryClientRouteLocator(StringservletPath, DiscoveryClientdiscovery,
ZuulPropertiesproperties, ServiceInstancelocalServiceInstance) {
super(servletPath, properties);
//添加忽略的服务，对应配置：ignored-services: "*"if (properties.isIgnoreLocalService() &&localServiceInstance!=null) {
StringlocalServiceId=localServiceInstance.getServiceId();
if (!properties.getIgnoredServices().contains(localServiceId)) {
properties.getIgnoredServices().add(localServiceId);
            }
        }
this.serviceRouteMapper=newSimpleServiceRouteMapper();
//初始化服务发现客户端this.discovery=discovery;
this.properties=properties;
    }
//定位路由，读取yml配置的zuul.routes中的路由，然后把需要忽略的忽略掉，加上前缀返回。@OverrideprotectedLinkedHashMap<String, ZuulRoute>locateRoutes() {
LinkedHashMap<String, ZuulRoute>routesMap=newLinkedHashMap<>();
//拿到所有的routes配置添加到map中，对应yml中的zuul.routes配置routesMap.putAll(super.locateRoutes());
if (this.discovery!=null) {
Map<String, ZuulRoute>staticServices=newLinkedHashMap<>();
for (ZuulRouteroute : routesMap.values()) {
//取到配置的每个路由的微服务的IDStringserviceId=route.getServiceId();
if (serviceId==null) {
serviceId=route.getId();
                }
if (serviceId!=null) {
//以 服务ID为key把每个路由配置放到staticServices中staticServices.put(serviceId, route);
                }
            }
// Add routes for discovery services by default//通过服务发现客户端找到服务注册表中的服务List<String>services=this.discovery.getServices();
//得到配置中需要忽略的服务的服务名String[] ignored=this.properties.getIgnoredServices()
                    .toArray(newString[0]);
//循环从注册表中找到的服务 , 这里要处理忽略的服务for (StringserviceId : services) {
// Ignore specifically ignored services and those that were manually// configuredStringkey="/"+mapRouteToService(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 nullZuulRoutestaticRoute=staticServices.get(serviceId);
if (!StringUtils.hasText(staticRoute.getLocation())) {
staticRoute.setLocation(serviceId);
                    }
                }
//通过工具判断哪些服务要忽略，不忽略的加入routesMap中if (!PatternMatchUtils.simpleMatch(ignored, serviceId)
&&!routesMap.containsKey(key)) {
// Not ignoredroutesMap.put(key, newZuulRoute(key, serviceId));
                }
            }
        }
if (routesMap.get(DEFAULT_ROUTE) !=null) {
ZuulRoutedefaultRoute=routesMap.get(DEFAULT_ROUTE);
// Move the defaultServiceId to the endroutesMap.remove(DEFAULT_ROUTE);
routesMap.put(DEFAULT_ROUTE, defaultRoute);
        }
LinkedHashMap<String, ZuulRoute>values=newLinkedHashMap<>();
//处理路径的 前缀for (Entry<String, ZuulRoute>entry : routesMap.entrySet()) {
Stringpath=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());
        }
returnvalues;
    }

/*** Detects whether a request is ran through the {@link DispatcherServlet} or {@link ZuulServlet}.* The purpose was to detect this up-front at the very beginning of Zuul filter processing*  and rely on this information in all filters.*  RequestContext is used such that the information is accessible to classes *  which do not have a request reference.* @author Adrian Ivan*/publicclassServletDetectionFilterextendsZuulFilter {
publicServletDetectionFilter() {
    }
//前置通知@OverridepublicStringfilterType() {
returnPRE_TYPE;
    }
/*** Must run before other filters that rely on the difference between * DispatcherServlet and ZuulServlet.*///filterOrder 决定了这个过滤器的执行顺序 这里是 ：-3 见//public static final int SERVLET_DETECTION_FILTER_ORDER = -3;@OverridepublicintfilterOrder() {
returnSERVLET_DETECTION_FILTER_ORDER;
    }
@OverridepublicbooleanshouldFilter() {
returntrue; 
    }
@OverridepublicObjectrun() {
RequestContextctx=RequestContext.getCurrentContext();
//判断结果保存到  HttpServletRequest中HttpServletRequestrequest=ctx.getRequest();
//如果请求中设置了DispatcherServletRequest属性就给RequestContext 设置 IS_DISPATCHER_SERVLET_REQUEST_KEY = trueif (!(requestinstanceofHttpServletRequestWrapper) 
&&isDispatcherServletRequest(request)) {
//上下文设置：isDispatcherServletRequest = truectx.set(IS_DISPATCHER_SERVLET_REQUEST_KEY, true);
        } else {
//上下文设置：isDispatcherServletRequest = falsectx.set(IS_DISPATCHER_SERVLET_REQUEST_KEY, false);
        }
returnnull;
    }
//判断当前请求是否是DispatcherServletRequestprivatebooleanisDispatcherServletRequest(HttpServletRequestrequest) {
returnrequest.getAttribute(DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE) !=null;
    }       
}

/*** Pre {@link ZuulFilter} that parses form data and reencodes it for downstream services** @author Dave Syer*/publicclassFormBodyWrapperFilterextendsZuulFilter {
    ...省略...
@OverridepublicStringfilterType() {
//前置FilterreturnPRE_TYPE;
    }
@OverridepublicintfilterOrder() {
//执行顺序 -1returnFORM_BODY_WRAPPER_FILTER_ORDER;
    }
@OverridepublicObjectrun() {
RequestContextctx=RequestContext.getCurrentContext();
//处理请求HttpServletRequestrequest=ctx.getRequest();
FormBodyRequestWrapperwrapper=null;
if (requestinstanceofHttpServletRequestWrapper) {
HttpServletRequestwrapped= (HttpServletRequest) ReflectionUtils                    .getField(this.requestField, request);
//包装成 FormBodyRequestWrapperwrapper=newFormBodyRequestWrapper(wrapped);
ReflectionUtils.setField(this.requestField, request, wrapper);
if (requestinstanceofServletRequestWrapper) {
ReflectionUtils.setField(this.servletRequestField, request, wrapper);
            }
        }
else {
//包装成 FormBodyRequestWrapperwrapper=newFormBodyRequestWrapper(request);
ctx.setRequest(wrapper);
        }
if (wrapper!=null) {
ctx.getZuulRequestHeaders().put("content-type", wrapper.getContentType());
        }
returnnull;
    }
...省略...
 }

/*** Pre {@link ZuulFilter} that sets {@link RequestContext} debug attributes to true if* the "debug" request parameter is set.** @author Spencer Gibb*/publicclassDebugFilterextendsZuulFilter {
privatestaticfinalDynamicBooleanPropertyROUTING_DEBUG=DynamicPropertyFactory            .getInstance().getBooleanProperty(ZuulConstants.ZUUL_DEBUG_REQUEST, false);
privatestaticfinalDynamicStringPropertyDEBUG_PARAMETER=DynamicPropertyFactory            .getInstance().getStringProperty(ZuulConstants.ZUUL_DEBUG_PARAMETER, "debug");
@OverridepublicStringfilterType() {
returnPRE_TYPE;
    }
@OverridepublicintfilterOrder() {
returnDEBUG_FILTER_ORDER;
    }
@OverridepublicbooleanshouldFilter() {
HttpServletRequestrequest=RequestContext.getCurrentContext().getRequest();
if ("true".equals(request.getParameter(DEBUG_PARAMETER.get()))) {
returntrue;
        }
returnROUTING_DEBUG.get();
    }
@OverridepublicObjectrun() {
RequestContextctx=RequestContext.getCurrentContext();
//设置上下文，开启Routing和Request的debug功能ctx.setDebugRouting(true);
ctx.setDebugRequest(true);
returnnull;
    }
}

/*** Pre {@link ZuulFilter} that wraps requests in a Servlet 3.0 compliant wrapper.* Zuul's default wrapper is only Servlet 2.5 compliant.* @author Spencer Gibb*/publicclassServlet30WrapperFilterextendsZuulFilter {
privateFieldrequestField=null;
publicServlet30WrapperFilter() {
this.requestField=ReflectionUtils.findField(HttpServletRequestWrapper.class,
"req", HttpServletRequest.class);
Assert.notNull(this.requestField,
"HttpServletRequestWrapper.req field not found");
this.requestField.setAccessible(true);
    }
protectedFieldgetRequestField() {
returnthis.requestField;
    }
@OverridepublicStringfilterType() {
returnPRE_TYPE;
    }
@OverridepublicintfilterOrder() {
returnSERVLET_30_WRAPPER_FILTER_ORDER;
    }
@OverridepublicObjectrun() {
//把请求包装成  Servlet30RequestWrapperRequestContextctx=RequestContext.getCurrentContext();
HttpServletRequestrequest=ctx.getRequest();
if (requestinstanceofHttpServletRequestWrapper) {
request= (HttpServletRequest) ReflectionUtils.getField(this.requestField,
request);
ctx.setRequest(newServlet30RequestWrapper(request));
        }
elseif (RequestUtils.isDispatcherServletRequest()) {
// If it's going through the dispatcher we need to buffer the bodyctx.setRequest(newServlet30RequestWrapper(request));
        }
returnnull;
    }
}

/*** Post {@link ZuulFilter} that writes responses from proxied requests to the current response.** @author Spencer Gibb* @author Dave Syer* @author Ryan Baxter*/publicclassSendResponseFilterextendsZuulFilter {
...省略...
@OverridepublicObjectrun() {
try {
//添加响应头addResponseHeaders();
//添加响应的内容writeResponse();
        }
catch (Exceptionex) {
ReflectionUtils.rethrowRuntimeException(ex);
        }
returnnull;
    }
privatevoidwriteResponse() throwsException {
RequestContextcontext=RequestContext.getCurrentContext();
// there is no body to sendif (context.getResponseBody() ==null&&context.getResponseDataStream() ==null) {
return;
        }
HttpServletResponseservletResponse=context.getResponse();
if (servletResponse.getCharacterEncoding() ==null) { // only set if not setservletResponse.setCharacterEncoding("UTF-8");
        }
OutputStreamoutStream=servletResponse.getOutputStream();
InputStreamis=null;
try {
if (RequestContext.getCurrentContext().getResponseBody() !=null) {
Stringbody=RequestContext.getCurrentContext().getResponseBody();
writeResponse(
newByteArrayInputStream(
body.getBytes(servletResponse.getCharacterEncoding())),
outStream);
return;
            }
        ...省略...
//写响应结果privatevoidwriteResponse(InputStreamzin, OutputStreamout) throwsException {
byte[] bytes=buffers.get();
intbytesRead=-1;
while ((bytesRead=zin.read(bytes)) !=-1) {
out.write(bytes, 0, bytesRead);
        }
    }
}

/*** Error {@link ZuulFilter} that forwards to /error (by default) if {@link RequestContext#getThrowable()} is not null.** @author Spencer Gibb*///TODO: move to error package in EdgwarepublicclassSendErrorFilterextendsZuulFilter {
privatestaticfinalLoglog=LogFactory.getLog(SendErrorFilter.class);
protectedstaticfinalStringSEND_ERROR_FILTER_RAN="sendErrorFilter.ran";
//异常重定向路径@Value("${error.path:/error}")
privateStringerrorPath;
@OverridepublicStringfilterType() {
returnERROR_TYPE;
    }
@OverridepublicintfilterOrder() {
returnSEND_ERROR_FILTER_ORDER;
    }
@OverridepublicbooleanshouldFilter() {
RequestContextctx=RequestContext.getCurrentContext();
// only forward to errorPath if it hasn't been forwarded to alreadyreturnctx.getThrowable() !=null&&!ctx.getBoolean(SEND_ERROR_FILTER_RAN, false);
    }
@OverridepublicObjectrun() {
try {
RequestContextctx=RequestContext.getCurrentContext();
//找到异常ZuulExceptionexception=findZuulException(ctx.getThrowable());
HttpServletRequestrequest=ctx.getRequest();
//处理异常错误码等request.setAttribute("javax.servlet.error.status_code", exception.nStatusCode);
log.warn("Error during filtering", exception);
request.setAttribute("javax.servlet.error.exception", exception);
if (StringUtils.hasText(exception.errorCause)) {
request.setAttribute("javax.servlet.error.message", exception.errorCause);
            }
RequestDispatcherdispatcher=request.getRequestDispatcher(
this.errorPath);
if (dispatcher!=null) {
ctx.set(SEND_ERROR_FILTER_RAN, true);
if (!ctx.getResponse().isCommitted()) {
ctx.setResponseStatusCode(exception.nStatusCode);
dispatcher.forward(request, ctx.getResponse());
                }
            }
        }
catch (Exceptionex) {
ReflectionUtils.rethrowRuntimeException(ex);
        }
returnnull;
    }
}

/*** Route {@link ZuulFilter} that forwards requests using the {@link RequestDispatcher}.* Forwarding location is located in the {@link RequestContext} attribute {@link org.springframework.cloud.netflix.zuul.filters.support.FilterConstants#FORWARD_TO_KEY}.* Useful for forwarding to endpoints in the current application.用户RequestDispatcher 进行本地应用端点的Forwarding* @author Dave Syer*/publicclassSendForwardFilterextendsZuulFilter {
    ...省略...
@OverridepublicObjectrun() {
try {
RequestContextctx=RequestContext.getCurrentContext();
Stringpath= (String) ctx.get(FORWARD_TO_KEY);
RequestDispatcherdispatcher=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 (Exceptionex) {
ReflectionUtils.rethrowRuntimeException(ex);
        }
returnnull;
    }
}

/*** Pre {@link ZuulFilter} that determines where and how to route based on the supplied {@link RouteLocator}.* Also sets various proxy related headers for downstream requests.*/publicclassPreDecorationFilterextendsZuulFilter {
    ...省略...
@OverridepublicObjectrun() {
//请求上下文RequestContextctx=RequestContext.getCurrentContext();
//请求路径finalStringrequestURI=this.urlPathHelper.getPathWithinApplication(ctx.getRequest());
//根据请求地址，匹配匹配路由（url对应要访问的服务）Routeroute=this.routeLocator.getMatchingRoute(requestURI);
if (route!=null) {
//从路由中获取请求服务idStringlocation=route.getLocation();
if (location!=null) {
//设置请求上下文相关信息//请求的资源路径  pathctx.put(REQUEST_URI_KEY, route.getPath());
//路由的idctx.put(PROXY_KEY, route.getId());
if (!route.isCustomSensitiveHeaders()) {
//忽略敏感的请求头this.proxyRequestHelper                        .addIgnoredHeaders(this.properties.getSensitiveHeaders().toArray(newString[0]));
                }
else {
this.proxyRequestHelper.addIgnoredHeaders(route.getSensitiveHeaders().toArray(newString[0]));
                }
if (route.getRetryable() !=null) {
//可否重试ctx.put(RETRYABLE_KEY, route.getRetryable());
                }
if (location.startsWith(HTTP_SCHEME+":") ||location.startsWith(HTTPS_SCHEME+":")) {
ctx.setRouteHost(getUrl(location));
ctx.addOriginResponseHeader(SERVICE_HEADER, location);
                }
elseif (location.startsWith(FORWARD_LOCATION_PREFIX)) {
ctx.set(FORWARD_TO_KEY,
StringUtils.cleanPath(location.substring(FORWARD_LOCATION_PREFIX.length()) +route.getPath()));
ctx.setRouteHost(null);
returnnull;
                }
else {
//设置服务id绑定到上下文个，在RibbonReques中使用// set serviceId for use in filters.route.RibbonRequestctx.set(SERVICE_ID_KEY, location);
ctx.setRouteHost(null);
ctx.addOriginResponseHeader(SERVICE_ID_HEADER, location);
                }
//添加代理请求头if (this.properties.isAddProxyHeaders()) {
addProxyHeaders(ctx, route);
Stringxforwardedfor=ctx.getRequest().getHeader(X_FORWARDED_FOR_HEADER);
StringremoteAddr=ctx.getRequest().getRemoteAddr();
if (xforwardedfor==null) {
xforwardedfor=remoteAddr;
                    }
elseif (!xforwardedfor.contains(remoteAddr)) { // Prevent duplicatesxforwardedfor+=", "+remoteAddr;
                    }
ctx.addZuulRequestHeader(X_FORWARDED_FOR_HEADER, xforwardedfor);
                }
if (this.properties.isAddHostHeader()) {
ctx.addZuulRequestHeader(HttpHeaders.HOST, toHostHeader(ctx.getRequest()));
                }
                ...省略...

/*** Route {@link ZuulFilter} that uses Ribbon, Hystrix and pluggable http clients to send requests.* ServiceIds are found in the {@link RequestContext} attribute {@link org.springframework.cloud.netflix.zuul.filters.support.FilterConstants#SERVICE_ID_KEY}.通过  Ribbon 和  Hystrix 向http客户端发送请求通过 RequestContext找到  ServiceIds服务id ,* @author Spencer Gibb* @author Dave Syer* @author Ryan Baxter*/publicclassRibbonRoutingFilterextendsZuulFilter {
    ...省略...
@OverridepublicObjectrun() {
//获取请求上下文 RequestContextcontext=RequestContext.getCurrentContext();
this.helper.addIgnoredHeaders();
try {
//创建一个 RibbonCommandContext Ribbon命令上下文，用来发请求RibbonCommandContextcommandContext=buildCommandContext(context);
//发送请求，获取到结果ClientHttpResponseresponse=forward(commandContext);
setResponse(response);
returnresponse;
        }
catch (ZuulExceptionex) {
thrownewZuulRuntimeException(ex);
        }
catch (Exceptionex) {
thrownewZuulRuntimeException(ex);
        }
    }
//根据RequestContext 请求上下文，获取请求服务id，url等封装成RibbonCommandContextprotectedRibbonCommandContextbuildCommandContext(RequestContextcontext) {
HttpServletRequestrequest=context.getRequest();
MultiValueMap<String, String>headers=this.helper            .buildZuulRequestHeaders(request);
MultiValueMap<String, String>params=this.helper            .buildZuulRequestQueryParams(request);
Stringverb=getVerb(request);
InputStreamrequestEntity=getRequestBody(request);
if (request.getContentLength() <0&&!verb.equalsIgnoreCase("GET")) {
context.setChunkedRequestBody();
        }
StringserviceId= (String) context.get(SERVICE_ID_KEY);
Booleanretryable= (Boolean) context.get(RETRYABLE_KEY);
ObjectloadBalancerKey=context.get(LOAD_BALANCER_KEY);
Stringuri=this.helper.buildZuulRequestURI(request);
// remove double slashesuri=uri.replace("//", "/");
longcontentLength=useServlet31?request.getContentLengthLong(): request.getContentLength();
returnnewRibbonCommandContext(serviceId, verb, uri, retryable, headers, params,
requestEntity, this.requestCustomizers, contentLength, loadBalancerKey);
    }
protectedClientHttpResponseforward(RibbonCommandContextcontext) throwsException {
Map<String, Object>info=this.helper.debug(context.getMethod(),
context.getUri(), context.getHeaders(), context.getParams(),
context.getRequestEntity());
RibbonCommandcommand=this.ribbonCommandFactory.create(context);
try {
//执行请求ClientHttpResponseresponse=command.execute();
this.helper.appendDebug(info, response.getRawStatusCode(), response.getHeaders());
returnresponse;
        }
catch (HystrixRuntimeExceptionex) {
//处理异常returnhandleException(info, ex);
        }
    }
//处理异常protectedClientHttpResponsehandleException(Map<String, Object>info,
HystrixRuntimeExceptionex) throwsZuulException {
intstatusCode=HttpStatus.INTERNAL_SERVER_ERROR.value();
Throwablecause=ex;
Stringmessage=ex.getFailureType().toString();
ClientExceptionclientException=findClientException(ex);
if (clientException==null) {
clientException=findClientException(ex.getFallbackException());
        }
if (clientException!=null) {
if (clientException                .getErrorType() ==ClientException.ErrorType.SERVER_THROTTLED) {
statusCode=HttpStatus.SERVICE_UNAVAILABLE.value();
            }
cause=clientException;
message=clientException.getErrorType().toString();
        }
info.put("status", String.valueOf(statusCode));
thrownewZuulException(cause, "Forwarding error", statusCode, message);
    }

/*** Route {@link ZuulFilter} that sends requests to predetermined URLs via apache* {@link HttpClient}. URLs are found in {@link RequestContext#getRouteHost()}.通过RequestContext#getRouteHost()找到调用的服务地址 ，使用apache的http客户端实现调用** @author Spencer Gibb* @author Dave Syer* @author Bilal Alp* @author Gang Li*/publicclassSimpleHostRoutingFilterextendsZuulFilter {
    ...省略...
@OverridepublicObjectrun() {
RequestContextcontext=RequestContext.getCurrentContext();
HttpServletRequestrequest=context.getRequest();
MultiValueMap<String, String>headers=this.helper            .buildZuulRequestHeaders(request);
MultiValueMap<String, String>params=this.helper            .buildZuulRequestQueryParams(request);
Stringverb=getVerb(request);
InputStreamrequestEntity=getRequestBody(request);
if (request.getContentLength() <0) {
context.setChunkedRequestBody();
        }
//获取请求地址Stringuri=this.helper.buildZuulRequestURI(request);
this.helper.addIgnoredHeaders();
try {
//发送请求CloseableHttpResponseresponse=forward(this.httpClient, verb, uri, request,
headers, params, requestEntity);
setResponse(response);
        }
catch (Exceptionex) {
thrownewZuulRuntimeException(ex);
        }
returnnull;
    }
------------------------------------//使用 httpclient 发送请求privateCloseableHttpResponseforward(CloseableHttpClienthttpclient, Stringverb,
Stringuri, HttpServletRequestrequest, MultiValueMap<String, String>headers,
MultiValueMap<String, String>params, InputStreamrequestEntity)
throwsException {
Map<String, Object>info=this.helper.debug(verb, uri, headers, params,
requestEntity);
//请求主机URLhost=RequestContext.getCurrentContext().getRouteHost();
HttpHosthttpHost=getHttpHost(host);
//请求地址uri=StringUtils.cleanPath((host.getPath() +uri).replaceAll("/{2,}", "/"));
intcontentLength=request.getContentLength();
ContentTypecontentType=null;
if (request.getContentType() !=null) {
contentType=ContentType.parse(request.getContentType());
        }
InputStreamEntityentity=newInputStreamEntity(requestEntity, contentLength,
contentType);
HttpRequesthttpRequest=buildHttpRequest(verb, uri, entity, headers, params,
request);
try {
log.debug(httpHost.getHostName() +" "+httpHost.getPort() +" "+httpHost.getSchemeName());
//发送请求CloseableHttpResponsezuulResponse=forwardRequest(httpclient, httpHost,
httpRequest);
this.helper.appendDebug(info, zuulResponse.getStatusLine().getStatusCode(),
revertHeaders(zuulResponse.getAllHeaders()));
returnzuulResponse;
        }
finally {
// When HttpClient instance is no longer needed,// shut down the connection manager to ensure// immediate deallocation of all system resources// httpclient.getConnectionManager().shutdown();        }
    }
------------------------------------protectedHttpRequestbuildHttpRequest(Stringverb, Stringuri,
InputStreamEntityentity, MultiValueMap<String, String>headers,
MultiValueMap<String, String>params, HttpServletRequestrequest) {
HttpRequesthttpRequest;
StringuriWithQueryString=uri+ (this.forceOriginalQueryStringEncoding?getEncodedQueryString(request) : 
this.helper.getQueryString(params));
//处理各种请求方式switch (verb.toUpperCase()) {
case"POST":
HttpPosthttpPost=newHttpPost(uriWithQueryString);
httpRequest=httpPost;
httpPost.setEntity(entity);
break;
case"PUT":
HttpPuthttpPut=newHttpPut(uriWithQueryString);
httpRequest=httpPut;
httpPut.setEntity(entity);
break;
case"PATCH":
HttpPatchhttpPatch=newHttpPatch(uriWithQueryString);
httpRequest=httpPatch;
httpPatch.setEntity(entity);
break;
case"DELETE":
BasicHttpEntityEnclosingRequestentityRequest=newBasicHttpEntityEnclosingRequest(
verb, uriWithQueryString);
httpRequest=entityRequest;
entityRequest.setEntity(entity);
break;
default:
httpRequest=newBasicHttpRequest(verb, uriWithQueryString);
log.debug(uriWithQueryString);
        }
httpRequest.setHeaders(convertHeaders(headers));
returnhttpRequest;
    }
------------------------------------//最终执行请求privateCloseableHttpResponseforwardRequest(CloseableHttpClienthttpclient,
HttpHosthttpHost, HttpRequesthttpRequest) throwsIOException {
returnhttpclient.execute(httpHost, httpRequest);
    }