Java | Spring Cloud Gateway 是如何工作的

最新推荐文章于 2024-06-07 11:18:21 发布
最新推荐文章于 2024-06-07 11:18:21 发布
阅读量247 收藏
点赞数
分类专栏： Spring Cloud 文章标签： spring cloud gateway
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyndev/article/details/114295261
版权

Spring Cloud Gateway 是如何工作的

文档写的再好，也不如源码写的好
源码地址：
GitHub: https://github.com/spring-cloud/spring-cloud-gateway
Gitee: https://gitee.com/github_mirror_plus/spring-cloud-gateway

文章目录

在 Spring Cloud Gateway 流程图中，可以看出优先级低的 Filter 则在 Request 发送前最后处理，在 Response 响应后优先处理

在这里插入图片描述

负责转发请求的 NettyRoutingFilter

熟悉 Spring Cloud Gateway 用法的应该都知道 GlobalFilter 在 Spring Cloud Gateway 中，有一个有趣的 GlobalFilter 其优先级最低

其优先级根据 getOrder() 来判断，其实值越大则优先级越小，反之亦然

在其中 filter 方法做了以下几件事：

  1. 判断请求是否已经发送过，如果发送过，则不在处理
  2. 标记请求为发送过，并开始处理请求
  3. 处理下请求头信息
  4. 获取 Route 信息，里面设置了请求超时时间
  5. 使用 HttpClient 发送请求
  6. 发送请求并获取响应，将响应重新处理到 exchange ，最终得到 Flux<HttpClientResponse> responseFlux
  7. 判断 responseFlux 是否超时，如果超时则进行超时处理
  8. 结束
public class NettyRoutingFilter implements GlobalFilter, Ordered {

	private static final Log log = LogFactory.getLog(NettyRoutingFilter.class);

	/**
	 * 设置最低的优先级，此处为了最后处理请求，第一处理响应
	 */
	public static final int ORDER = Ordered.LOWEST_PRECEDENCE;

    // httpclient 负责转发请求
	private final HttpClient httpClient;

	private final ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider;

	private final HttpClientProperties properties;

	// do not use this headersFilters directly, use getHeadersFilters() instead.
	private volatile List<HttpHeadersFilter> headersFilters;

	public NettyRoutingFilter(HttpClient httpClient, ObjectProvider<List<HttpHeadersFilter>> headersFiltersProvider,
			HttpClientProperties properties) {
		this.httpClient = httpClient;
		this.headersFiltersProvider = headersFiltersProvider;
		this.properties = properties;
	}

	public List<HttpHeadersFilter> getHeadersFilters() {
		if (headersFilters == null) {
			headersFilters = headersFiltersProvider.getIfAvailable();
		}
		return headersFilters;
	}

	@Override
	public int getOrder() {
		return ORDER;
	}

