SpringCloudGateway 入门

本文主要是介绍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 {@Beanpublic 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 {@Beanpublic 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 {@Beanpublic 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 {@Beanpublic 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{@Beanpublic 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 {@Overridepublic Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {// 什么都不做。return chain.filter(exchange);}}
}

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

这篇关于SpringCloudGateway 入门的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---