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 doesnt
// 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 doesnt
// 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一些值进去就行了。

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

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

热门新闻

周热门

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

什么是jvm双亲委派模型？有什么用？

JVM简述下包括什么，有什么用？

现阶段最值得学的编程语言是什么？

怎么才能看到案例或者问题就知道用哪种代码解决？

有一些大公司，为什么还要使用过时的技术？

各位Coder都是怎么学习新技术的？

大数据是什么？多大的数据叫大数据？

哪种程序语言比较好？

编写完css后在浏览器中，只能显示静态的内容，样式无法显示，怎么办？

我国安卓市场是否已经饱和？

为什么狂多人迷信数学？

不用Spring怎么做开发？

用nginx这个反向代理伺服器实现负载均衡，集群几台伺服器，同时协作完成一个任务，这样的情景下就是分散式吗？

最火的编程语言是哪几种？

php还能火几年呢？

热门新闻

周热门