SpringCloudGateway 入门

POM 依赖

我的Java版本是17
父模块

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

<dependencyManagement>
    <dependencies>
        <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-alibaba-dependencies</artifactId>
        <version>${alibaba-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
        </dependency>

        <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>${spring-boot.version}</version>
        <type>pom</type>
        <scope>import</scope>
        </dependency>

        <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>${spring-cloud.version}</version>
        <type>pom</type>
        <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

子模块

 <dependencies>
    <!-- 网关 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!-- 注册中心配置 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>

    <!-- 注册中心客户端 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
</dependencies>

一、内容

网关的作用

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

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

Spring-Cloud-Gateway的核心概念

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

二、基于Ribbon的负载均衡

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

<!-- 负载均衡器，用作服务发现，支持路由的 lb://servername -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

然后写路由就可以使用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();
}

三、核心概念详细

3.1 断言 Predicate

1. 关于时间的
   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();
	}
}

2. 关于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();
	}
}

3. 关于路径的
   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();
	}
}

4. IP地址和网段
   RemoteAdd：两个参数，第一个是IP地址，第二个是网段。

5. 权重
   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();
	}
}

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/($<segment>.*)", "/user/$\\{segment}"))
				.uri("lb://servername"))
			// 最后访问路径是 lb://servername/order/**
			.route("route1", r -> r.path("/gateway/order/**")
				.filters(f -> f.stripPrefix(1)).uri("lb://servername"))
			.build();
	}
}

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<>();
    省略....
}

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

构造器的增强器

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

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

public static class Builder {

	private List<Buildable<Route>> routes = new ArrayList<>();
	private ConfigurableApplicationContext context;
	public Builder(ConfigurableApplicationContext context) {
		this.context = context;
	}
   
   // 创建一个Buildable，放到routes中，ID是自命名。
   // apply会生成一个PredicateSpec，提供给用户选择过滤器，最后通过UriSpec的uri方法，返回一个Buildable对象。
	public Builder route(String id, Function<PredicateSpec, Buildable<Route>> fn) {
		Buildable<Route> routeBuilder = fn.apply(new RouteSpec(this).id(id));
		add(routeBuilder);
		return this;
	}
    
   // 创建一个Buildable，放到routes中，ID随机生成。
   // apply会生成一个PredicateSpec，提供给用户选择过滤器，最后通过UriSpec的uri方法，返回一个Buildable对象。
	public Builder route(Function<PredicateSpec, Buildable<Route>> fn) {
		Buildable<Route> routeBuilder = fn.apply(new RouteSpec(this).randomId());
		add(routeBuilder);
		return this;
	}
   
   // 执行所有的Buildable，构造RouteLocator。
	public RouteLocator build() {
		return () -> Flux.fromIterable(this.routes).map(routeBuilder -> routeBuilder.build());
	}

	ConfigurableApplicationContext getContext() {
		return context;
	}

	void add(Buildable<Route> route) {
		routes.add(route);
	}
}

public class UriSpec {

	final Route.AsyncBuilder routeBuilder;

	final RouteLocatorBuilder.Builder builder;

	UriSpec(Route.AsyncBuilder routeBuilder, RouteLocatorBuilder.Builder builder) {
		this.routeBuilder = routeBuilder;
		this.builder = builder;
	}

	public UriSpec customize(Consumer<Route.AsyncBuilder> routeConsumer) {
		routeConsumer.accept(this.routeBuilder);
		return this;
	}

	public UriSpec replaceMetadata(Map<String, Object> metadata) {
		this.routeBuilder.replaceMetadata(metadata);
		return this;
	}

	public UriSpec metadata(Map<String, Object> metadata) {
		this.routeBuilder.metadata(metadata);
		return this;
	}

	public UriSpec metadata(String key, Object value) {
		this.routeBuilder.metadata(key, value);
		return this;
	}

	// 设置uri，这里会抛出一个Buildalbe，对应构造器的写法：build.routes().route(r -> r.uri()).build();
	public Buildable<Route> uri(String uri) {
		return this.routeBuilder.uri(uri);
	}

	/**
	 * Set the URI for the route.
	 * @param uri the URI for the route.
	 * @return a {@link Route.AsyncBuilder}S
	 */
	public Buildable<Route> uri(URI uri) {
		return this.routeBuilder.uri(uri);
	}

	<T> T getBean(Class<T> type) {
		return this.builder.getContext().getBean(type);
	}
}

扩展自己的过滤器（实战）

GatewayFilterSpec有filter方法，可以直接添加自己的过滤器。

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

    return builder.routes()
            .route("user", r -> r.before(zonedDateTime).uri("lb://oraone"))
            .route("user1", predicate -> predicate
                    .path("/strip/prefix/**")
                    .filters(filter -> filter.stripPrefix(2)
                            // 自定义GatewayFilter
                            .filter(new MyGatewayFilter()))
                    .uri("lb://oraone"))
            .build();
    }
    
    class MyGatewayFilter implements GatewayFilter {
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            // 什么都不做。
            return chain.filter(exchange);
        }
    }
}

还可以继承GatewayFilterFactory，实现它的apply方法。或者继承AbstractGatewayFilterFactory，实现apply方法。