	@Override
	@SuppressWarnings("Duplicates")
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR);

		String scheme = requestUrl.getScheme();
		if (isAlreadyRouted(exchange) || (!"http".equals(scheme) && !"https".equals(scheme))) {
			return chain.filter(exchange);
		}
		setAlreadyRouted(exchange);

		ServerHttpRequest request = exchange.getRequest();

		final HttpMethod method = HttpMethod.valueOf(request.getMethodValue());
		final String url = requestUrl.toASCIIString();

		HttpHeaders filtered = filterRequest(getHeadersFilters(), exchange);

		final DefaultHttpHeaders httpHeaders = new DefaultHttpHeaders();
		filtered.forEach(httpHeaders::set);

		boolean preserveHost = exchange.getAttributeOrDefault(PRESERVE_HOST_HEADER_ATTRIBUTE, false);
		Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);

		Flux<HttpClientResponse> responseFlux = getHttpClient(route, exchange).headers(headers -> {
			headers.add(httpHeaders);
			// Will either be set below, or later by Netty
			headers.remove(HttpHeaders.HOST);
			if (preserveHost) {
				String host = request.getHeaders().getFirst(HttpHeaders.HOST);
				headers.add(HttpHeaders.HOST, host);
			}
		}).request(method).uri(url).send((req, nettyOutbound) -> {
			if (log.isTraceEnabled()) {
				nettyOutbound.withConnection(connection -> log.trace("outbound route: "
						+ connection.channel().id().asShortText() + ", inbound: " + exchange.getLogPrefix()));
			}
			return nettyOutbound.send(request.getBody().map(this::getByteBuf));
		}).responseConnection((res, connection) -> {

			// Defer committing the response until all route filters have run
			// Put client response as ServerWebExchange attribute and write
			// response later NettyWriteResponseFilter
			exchange.getAttributes().put(CLIENT_RESPONSE_ATTR, res);
			exchange.getAttributes().put(CLIENT_RESPONSE_CONN_ATTR, connection);

			ServerHttpResponse response = exchange.getResponse();
			// put headers and status so filters can modify the response
			HttpHeaders headers = new HttpHeaders();

			res.responseHeaders().forEach(entry -> headers.add(entry.getKey(), entry.getValue()));

			String contentTypeValue = headers.getFirst(HttpHeaders.CONTENT_TYPE);
			if (StringUtils.hasLength(contentTypeValue)) {
				exchange.getAttributes().put(ORIGINAL_RESPONSE_CONTENT_TYPE_ATTR, contentTypeValue);
			}

			setResponseStatus(res, response);

			// make sure headers filters run after setting status so it is
			// available in response
			HttpHeaders filteredResponseHeaders = HttpHeadersFilter.filter(getHeadersFilters(), headers, exchange,
					Type.RESPONSE);

			if (!filteredResponseHeaders.containsKey(HttpHeaders.TRANSFER_ENCODING)
					&& filteredResponseHeaders.containsKey(HttpHeaders.CONTENT_LENGTH)) {
				// It is not valid to have both the transfer-encoding header and
				// the content-length header.
				// Remove the transfer-encoding header in the response if the
				// content-length header is present.
				response.getHeaders().remove(HttpHeaders.TRANSFER_ENCODING);
			}

			exchange.getAttributes().put(CLIENT_RESPONSE_HEADER_NAMES, filteredResponseHeaders.keySet());

			response.getHeaders().putAll(filteredResponseHeaders);

			return Mono.just(res);
		});

		Duration responseTimeout = getResponseTimeout(route);
		if (responseTimeout != null) {
			responseFlux = responseFlux
					.timeout(responseTimeout,
							Mono.error(new TimeoutException("Response took longer than timeout: " + responseTimeout)))
					.onErrorMap(TimeoutException.class,
							th -> new ResponseStatusException(HttpStatus.GATEWAY_TIMEOUT, th.getMessage(), th));
		}

		return responseFlux.then(chain.filter(exchange));
	}

	protected ByteBuf getByteBuf(DataBuffer dataBuffer) {
		if (dataBuffer instanceof NettyDataBuffer) {
			NettyDataBuffer buffer = (NettyDataBuffer) dataBuffer;
			return buffer.getNativeBuffer();
		}
		// MockServerHttpResponse creates these
		else if (dataBuffer instanceof DefaultDataBuffer) {
			DefaultDataBuffer buffer = (DefaultDataBuffer) dataBuffer;
			return Unpooled.wrappedBuffer(buffer.getNativeBuffer());
		}
		throw new IllegalArgumentException("Unable to handle DataBuffer of type " + dataBuffer.getClass());
	}

	private void setResponseStatus(HttpClientResponse clientResponse, ServerHttpResponse response) {
		HttpStatus status = HttpStatus.resolve(clientResponse.status().code());
		if (status != null) {
			response.setStatusCode(status);
		}
		else {
			while (response instanceof ServerHttpResponseDecorator) {
				response = ((ServerHttpResponseDecorator) response).getDelegate();
			}
			if (response instanceof AbstractServerHttpResponse) {
				((AbstractServerHttpResponse) response).setRawStatusCode(clientResponse.status().code());
			}
			else {
				// TODO: log warning here, not throw error?
				throw new IllegalStateException("Unable to set status code " + clientResponse.status().code()
						+ " on response of type " + response.getClass().getName());
			}
		}
	}

	/**
	 * Creates a new HttpClient with per route timeout configuration. Sub-classes that
	 * override, should call super.getHttpClient() if they want to honor the per route
	 * timeout configuration.
	 * @param route the current route.
	 * @param exchange the current ServerWebExchange.
	 * @return
	 */
	protected HttpClient getHttpClient(Route route, ServerWebExchange exchange) {
		Object connectTimeoutAttr = route.getMetadata().get(CONNECT_TIMEOUT_ATTR);
		if (connectTimeoutAttr != null) {
			Integer connectTimeout = getInteger(connectTimeoutAttr);
			return this.httpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, connectTimeout);
		}
		return httpClient;
	}

	static Integer getInteger(Object connectTimeoutAttr) {
		Integer connectTimeout;
		if (connectTimeoutAttr instanceof Integer) {
			connectTimeout = (Integer) connectTimeoutAttr;
		}
		else {
			connectTimeout = Integer.parseInt(connectTimeoutAttr.toString());
		}
		return connectTimeout;
	}

	private Duration getResponseTimeout(Route route) {
		Object responseTimeoutAttr = route.getMetadata().get(RESPONSE_TIMEOUT_ATTR);
		Long responseTimeout = null;
		if (responseTimeoutAttr != null) {
			if (responseTimeoutAttr instanceof Number) {
				responseTimeout = ((Number) responseTimeoutAttr).longValue();
			}
			else {
				responseTimeout = Long.valueOf(responseTimeoutAttr.toString());
			}
		}
		return responseTimeout != null ? Duration.ofMillis(responseTimeout) : properties.getResponseTimeout();
	}

}

