SpringCloudGateway 入门

POM 依赖

我的Java版本是17
父模块

<properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    <alibaba-cloud.version>2022.0.0.0alibaba-cloud.version>
    <spring-cloud.version>2022.0.4spring-cloud.version>
    <spring-boot.version>3.0.9spring-boot.version>
    <circuit-breaker.version>3.0.3circuit-breaker.version>
properties>

<dependencyManagement>
    <dependencies>
        <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-alibaba-dependenciesartifactId>
        <version>${alibaba-cloud.version}version>
        <type>pomtype>
        <scope>importscope>
        dependency>

        <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-dependenciesartifactId>
        <version>${spring-boot.version}version>
        <type>pomtype>
        <scope>importscope>
        dependency>

        <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-dependenciesartifactId>
        <version>${spring-cloud.version}version>
        <type>pomtype>
        <scope>importscope>
        dependency>
    dependencies>
dependencyManagement>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

子模块

 <dependencies>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-gatewayartifactId>
    dependency>

    
    <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-configartifactId>
    dependency>

    
    <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    dependency>
dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

一、内容

网关的作用

假设：如果没有网关，客户端如何调用微服务，数十个微服务。
如果真有数十个微服务，那客户端要记录数十个微服务的地址，然后分别去使用，这样会存在很多问题，比如：
1. 重复造轮子
  每个微服务单独为战，各自实现自己的鉴权、限流、跨域等，把轮子重造。
2. 调用低效
  如果业务量比较简单的话，暂时还不会有什么问题，随着业务越来越复杂，一个复杂的页面可能会涉及到数百个微服务协同工作，如果每个微服务都分配一个域名的话，一方面客户端代码会很难维护，涉及到数百个域名，另一方面是连接数的瓶颈，想象一下你打开一个APP，通过抓包发现涉及到了数百个远程调用，这在移动端下会显得非常低效。
3. 重构复杂
  后期如果需要对微服务进行重构的话，也会变的非常麻烦，需要客户端配合你一起进行改造，比如商品服务，随着业务变的越来越复杂，后期需要进行拆分成多个微服务，这个时候对外提供的服务也需要拆分成多个，同时需要客户端配合你进行改造，非常蛋疼。

上面的问题，如果引入了网关，由网关统一管理，客户端只需要和网关对接，网关就负责授权、限流、路由转发等。

Spring-Cloud-Gateway的核心概念

Route：网关的基本构建块，它由一个ID、一个目标URI、一组断言和一组过滤器定义。如果聚合断言为真，则匹配路由。
Predicate：支持对请求头、请求方法、请求参数、Host、时间（设置过期时间/生效时间）等等进行匹配，匹配成功之后会执行Filter。
Filter：有修改url，修改body，添加请求头/请求参数，限流，断路器，权限认证等功能。

二、基于Ribbon的负载均衡

在网关模块添加这个依赖就行了，注意我这个是子模块，我的父模块管理了SpringCloud的依赖，所以不需要添加版本


<dependency>
    <groupId>org.springframework.cloudgroupId>
    <artifactId>spring-cloud-starter-loadbalancerartifactId>
dependency>
1
2
3
4
5

然后写路由就可以使用lb://servername了。

@Bean
public RouteLocator usrRout(RouteLocatorBuilder builder) {
    ZonedDateTime zonedDateTime = LocalDateTime.now()
            .plusSeconds(20)
            .atZone(ZoneId.systemDefault());

    return builder.routes()
            .route("user", r -> r.path("/xxxx").uri("lb://oraone"))
            .build();
}
1
2
3
4
5
6
7
8
9
10

三、核心概念详细

3.1 断言 Predicate

关于时间的
before：在指定时间之后路由永远失效。
after：在指定时间之后路由才生效。
between：在指定时间之间生效，其余时间失效。

