zuul源码深度解析之一：enableZuulServer的初始化

最新推荐文章于 2023-03-16 10:45:47 发布
最新推荐文章于 2023-03-16 10:45:47 发布
阅读量360 收藏 2
点赞数
文章标签： 网关 spring boot java 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/soonyigkka/article/details/113650983
版权

zuul源码深度解析（一）- enableZuulServer的初始化

前言

基于spring cloud分析，对应pom文件如下：

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-zuul</artifactId>
			<!--zuul-core及spring-cloud-netflix-core建议从github下载源码后导入项目引入（修改源码常用操作），如果只做学习使用且习惯借助于idle解析jar包，则可以删掉exclusions-->
			<exclusions>
				<exclusion>
					<groupId>com.netflix.zuul</groupId>
					<artifactId>zuul-core</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.springframework.cloud</groupId>
					<artifactId>spring-cloud-netflix-core</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

源码版本：spring-cloud-start-zuul版本1.4.4.RELEASE，zuul-core版本1.3.0。建议对网关的原理及基础知识有一定了解后，再对源码进行解读。

1、zuul的初始化

使用zuul的方式非常简单，在启动类上增加@EnableZuulProxy或EnableZuulServer注解即可。

1.1、@EnableZuulServer的初始化

1.1.1、EnableZuulServer源码分析

主要引入zuulServerMakerConfiguration类。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(ZuulServerMarkerConfiguration.class)
public @interface EnableZuulServer {

}

1.1.2、ZuulServerMarkerConfiguration源码分析

初始化了Marker对象，由注释可以得知@link ZuulServerAutoConfiguration

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

@Configuration
public class ZuulServerMarkerConfiguration {
	@Bean
	public Marker zuulServerMarkerBean() {
		return new Marker();
	}

	class Marker {
	}
}

1.1.3、ZuulServerAutoConfiguration源码分析

ZuulServerAutoConfiguration是@EnableZuulServer的核心初始化类，我们做重点分析，类的注解重点关注@ConditionalOnBean(ZuulServerMarkerConfiguration.Marker.class)。由此可知通过Maker对象注入spring容器，所以在application启动类加注解@EnableZuulServer，则spring容器最终会加载@zuulServerAutoConfiguration.该类加载的对象比较多，我们逐一介绍

@Configuration
@EnableConfigurationProperties({ ZuulProperties.class })
@ConditionalOnClass(ZuulServlet.class)
@ConditionalOnBean(ZuulServerMarkerConfiguration.Marker.class)
// Make sure to get the ServerProperties from the same place as a normal web app would
@Import(ServerPropertiesAutoConfiguration.class)
public class ZuulServerAutoConfiguration {
  1. zuulProperties:加载application.properties中的配置项，常见的配置如：zuul.routes..path,zuul.routes..url等
	@Autowired
	protected ZuulProperties zuulProperties;
  1. routeLocate相关的类，网关对应路由信息的实现类，主要负责加载路由规则，是网关路由转发寻址的核心，SimpleRouteLocator加载的是配置文件的信息，注意注解标注@ConditionalOnMissingBean；CompositeRouteLocator 是组合路由，注解标注为@Primary。RouteLocator 路由规则确认会在后续章节RouteLocator路由规则加载详细介绍。
	@Bean
	@Primary
	public CompositeRouteLocator primaryRouteLocator(
			Collection<RouteLocator> routeLocators) {
		return new CompositeRouteLocator(routeLocators);
	}

	@Bean
	@ConditionalOnMissingBean(SimpleRouteLocator.class)
	public SimpleRouteLocator simpleRouteLocator() {
		return new SimpleRouteLocator(this.server.getServletPrefix(),
				this.zuulProperties);
	}
  1. ZuulController 继承ServletWrappingController，ZuulHandlerMapping 继承AbstractUrlHandlerMapping都是servlet相关组件，当发送http、https请求是spring mvc做请求分发是会查找handler（zuulHandlerMapping），在通过handlerAdapter找到合适的Handler处理器zuulController，dispatch流程会在后续Zuul请求流程中分析。
	@Bean
	public ZuulController zuulController() {
		return new ZuulController();
	}