负责将响应回写到原连接的 NettyWriteResponseFilter

NettyRoutingFilter 是最后处理请求的，那么 NettyWriteResponseFilter 就应该是最后处理响应的，其 Order 为 -1

在自己配置 GlobalFilter 和 GatewayFilter 一定要记得这两个优先级

如果想在请求被转发到目标服务器之前处理 Request 其设置的优先级一定要比 NettyRoutingFilter 高，即 Order 比 2147483647 小

如果想在响应被重写会发起方前处理下 Response 其设置的优先级一定要比 NettyWriteResponseFilter 低，即 Order 比 -1 大

public class NettyWriteResponseFilter implements GlobalFilter, Ordered {

	/**
	 * Order for write response filter.
	 */
	public static final int WRITE_RESPONSE_FILTER_ORDER = -1;

	private static final Log log = LogFactory.getLog(NettyWriteResponseFilter.class);

	private final List<MediaType> streamingMediaTypes;

	public NettyWriteResponseFilter(List<MediaType> streamingMediaTypes) {
		this.streamingMediaTypes = streamingMediaTypes;
	}

	@Override
	public int getOrder() {
		return WRITE_RESPONSE_FILTER_ORDER;
	}

	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		// NOTICE: nothing in "pre" filter stage as CLIENT_RESPONSE_CONN_ATTR is not added
		// until the NettyRoutingFilter is run
		// @formatter:off
		return chain.filter(exchange)
				.doOnError(throwable -> cleanup(exchange))
				.then(Mono.defer(() -> {
					Connection connection = exchange.getAttribute(CLIENT_RESPONSE_CONN_ATTR);

					if (connection == null) {
						return Mono.empty();
					}
					if (log.isTraceEnabled()) {
						log.trace("NettyWriteResponseFilter start inbound: "
								+ connection.channel().id().asShortText() + ", outbound: "
								+ exchange.getLogPrefix());
					}
					ServerHttpResponse response = exchange.getResponse();

					// TODO: needed?
					final Flux<DataBuffer> body = connection
							.inbound()
							.receive()
							.retain()
							.map(byteBuf -> wrap(byteBuf, response));

					MediaType contentType = null;
					try {
						contentType = response.getHeaders().getContentType();
					}
					catch (Exception e) {
						if (log.isTraceEnabled()) {
							log.trace("invalid media type", e);
						}
					}
					return (isStreamingMediaType(contentType)
							? response.writeAndFlushWith(body.map(Flux::just))
							: response.writeWith(body));
				})).doOnCancel(() -> cleanup(exchange));
		// @formatter:on
	}

	protected DataBuffer wrap(ByteBuf byteBuf, ServerHttpResponse response) {
		DataBufferFactory bufferFactory = response.bufferFactory();
		if (bufferFactory instanceof NettyDataBufferFactory) {
			NettyDataBufferFactory factory = (NettyDataBufferFactory) bufferFactory;
			return factory.wrap(byteBuf);
		}
		// MockServerHttpResponse creates these
		else if (bufferFactory instanceof DefaultDataBufferFactory) {
			DataBuffer buffer = ((DefaultDataBufferFactory) bufferFactory).allocateBuffer(byteBuf.readableBytes());
			buffer.write(byteBuf.nioBuffer());
			byteBuf.release();
			return buffer;
		}
		throw new IllegalArgumentException("Unkown DataBufferFactory type " + bufferFactory.getClass());
	}

	private void cleanup(ServerWebExchange exchange) {
		Connection connection = exchange.getAttribute(CLIENT_RESPONSE_CONN_ATTR);
		if (connection != null && connection.channel().isActive() && !connection.isPersistent()) {
			connection.dispose();
		}
	}

	// TODO: use framework if possible
	// TODO: port to WebClientWriteResponseFilter
	private boolean isStreamingMediaType(@Nullable MediaType contentType) {
		return (contentType != null && this.streamingMediaTypes.stream().anyMatch(contentType::isCompatibleWith));
	}

}