@Configure
public class Config {
	public RouteLocator config(RouteLocatorBuilder build) {
		ZoneDateTime before = ZoneDateTime.now()
			.plusSeconds(36)
			.atZone(ZoneId.systemDefault());
		ZoneDateTime after = ZoneDateTime.now()
			.plusSeconds(900)
			.atZone(ZoneId.systemDefault());
		return build.routes()
		// 在before之后永久路由失效
		.route("before", r -> r.before(before).uri("lb://servername"))
		// 在after之后路由生效。
		.route("after", r -> r.after(after).uri("lb://servername"))
		// 在[before, after]之内路由生效。
		.between("between", r -> r.between(before, after).uri("lb://servername"))
		.build();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

关于HTTP的
Header：限制请求头和请求头的值
Host：限制主机
Method：限制请求方法
Query：限制请求参数

@Configure
public class RouteConfig {
	@Bean
	public RouteLocator route(RouteLocatorBuilder build) {
		return build.routes()
			// 请求必须有name，和token这两个请求头，token必须是32位指定字符。
			// 请求方法必须是get，只能本地请求。
			// 参数必须携带id
			.route("route", r -> e.header("name")
				and().header("token", "[a-zA-Z0-9]{32, 32}")
				and().method(HttpMethod.GET)
				and().Host("localhost")
				and().query("id")
				.uri("lb://servername"))
			.build();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

关于路径的
Path：限制访问的路径及协议域名端口之后的url

@Configure
public class RouteConfig {
	@Bean
	public RouteLocator route(RouteLocatorBuilder build) {
		return build.routes()
			.route("path", r -> r.path("/gateway/user/**").uri("lb://servername"))
			.build();
	}
}
1
2
3
4
5
6
7
8
9

IP地址和网段
RemoteAdd：两个参数，第一个是IP地址，第二个是网段。
权重
Weight：设置接口的权重，权重越高，那么转发到该接口的请求数就越多。有两个参数，第一个个是GroupName，第二个是一个Weight数值。

@Configure
public class RouteConfig {
	@Bean
	public RouteLocator route(RouteLocatorBuilder build) {
		String path = "/gateway/user/**";
		String groupName = "user";
		return build.routes()
			.route("weight1", r -> r.path(path)
				and().weight(groupName, 80).uri("lb://servername1"))
			.route("weight2", r -> r.path(path)
				.and().weight(groupName, 20).uri("lb://servername2")))
			.build();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.2 过滤器

3.2.1 内置过滤器

内置的过滤器大体分为请求头、响应头、跳转、参数处理、响应状态、熔断、限速器。

关于HTTP的过滤器
AddRequestHeader：
AddRequestParams：
AddResponseHeader：
关于路径的过滤器
RewritePath：支持正则匹配替换
StripPrefix：可以把前缀路径干掉

@Configure
public class RouteConfig {
	@Bean
	public RouteLocator route(RouteLocatorBuilder build) {
		return build.routes()
			.route("route", r -> r.path("/gateway/usr/local/**")
				.filters(f -> f.rewritePath("/gateway/usr/($.*)", "/user/$\\{segment}"))
				.uri("lb://servername"))
			// 最后访问路径是 lb://servername/order/**
			.route("route1", r -> r.path("/gateway/order/**")
				.filters(f -> f.stripPrefix(1)).uri("lb://servername"))
			.build();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.2.2 自定义过滤器

构造器（原理）

资源结构

gateway最终需要的资源是RouteLocator，RouteLocator里面包含了路由、断言、过滤器三个种资源，它们的依赖关系如下：

请添加图片描述

Route / Predicate 的构造器

Buildalbe就一个方法build，AbstractBuilder负责构建Route，源码如下：
五个属性，都是路由的基本组成，还看到了GatewayFilter 局部过滤器。

public abstract static class AbstractBuilder<B extends AbstractBuilder<B>> implements Buildable<Route> {
	protected String id;
	protected URI uri;
	protected int order = 0;
	protected List<GatewayFilter> gatewayFilters = new ArrayList<>();
	protected Map<String, Object> metadata = new HashMap<>();
    省略....
}
1
2
3
4
5
6
7
8

最后是Buidler和AsyncBuidler，它两负责构建断言，只是构建的类型不同，至于作用是什么目前还不清楚，它们两分别构建Predicate和AsyncPredicate。
请添加图片描述

构造器的增强器

SpringCloudGateway提供了很多GatewayFilter过滤器，UriSpec就是这些过滤器的配置，UriSpec里面包含了Route.Builder / RouteLocatorBuilder.Builder，配置的断言和过滤器最终都会流入Route.Builder。
请添加图片描述增强器和构造器的协作关系，Route.AsyncBuilder和RouteLocatorBuidler.Builder都组合在UriSpec中。

整体协同关系 / 部分源代码分析