	@Bean
	public ZuulHandlerMapping zuulHandlerMapping(RouteLocator routes) {
		ZuulHandlerMapping mapping = new ZuulHandlerMapping(routes, zuulController());
		mapping.setErrorController(this.errorController);
		return mapping;
	}
  1. pre filter相关类ServletDetectionFilter ，FormBodyWrapperFilter ，DebugFilter ，Servlet30WrapperFilter
	@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();
	}
过滤器类型order执行条件描述
ServletDetectionFilterpre-3检测请求是用DispatcherServlet还是zuulServlet，该过滤器是默认过滤器中最先执行的，且总会执行（shouldFilter返回true），严格来说，若请求path，在网关有路由配置，则一定会执行。主要用来检测当前请求是通过DispatcherServlet处理运行，还是zuulServlet来处理运行。检测结果会以布尔类型保存在上下文的isDispatchServletRequest参数
@Override
	public boolean shouldFilter() {
		return true; 
	}

	@Override
	public Object run() {
		RequestContext ctx = RequestContext.getCurrentContext();
		HttpServletRequest request = ctx.getRequest();
		if (!(request instanceof HttpServletRequestWrapper) 
				&& isDispatcherServletRequest(request)) {
			ctx.set(IS_DISPATCHER_SERVLET_REQUEST_KEY, true);
		} else {
			ctx.set(IS_DISPATCHER_SERVLET_REQUEST_KEY, false);
		}

		return null;
	}

zuulServlet跟DispatcherServlet的区别在于/zuul(可通过zuul.servletPath配置) 会通过zuulServlet分发，原因在于Content-Type为multipart/form的请求且是DispatcherServlet分发的请求会通过FromBodyWrapperFilter处理封装加强，而对于大文件流的请求，会影响性能。DispacherServlet分发及FromBodyWrapperFilter处理大文件的性能损耗会比较大。所以此类请求可以通过/zuul通过zuulServlet分发。

	@Bean
	@ConditionalOnMissingBean(name = "zuulServlet")
	public ServletRegistrationBean zuulServlet() {
		ServletRegistrationBean 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;
	}
	public String getServletPattern() {
		String path = this.servletPath;
		if (!path.startsWith("/")) {
			path = "/" + path;
		}
		if (!path.contains("*")) {
			path = path.endsWith("/") ? (path + "*") : (path + "/*");
		}
		return path;
	}
过滤器类型order执行条件描述
Servlet30WrapperFilterpre-2总是执行装饰器模式，将原始的HttpServletRequest包装成Servlet30Request对象，实际等同于HttpServletRequest对象，未在代码处看到相关增强的功能
@Override
	public boolean shouldFilter() {
		return true; // TODO: only if in servlet 3.0 env
	}

	@Override
	public Object run() {
		RequestContext ctx = RequestContext.getCurrentContext();
		HttpServletRequest request = ctx.getRequest();
		if (request instanceof HttpServletRequestWrapper) {
			request = (HttpServletRequest) ReflectionUtils.getField(this.requestField,
					request);
			ctx.setRequest(new Servlet30RequestWrapper(request));
		}
		else if (RequestUtils.isDispatcherServletRequest()) {
			// If it's going through the dispatcher we need to buffer the body
			ctx.setRequest(new Servlet30RequestWrapper(request));
		}
		return null;
	}