如何实现负载均衡的

实现负载均衡的过滤器为 ReactiveLoadBalancerClientFilter 该过滤器的主要功能为

  1. 处理转发地址为 lb 开头的配置，在 Spring Cloud Gateway 的 routes 配置中 lb 是需要进行负载均衡的
  2. 根据 lb 信息找到对应的 serviceId，例如 lb://user-server 则 serviceId 为 user-server
  3. 根据 serviceId 从 LoadBalancer 中找到对应的可用实例，lb 实现主要依赖 consul、eureka、zk 等
  4. 如果无可用的实例，则判断是否使用 404 提示，如果用则用 404 状态码，如果否则用 502
  5. 从获取到的可用的服务实例 serviceInstance 获取目标服务器的 host 信息
  6. 将获取到的 host 信息设置到 Attributes 中, 方便在 NettyRoutingFilter进行请求转发时获取到这个地址，并转发到对应服务器 exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl)
public class ReactiveLoadBalancerClientFilter implements GlobalFilter, Ordered {

	private static final Log log = LogFactory.getLog(ReactiveLoadBalancerClientFilter.class);

	/**
	 * Order of filter.
	 */
	public static final int LOAD_BALANCER_CLIENT_FILTER_ORDER = 10150;

	private final LoadBalancerClientFactory clientFactory;

	private final GatewayLoadBalancerProperties properties;

	private final LoadBalancerProperties loadBalancerProperties;

	public ReactiveLoadBalancerClientFilter(LoadBalancerClientFactory clientFactory,
			GatewayLoadBalancerProperties properties, LoadBalancerProperties loadBalancerProperties) {
		this.clientFactory = clientFactory;
		this.properties = properties;
		this.loadBalancerProperties = loadBalancerProperties;
	}

	@Override
	public int getOrder() {
		return LOAD_BALANCER_CLIENT_FILTER_ORDER;
	}

	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		URI url = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
		String schemePrefix = exchange.getAttribute(GATEWAY_SCHEME_PREFIX_ATTR);
		if (url == null || (!"lb".equals(url.getScheme()) && !"lb".equals(schemePrefix))) {
			return chain.filter(exchange);
		}
		// preserve the original url
		addOriginalRequestUrl(exchange, url);

		if (log.isTraceEnabled()) {
			log.trace(ReactiveLoadBalancerClientFilter.class.getSimpleName() + " url before: " + url);
		}

		URI requestUri = exchange.getAttribute(GATEWAY_REQUEST_URL_ATTR);
		String serviceId = requestUri.getHost();
		Set<LoadBalancerLifecycle> supportedLifecycleProcessors = LoadBalancerLifecycleValidator
				.getSupportedLifecycleProcessors(clientFactory.getInstances(serviceId, LoadBalancerLifecycle.class),
						RequestDataContext.class, ResponseData.class, ServiceInstance.class);
		DefaultRequest<RequestDataContext> lbRequest = new DefaultRequest<>(new RequestDataContext(
				new RequestData(exchange.getRequest()), getHint(serviceId, loadBalancerProperties.getHint())));
		return choose(lbRequest, serviceId, supportedLifecycleProcessors).doOnNext(response -> {

			if (!response.hasServer()) {
				supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
						.onComplete(new CompletionContext<>(CompletionContext.Status.DISCARD, lbRequest, response)));
				throw NotFoundException.create(properties.isUse404(), "Unable to find instance for " + url.getHost());
			}

			ServiceInstance retrievedInstance = response.getServer();

			URI uri = exchange.getRequest().getURI();

			// if the `lb:<scheme>` mechanism was used, use `<scheme>` as the default,
			// if the loadbalancer doesn't provide one.
			String overrideScheme = retrievedInstance.isSecure() ? "https" : "http";
			if (schemePrefix != null) {
				overrideScheme = url.getScheme();
			}

			DelegatingServiceInstance serviceInstance = new DelegatingServiceInstance(retrievedInstance,
					overrideScheme);

			URI requestUrl = reconstructURI(serviceInstance, uri);

			if (log.isTraceEnabled()) {
				log.trace("LoadBalancerClientFilter url chosen: " + requestUrl);
			}
			exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, requestUrl);
			exchange.getAttributes().put(GATEWAY_LOADBALANCER_RESPONSE_ATTR, response);
			supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStartRequest(lbRequest, response));
		}).then(chain.filter(exchange))
				.doOnError(throwable -> supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
						.onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
								CompletionContext.Status.FAILED, throwable, lbRequest,
								exchange.getAttribute(GATEWAY_LOADBALANCER_RESPONSE_ATTR)))))
				.doOnSuccess(aVoid -> supportedLifecycleProcessors.forEach(lifecycle -> lifecycle
						.onComplete(new CompletionContext<ResponseData, ServiceInstance, RequestDataContext>(
								CompletionContext.Status.SUCCESS, lbRequest,
								exchange.getAttribute(GATEWAY_LOADBALANCER_RESPONSE_ATTR),
								new ResponseData(exchange.getResponse(), new RequestData(exchange.getRequest()))))));
	}

	protected URI reconstructURI(ServiceInstance serviceInstance, URI original) {
		return LoadBalancerUriTools.reconstructURI(serviceInstance, original);
	}

	private Mono<Response<ServiceInstance>> choose(Request<RequestDataContext> lbRequest, String serviceId,
			Set<LoadBalancerLifecycle> supportedLifecycleProcessors) {
		ReactorLoadBalancer<ServiceInstance> loadBalancer = this.clientFactory.getInstance(serviceId,
				ReactorServiceInstanceLoadBalancer.class);
		if (loadBalancer == null) {
			throw new NotFoundException("No loadbalancer available for " + serviceId);
		}
		supportedLifecycleProcessors.forEach(lifecycle -> lifecycle.onStart(lbRequest));
		return loadBalancer.choose(lbRequest);
	}

	private String getHint(String serviceId, Map<String, String> hints) {
		String defaultHint = hints.getOrDefault("default", "default");
		String hintPropertyValue = hints.get(serviceId);
		return hintPropertyValue != null ? hintPropertyValue : defaultHint;
	}

}