过滤器类型order执行条件描述
FromBodyWrapperFilterpre-1Content-Type为application/x-www-from-urlencode或（multipart/form-data且为DispatcherServlet）该过滤器主要作用是将符合要求的请求包装成FromBodyRequestWrapper（继承Servlet30WrapperFilter）对象
	@Override
	public boolean shouldFilter() {
		RequestContext ctx = RequestContext.getCurrentContext();
		HttpServletRequest request = ctx.getRequest();
		String contentType = request.getContentType();
		// Don't use this filter on GET method
		if (contentType == null) {
			return false;
		}
		// Only use this filter for form data and only for multipart data in a
		// DispatcherServlet handler
		try {
			MediaType mediaType = MediaType.valueOf(contentType);
			return MediaType.APPLICATION_FORM_URLENCODED.includes(mediaType)
					|| (isDispatcherServletRequest(request)
							&& MediaType.MULTIPART_FORM_DATA.includes(mediaType));
		}
		catch (InvalidMediaTypeException ex) {
			return false;
		}
	}

	private boolean isDispatcherServletRequest(HttpServletRequest request) {
		return request.getAttribute(
				DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null;
	}

	@Override
	public Object run() {
		RequestContext ctx = RequestContext.getCurrentContext();
		HttpServletRequest request = ctx.getRequest();
		FormBodyRequestWrapper wrapper = null;
		if (request instanceof HttpServletRequestWrapper) {
			HttpServletRequest wrapped = (HttpServletRequest) ReflectionUtils
					.getField(this.requestField, request);
			wrapper = new FormBodyRequestWrapper(wrapped);
			ReflectionUtils.setField(this.requestField, request, wrapper);
			if (request instanceof ServletRequestWrapper) {
				ReflectionUtils.setField(this.servletRequestField, request, wrapper);
			}
		}
		else {
			wrapper = new FormBodyRequestWrapper(request);
			ctx.setRequest(wrapper);
		}
		if (wrapper != null) {
			ctx.getZuulRequestHeaders().put("content-type", wrapper.getContentType());
		}
		return null;
	}

FromBodyRequestWrapper的相关增强功能如下，可以看到在
getContentType，getContentLength，getContentLengthLong做了相关封装。

private class FormBodyRequestWrapper extends Servlet30RequestWrapper {

		private HttpServletRequest request;

		private volatile byte[] contentData;

		private MediaType contentType;

		private int contentLength;

		public FormBodyRequestWrapper(HttpServletRequest request) {
			super(request);
			this.request = request;
		}

		@Override
		public String getContentType() {
			if (this.contentData == null) {
				buildContentData();
			}
			return this.contentType.toString();
		}

		@Override
		public int getContentLength() {
			if (super.getContentLength() <= 0) {
				return super.getContentLength();
			}
			if (this.contentData == null) {
				buildContentData();
			}
			return this.contentLength;
		}

		public long getContentLengthLong() {
			return getContentLength();
		}

		@Override
		public ServletInputStream getInputStream() throws IOException {
			if (this.contentData == null) {
				buildContentData();
			}
			return new ServletInputStreamWrapper(this.contentData);
		}

		private synchronized void buildContentData() {
			if (this.contentData != null) {
				return;
			}
			try {
				MultiValueMap<String, Object> builder = RequestContentDataExtractor.extract(this.request);
				FormHttpOutputMessage data = new FormHttpOutputMessage();

				this.contentType = MediaType.valueOf(this.request.getContentType());
				data.getHeaders().setContentType(this.contentType);
				FormBodyWrapperFilter.this.formHttpMessageConverter.write(builder, this.contentType, data);
				// copy new content type including multipart boundary
				this.contentType = data.getHeaders().getContentType();
				byte[] input = data.getInput();
				this.contentLength = input.length;
				this.contentData = input;
			}
			catch (Exception e) {
				throw new IllegalStateException("Cannot convert form data", e);
			}
		}
	}
过滤器类型order执行条件描述
DebugFilterpre1生效方式为zuul.debug.request参数配置为true或请求参数zuul.debug.parameter设置为true在上下文设置debugRouting,debugRequest参数为true
	@Override
	public boolean shouldFilter() {
		HttpServletRequest request = RequestContext.getCurrentContext().getRequest();
		if ("true".equals(request.getParameter(DEBUG_PARAMETER.get()))) {
			return true;
		}
		return ROUTING_DEBUG.get();
	}

	@Override
	public Object run() {
		RequestContext ctx = RequestContext.getCurrentContext();
		ctx.setDebugRouting(true);
		ctx.setDebugRequest(true);
		return null;
	}
  1. routeFilter相关类：sendFowrdFilter
过滤器类型order执行条件描述
sendFowrdFilterroute500上下文中存在forward.to值，且sendForwardFilter.ran未设置值或为false使用requestDispatcher 发送相关请求，在preDecorationFilter(@EnableZuulProxy注解引入)中会处理url为forward:开头的url地址，这部分配置forward:开头的请求会通过此过滤器转发请求。
	@Override
	public boolean shouldFilter() {
		RequestContext ctx = RequestContext.getCurrentContext();
		return ctx.containsKey(FORWARD_TO_KEY)
				&& !ctx.getBoolean(SEND_FORWARD_FILTER_RAN, false);
	}

	@Override
	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;
	}
  1. post filter相关类：sendReponseFilter