总结

这样 Spring Cloud Gateway 通过这两个过滤器就可完成将请求转发到目标服务器和将目标服务器的响应重写到发起方，为了方便开发者扩展其功能，我们可以自己实现一些过滤器来实现在请求被转发到目标服务器前对请求就行一些自定义处理，比如：修改请求头、修改请求参数、重写请求路径、重写目标服务；在响应被重写回发起方之前对响应就行处理，比如：增加跨域请求头、对响应内容进行加密等；当然我们也可以即处理请求又处理响应，比如：统计请求时间等等功能

再次提醒

在自己配置 GlobalFilter 和 GatewayFilter 一定要记得这两个优先级
如果想在请求被转发到目标服务器之前处理 Request 其设置的优先级一定要比 NettyRoutingFilter 高，即 Order 比 2147483647 小
如果想在响应被重写会发起方前处理下 Response 其设置的优先级一定要比 NettyWriteResponseFilter 低，即 Order 比 -1 大

参考

GitHub: https://github.com/spring-cloud/spring-cloud-gateway
Gitee: https://gitee.com/github_mirror_plus/spring-cloud-gateway

扩展阅读

除了上面的三个过滤器，在 org.springframework.cloud.gateway.filter 包下还有很多有意思的过滤器

GatewayMetricsFilter 统计请求时间

public class GatewayMetricsFilter implements GlobalFilter, Ordered {

	private static final Log log = LogFactory.getLog(GatewayMetricsFilter.class);

	private final MeterRegistry meterRegistry;

	private GatewayTagsProvider compositeTagsProvider;

	private final String metricsPrefix;

	public GatewayMetricsFilter(MeterRegistry meterRegistry, List<GatewayTagsProvider> tagsProviders,
			String metricsPrefix) {
		this.meterRegistry = meterRegistry;
		this.compositeTagsProvider = tagsProviders.stream().reduce(exchange -> Tags.empty(), GatewayTagsProvider::and);
		if (metricsPrefix.endsWith(".")) {
			this.metricsPrefix = metricsPrefix.substring(0, metricsPrefix.length() - 1);
		}
		else {
			this.metricsPrefix = metricsPrefix;
		}
	}

	public String getMetricsPrefix() {
		return metricsPrefix;
	}

	@Override
	public int getOrder() {
		// start the timer as soon as possible and report the metric event before we write
		// response to client
		return NettyWriteResponseFilter.WRITE_RESPONSE_FILTER_ORDER + 1;
	}

	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		Sample sample = Timer.start(meterRegistry);

		return chain.filter(exchange).doOnSuccess(aVoid -> endTimerRespectingCommit(exchange, sample))
				.doOnError(throwable -> endTimerRespectingCommit(exchange, sample));
	}

	private void endTimerRespectingCommit(ServerWebExchange exchange, Sample sample) {

		ServerHttpResponse response = exchange.getResponse();
		if (response.isCommitted()) {
			endTimerInner(exchange, sample);
		}
		else {
			response.beforeCommit(() -> {
				endTimerInner(exchange, sample);
				return Mono.empty();
			});
		}
	}

	private void endTimerInner(ServerWebExchange exchange, Sample sample) {
		Tags tags = compositeTagsProvider.apply(exchange);

		if (log.isTraceEnabled()) {
			log.trace(metricsPrefix + ".requests tags: " + tags);
		}
		sample.stop(meterRegistry.timer(metricsPrefix + ".requests", tags));
	}

}

鸣谢

感谢同事送的键盘，终于在半夜敲代码的时候，听不到哒哒哒声了

红色图片