过滤器类型order执行条件描述
sendReponseFilterpost1000上下文中包含请求响应相关的头信息、响应数据、响应体中的任何一个且上下文中未被设置异常，设置异常了则会给sendErrorFilter处理组装响应信息返回给客户端
	@Override
	public boolean shouldFilter() {
		RequestContext context = RequestContext.getCurrentContext();
		return context.getThrowable() == null
				&& (!context.getZuulResponseHeaders().isEmpty()
					|| context.getResponseDataStream() != null
					|| context.getResponseBody() != null);
	}

	@Override
	public Object run() {
		try {
			addResponseHeaders();
			writeResponse();
		}
		catch (Exception ex) {
			ReflectionUtils.rethrowRuntimeException(ex);
		}
		return null;
	}
  1. error filter相关类：SendErrorFilter
过滤器类型order执行条件描述
SendErrorFiltererror0上下文中包含异常信息，且sendErrorFilter.ran不为true时执行该类在1.4.4的版本中放在org.springframework.cloud.netflix.zuul.filters.post包下，此处不大规范，容易被误解成post过滤器。翻了下1.0.0的版本，SendErrorFilter类型为post类型。改成error过滤器后，结合zuulServlet中的各过滤器的执行逻辑顺序，异常处理会更加合理。error跟前面的response过滤器有个互斥条件ctx.getThrowable() ，所以最多只会执行一个
	@Override
	public boolean shouldFilter() {
		RequestContext ctx = RequestContext.getCurrentContext();
		// only forward to errorPath if it hasn't been forwarded to already
		return ctx.getThrowable() != null
				&& !ctx.getBoolean(SEND_ERROR_FILTER_RAN, false);
	}

	@Override
	public Object run() {
		try {
			RequestContext ctx = RequestContext.getCurrentContext();
			ZuulException exception = findZuulException(ctx.getThrowable());
			HttpServletRequest request = 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);
			}

			RequestDispatcher dispatcher = 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 (Exception ex) {
			ReflectionUtils.rethrowRuntimeException(ex);
		}
		return null;
	}
  1. 监控相关ZuulRefreshListener，观察者模式，监听applicaitonEvent事件。触发监听事件后，会做更新route的操作。
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) {
				this.zuulHandlerMapping.setDirty(true);
			}
			else if (event instanceof HeartbeatEvent) {
				if (this.heartbeatMonitor.update(((HeartbeatEvent) event).getValue())) {
					this.zuulHandlerMapping.setDirty(true);
				}
			}
		}

	}

实际项目过程中，HeartbeatEvent会频繁的 触发，原因是引入的spring-cloud-start-zuul包中包含eureka组件。引入该组件的工程服务，DiscoveryClient会每隔30s发心跳事件。心跳代码如下

 if (clientConfig.shouldRegisterWithEureka()) {
            int renewalIntervalInSecs = instanceInfo.getLeaseInfo().getRenewalIntervalInSecs();
            int expBackOffBound = clientConfig.getHeartbeatExecutorExponentialBackOffBound();
            logger.info("Starting heartbeat executor: " + "renew interval is: " + renewalIntervalInSecs);

            // Heartbeat timer
            scheduler.schedule(
                    new TimedSupervisorTask(
                            "heartbeat",
                            scheduler,
                            heartbeatExecutor,
                            renewalIntervalInSecs,
                            TimeUnit.SECONDS,
                            expBackOffBound,
                            new HeartbeatThread()
                    ),
                    renewalIntervalInSecs, TimeUnit.SECONDS);
  1. ZuulFilterConfiguration :初始化filters，该类的主要作用是把spring容器里面的所有zuulFilter类初始化到Map filters中。执行过滤器逻辑时会根据此filters找到相关的过滤器执行。典型的责任链模式。
	@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);
		}

	}

以上是ZuulServerAutoConfiguration的主要相关内容，可以确认的是初始化了zuulProperties，各routeLocator，zuulController，zuulHandlerMapping，各zuulFilter。