双鬼带单
关注
专栏目录
Spring Cloud Gateway自带Predicate使用 | Spring Cloud 14
gmHappy
03-08 3049
`Spring Cloud Gateway` 匹配路由作为 `Spring WebFluxHandlerMapping`基础设施的一部分。`Spring Cloud Gateway` 包含许多内置的`Predicate` 。所有这些`Predicate`都匹配 `HTTP` 请求的不同属性。您可以将多个`Predicate` 与`and`结合起来。
Spring Cloud Gateway自带RequestRateLimiter限流应用及扩展 | Spring Cloud 16
gmHappy
03-09 7959
限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。 在开发高并发系统时有三把利器用来保护系统： - 缓存：缓存的目的是提升系统访问速度和增大系统处理容量 - 降级：降级是当服务器压力剧增的情况下，根据当前业务情况及流量对一些服务和页面有策略的降级，以此释放服务器资源以保证核心任务的正常运行 - 限流：限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理。
spring cloud gateway实现流程介绍
sh210106sh的博客
04-23 398
文章目录前言一、Spring Cloud Gateway 功能特征二、Spring Cloud Gateway流程分析1.引入库2.读入数据总结 前言 在SpringCloud微服务体系中，有个很重要的组件就是网关，在1.x版本中都是采用的Zuul网关；但在2.x版本中，zuul的升级一直跳票，SpringCloud最后自己研发了一个网关替代Zuul，那就是SpringCloud Gateway。 还有一点就是Gateway是基于WebFlux的。这里引出了WebFlux名词，那什么是WebFlux？ W
SpringCloud Gateway 简介、工作流程、快速入门
豆恭梓的博客
07-11 820
网关是微服务最边缘的服务，直接暴露给用户，用来做用户和微服务的桥梁没有网关：客户端直接访问我们的微服务，会需要在客户端配置很多的 ip：port，如果user-service 并发比较大，则无法完成负载均衡有网关：客户端访问网关，网关来访问微服务，（网关可以和注册中心整合，通过服务名称找到目标的 ip：prot）这样只需要使用服务名称即可访问微服务，可以实现负载均衡，可以实现token 拦截，权限验证，限流等操作你们项目里面 用的什么网关？
Spring cloud gateway工作流程原理解析
08-19
主要介绍了Spring cloud gateway工作流程原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringCloud-Gateway介绍和工作流程(Day8)
web18484626332的博客
03-23 819
GateWay简介 Gateway是在Spring生态系统之上构建的API网关服务，基于Spring 5,Spring Boot 2和Project Reactor等技术。 Spring Cloud Gateway的目标提供统一的路由方式且基于 Filter链的方式提供了网关基本的功能，例如:安全，监控/指标，和限流。 SpringCloud Gateway是Spring Cloud的一个全新项目，基于Spring 5.0+Spring Boot 2.0和Project Reactor等技术开发的网关，它
最新Spring Cloud Gateway 官方参考指南-中文版-3.x
08-16
Spring Cloud Gateway的工作流程如下： 1. 客户端向Gateway发起请求。 2. 网关处理器（Gateway Handler Mapping）检查请求是否与定义的路由匹配。 3. 匹配的请求被发送到Gateway Web处理器，通过过滤器链进行处理。...
Spring Cloud Gateway构建的API网关服务 | Spring Cloud 12
gmHappy
03-07 1946
所谓的网关就是指系统的统一入口，它封装了运用程序的内部结构，为客户端提供统一的服务，一些与业务功能无关的公共逻辑可以在这里实现，诸如认证、鉴权、监控、路由转发等。
Spring Cloud Gateway 执行流程解读
For-的博客
03-17 3522
gateway 是在 Spring WebFlux 的基础上构建的，目标是提供一个简单高效的方式去统一管理 API 路由。 Spring Cloud Gateway 的目标，不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全，监控/指标和限流。 一、整体流程 请求处理流程 UML 图 从 UML 图可以看得出来 gateway 使用了与 Spring Mvc 类似的处理逻辑，即适配器模式；先从 Mapping 中匹配到适配器，然后使用适配器调用 handler。
【Spring Cloud】Gateway 服务网关核心架构的执行流程和断言
最新发布
阿Q的小窝
06-07 8544
路由(Route)是gateway中最基本的组件之一，表示一个具体的路由信息载体。Predicate(断言，谓词)用于进行条件判断，只有断言都返回真，才会真正的执行路由。断言就是说: 在什么条件下才能进行路由转发。
springCloud→Gateway：Gateway工作原理
Hello World
10-22 1479
Gateway工作流程 官网总结 核心逻辑：路由转发+执行过滤器链
gateWay网关组件及工作原理
Li18810710298的博客
01-08 1776
无法完全替代传统 API 网关：Spring Cloud gateWay 虽然提供了基于路由的请求处理能力，但无法完全替代传统的 API 网关，如 Nginx 和 Kong 等，因为一些传统 API 网关的功能，如高级的负载均衡、缓存和安全性等，还未完全支持。基于路由的请求处理：Spring Cloud gateWay 的核心功能是基于路由的请求处理，能够将不同的请求路由到不同的后端服务上，并提供丰富的路由配置选项。发现有些项目中用到的是zuul框架，作为统一网关，下面就简单说一下它们的不同之处。
SpringCloud之Gateway(服务网关)
my_air的博客
07-13 3890
Gateway Gateway 是Spring 生态系统之上构建的API网关服务，基于Spring 5,Spring Boot 2 和 Project Reactor等技术。Gateway 在提供一种简单而有效的方式来对API进行路由，以及提供一些强大的过滤器功能，例如：熔断，限流，重试等。 SpringCloud Gateway 作为Spring Cloud 生态系统中的网关，目标是代替Zuul,在Spriing Cloud 2.0以上版本，没有对新版本的Zuul 2.0 以上最新高性能版本进行集成，仍然
spring-cloud-gateway 导读（1）
foralllove的博客
01-10 145
Spring Cloud Gateway的工作方式：
Spring Cloud Gateway初体验
马明的博客
07-14 244
SpringCloud视频教程： https://ke.qq.com/course/2805647?tuin=a3e3fb1&from_uin=171851697&from=1000201007 个人博客纯净版 http://www.51ufo.cn/%E5%BE%AE%E6%9C%8D%E5%8A%A1/%E5%88%86%E5%B8%83%E5%BC%8F/2020/07/11/SpringCloud%E5%85%A5%E9%97%A815-Spring-Cloud-Gateway
[06] 入门Spring Cloud_Gateway 新一代网关
weixin_42547014的博客
09-26 237
一、新一代网关 Gateway 1. 网关 网关是所有请求的入口，是所有响应的出口，起到请求转发和安全监控等作用，是 Cloud 全家桶中很重要的组件 2. Gateway SpringCloud Gateway是SpringCloud的一个全新项目，基于Spring5.0+、SpringBoot2.0和Project Reactor等技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的API路由管理方式，且基于Filter链提供了网关基本的功能（例如：安全、监控/指标、和限流。）以及提供一些强大的
【Spring Cloud实战】Spring Cloud GateWay服务网关
11-23 348
GateWayCloud全家桶中有个很重要的组件就是网关，在1.x版本中都是采用的Zuul网关；但在2.x版本中，zuul的升级一直跳票，SpringCloud最后自己研发了一个网关替代Zuul，那就是SpringCloud Gateway一句话：gateway是原zuul1.x版的替代提供了一个在Spring生态系统之上构建的API网关，包括：Spring 5，Spring Boot 2和Project Reactor。
Spring Cloud Gateway路由详解：配置与工作流程
Spring Cloud Gateway的工作流程如下： - 客户端发起请求，网关处理程序根据预先定义的路由规则进行匹配。 - 如果匹配成功，请求会被路由到相应的网关Web处理器，处理器会根据请求创建一个筛选器链。 - 过滤器按照...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值