soonyigkka
关注
zuul-server 拦截器
qq_42053822的博客
08-31 390
zuul-server 拦截器
Spring Cloud微服务网关Zuul的注解@EnableZuulProxy或@EnableZuulServer做了什么事情
最新发布
m0_71777195的博客
04-15 240
本文配了较多的源码，主要是和这两个SpringBoot自动配置类，涵盖了很多Zuul的组件，花点时间去阅读、debug会让你很快去了解去很多的工作流程和原理。虽然Zuul在国内越来越少人用了，但是源码还是值得学习的。
Zuul的@EnableZuulServer注解与@EnableZuulProxy的区别
实践求真知
07-29 6114
一 @EnableZuulServer注解适用于下面过滤器 二 @EnableZuulProxy注解适用于下面过滤器 注：灰色为不起效果的过滤器 三 说明 @EnableZuulServer注解是高配版本 @EnableZuulProxy注解是低配版本 如果不想让高版本多出的过滤器生效，可用低配版本注解 低配版本注解更适合自定义过滤器，因为经过的过...
十八.SpringCloud源码剖析-Zuul的自动配置和核心Filter详解
墨家巨子@俏如来
01-27 966
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一.@EnableZuulProxy 注解 @EnableZuulProxy
zuul-Error during filtering
qk
04-23 4217
开启zuul ，控制台报错 Error during filtering 解决方法：在配置文件中加入如下配置后重新启动zuul ribbon: ReadTimeout: 60000 ConnectTimeout: 60000 hystrix: command: default: execution: isolation: thread: timeoutInMilliseconds: 60000 ...
zuul-2.1.5:zuul原始码解析-源码解析
03-24
Zuul是一种边缘服务，提供动态路由，监视，弹性，安全性等 原始解析目录 1，zuul使用场景，主要实现技术栈，系统架构整体概述（含系统架构图） 2，动态路由，静态路由，鉴权，限流等实战..... 3，从0到1实现一个...
浅谈SpringCloud之zuul源码解析
08-27
在SpringCloud生态系统中， Zuul是一个...通过源码解析，我们可以更深入地理解Zuul的工作机制，从而更好地定制和优化我们的微服务架构。在实际开发中，了解这些细节可以帮助我们解决性能瓶颈，提升系统的稳定性和效率。
SpringCloud源码深度解析
01-27
SpringCloud是目前广泛应用的微服务框架，其源码解析对于开发者深入理解微服务架构和优化实践至关重要。在SpringCloud中，Eureka作为注册中心，它的功能和工作机制是整个微服务架构的关键。 Eureka的主要职责是管理...
zuul-oauth2-example:具有使用密码授予类型的oauth2授权的Spring Boot应用程序示例
05-02
zuul-oauth2-example 这是在Zuul代理后面使用oauth2授权服务器和单独的资源服务器的示例。 它支持使用示例用法的内部客户端授权工作流（ grant_type = password ）。 相关文章在。 组件 是Zuul代理（ ）。 是OAuth...
Spring Cloud Zuul网关调用服务出现ConnectTimeoutException: Connect to ip:port [/ip] failed: connect timed out
奔跑的蜗牛
07-09 4090
在学习使用Spring Cloud Zuul实现服务网关时，调用服务出现如下异常： Caused by: org.apache.http.conn.ConnectTimeoutException: Connect to 192.168.1.102:8081 [/192.168.1.102] failed: connect timed out at org.apache.http.impl.conn.DefaultHttpClientConnectionOperator.connect(D
springboot集成zuul，把请求转到对应的服务时报：o.s.c.n.z.filters.post.SendErrorFilter : Error during filtering
冰夜翎博客
03-16 1019
springboot集成zuul，把请求转到对应的服务时报：o.s.c.n.z.filters.post.SendErrorFilter : Error during filtering
com.netflix.zuul.exception.ZuulException: Forwarding error 报错问题
自由の力
06-27 4724
*** 网上搜了一圈,各种原因导致的报错,但是结合我自身的情况,应该是超时了 *** 所以zuul 的gateway里加入了如下配置,发现可以了,这个确实有点坑 host: socket-timeout-millis: 12000 connect-timeout-millis: 12000 ...
Zuul的高可用
实践求真知
06-27 6132
Zuul的高可用非常关键，因为外部请求到后端服务的流量都会经过Zuul。故而在生产环境下一般都需要部署高可用的Zuul以避免单点故障。一 Zuul客户端也注册到Eureka Server上这种情况下，Zuul的高可用非常简单，只须将多个Zuul节点注册到Eureka Server上，就可实现Zuul的高可用。此时Zuul的高可用与其他微服务的高可用没什么区别。如下图，当Zuul客户端也注册到Eur...
zuul实现所有接口对于带指定前缀和不带前缀的url均能兼容访问
翻身已碰头的博客
10-22 7601
我们的项目里通过zuul实现路由转发，前几日接到这么一个需求，需要实现所有接口对于带指定前缀和不带前缀的url均能兼容访问，网上这方面的文档并不多，因此为了处理这个需求，捎带着阅读了一下zuul的部分源码 首先说一下结论，zuul本身便实现了这个功能，对于带/zuul的前缀的url会自动去掉该前缀进行转发，完美匹配这次需求。 接着开始理解源码，看一看zuul是怎么实现的。 在springboot项...
zuul的forward error
weixin_34050005的博客
04-28 229
error log 2017-04-22 16:03:46.673 WARN 1405 --- [io-10000-exec-3] o.s.c.n.z.filters.post.SendErrorFilter : Error during filtering com.netflix.zuul.exception.ZuulExcep...
关于SpringCloud框架网关配置的@EnableZuulProxy注解出错问题
热门推荐
qq_14809913的博客
06-06 1万+
自学springcloud在搭建框架时，遇到了一个很奇怪的问题，在配置网关服务时，注解@EnableZuulProxy一直报错add maven dependency也无济于事 点击后在pom里自动配置了spring-cloud-starter-zuul但问题依然没有解决，网上百度也没看出过所以然  然后去官方看了一下zuul的源码  终于发现了问题原来在SpringBoot2.0以上版本应该导入...
微服务（六）网关zuul
qq_40223516的博客
07-26 603
网关zuul
spring-cloud-zuul之spring-cloud-1.3.4(Dalston.SR3)-boot(1.5.6) 学习笔记
undergrowth的专栏
09-23 1086
spring-cloud-zuul之spring-cloud-1.3.4(Dalston.SR3)-boot(1.5.6) 学习笔记概述 参考 http://blog.didispace.com/springcloud5/ http://blog.didispace.com/spring-cloud-source-zuul/ http://blog.csdn.net/undergrowth/art
SpringCloud微服务架构中的Zuul深度解析：Filter与实战
1. **Filter过滤器**：Zuul的核心特性之一，它允许开发者自定义过滤逻辑。过滤器分为四类：pre（前置过滤器），route（路由过滤器），post（后置过滤器）和error（错误过滤器）。pre过滤器常用于身份验证，如文中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值