org.springframework.cloud.gateway.discovery.GatewayDiscoveryClientAutoConfiguration
org.springframework.cloud.gateway.config.GatewayAutoConfiguration$NettyConfiguration
gatewayHttpClient
org.springframework.cloud.gateway.config.GatewayAutoConfiguration
gatewayConfigurationService
routePredicateHandlerMapping
gatewayProperties

# 多个
**RoutePredicateFactory

# 多个
**GatewayFilterFactory

org.springframework.cloud.gateway.config.GatewayNoLoadBalancerClientAutoConfiguration
spring.cloud.gateway.loadbalancer-org.springframework.cloud.gateway.config.GatewayLoadBalancerProperties
...

{
    "timestamp": "2021-09-11T03:06:33.044+00:00",
    "path": "/",
    "status": 404,
    "error": "Not Found",
    "message": null,
    "requestId": "18974297-1"
}

# pom.xml文件
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

# application.properties文件
management.endpoints.web.exposure.include=health, info, mappings

# 居然访问不到！
# http://localhost:25001/actuator/gateway
{
    "timestamp": "2021-09-11T03:41:43.253+00:00",
    "path": "/actuator/gateway",
    "status": 404,
    "error": "Not Found",
    "message": null,
    "requestId": "aba1dfd7-4"
}

# 子端点 routes，，返回结果为 []，因为什么路由也没有配置
# http://localhost:25001/actuator/gateway/routes
[]

# 子端点 globalfilters
http://localhost:25001/actuator/gateway/globalfilters
{
    "org.springframework.cloud.gateway.filter.AdaptCachedBodyGlobalFilter@6b00ad9": -2147482648,
    "org.springframework.cloud.gateway.filter.NettyWriteResponseFilter@3ce53f6a": -1,
    "org.springframework.cloud.gateway.filter.WebsocketRoutingFilter@59d77850": 2147483646,
    "org.springframework.cloud.gateway.config.GatewayNoLoadBalancerClientAutoConfiguration$NoLoadBalancerClientFilter@60859f5a": 10150,
    "org.springframework.cloud.gateway.filter.ForwardPathFilter@1a6cf771": 0,
    "org.springframework.cloud.gateway.filter.RouteToRequestUrlFilter@3ee69ad8": 10000,
    "org.springframework.cloud.gateway.filter.RemoveCachedBodyFilter@2d82408": -2147483648,
    "org.springframework.cloud.gateway.filter.GatewayMetricsFilter@53ed09e8": 0,
    "org.springframework.cloud.gateway.filter.NettyRoutingFilter@19650aa6": 2147483647,
    "org.springframework.cloud.gateway.filter.ForwardRoutingFilter@f679798": 2147483647
}

{
    "timestamp": "2021-09-11T07:27:45.411+00:00",
    "path": "/user/get",
    "status": 404,
    "error": "Not Found",
    "message": null,
    "requestId": "6e46a6fa-8, L:/0:0:0:0:0:0:0:1:25001 - R:/0:0:0:0:0:0:0:1:61499"
}

{
    "timestamp": "2021-09-11 07:30:51",
    "status": 404,
    "error": "Not Found",
    "path": "/user2/get"
}

响应结果：
{
    "timestamp": "2021-09-11T07:37:17.437+00:00",
    "path": "/user/get",
    "status": 500,
    "error": "Internal Server Error",
    "requestId": "0d01c5bb-1, L:/0:0:0:0:0:0:0:1:25001 - R:/0:0:0:0:0:0:0:1:56362"
}

异常日志：
2021-09-11 15:37:17.449 ERROR 26812 --- [ctor-http-nio-5] a.w.r.e.AbstractErrorWebExceptionHandler : [0d01c5bb-1, L:/0:0:0:0:0:0:0:1:25001 - R:/0:0:0:0:0:0:0:1:56362]  500 Server Error for HTTP GET "/user/get?id=1"
io.netty.channel.AbstractChannel$AnnotatedConnectException: Connection refused: no further information: localhost/127.0.0.1:9999
	Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException: 
Caused by: java.net.ConnectException: Connection refused: no further information

    #
    # 路由配置
    gateway:
      routes:
      # 访问 adapter.web
      - id: route1
        # 1）服务
        uri: http://localhost:21001
#        order: 2
        # 2）端口后添加部分路径：无用，和上面效果相同
#        uri: http://localhost:21001/user
        predicates:
        # 严格按照下面的格式来，小于10的话，前加0
        - After=2021-09-11T14:13:13.000+08:00[Asia/Shanghai]

      # 不存在的主机
      - id: routeErr
        uri: http://localhost:9999
#        order: 1
        predicates:
        # 严格按照下面的格式来，小于10的话，前加0
        - After=2021-09-11T14:13:13.000+08:00[Asia/Shanghai]

[
    {
        "predicate": "After: 2021-09-11T14:13:13+08:00[Asia/Shanghai]",
        "route_id": "route1",
        "filters": [],
        "uri": "http://localhost:21001",
        "order": 0
    },
    {
        "predicate": "After: 2021-09-11T14:13:13+08:00[Asia/Shanghai]",
        "route_id": "routeErr",
        "filters": [],
        "uri": "http://localhost:9999",
        "order": 0
    }
]

[
    {
        "predicate": "After: 2021-09-11T14:13:13+08:00[Asia/Shanghai]",
        "route_id": "routeErr",
        "filters": [],
        "uri": "http://localhost:9999",
        "order": 1
    },
    {
        "predicate": "After: 2021-09-11T14:13:13+08:00[Asia/Shanghai]",
        "route_id": "route1",
        "filters": [],
        "uri": "http://localhost:21001",
        "order": 2
    }
]

[
    {
        "predicate": "Between: 2021-09-11T16:13:13+08:00[Asia/Shanghai] and 2021-09-11T17:13:13+08:00[Asia/Shanghai]",
        "route_id": "route1",
        "filters": [],
        "uri": "http://localhost:21001",
        "order": 0
    }
]

[
    {
        "predicate": "After: 2221-09-11T14:13:13+08:00[Asia/Shanghai]",
        "route_id": "route1",
        "filters": [],
        "uri": "http://localhost:21001",
        "order": 0
    },
    {
        "predicate": "After: 2021-09-11T14:13:13+08:00[Asia/Shanghai]",
        "route_id": "route2",
        "filters": [],
        "uri": "http://localhost:21001",
        "order": 0
    }
]

{
    "timestamp": "2021-09-11T08:43:01.274+00:00",
    "path": "/user/get",
    "status": 404,
    "error": "Not Found",
    "message": null,
    "requestId": "d8c568f7-3, L:/0:0:0:0:0:0:0:1:25001 - R:/0:0:0:0:0:0:0:1:59011"
}

name=addRequestHeaderGatewayFilterFactory
name=mapRequestHeaderGatewayFilterFactory
name=addRequestParameterGatewayFilterFactory
name=addResponseHeaderGatewayFilterFactory
name=modifyRequestBodyGatewayFilterFactory
name=dedupeResponseHeaderGatewayFilterFactory
name=modifyResponseBodyGatewayFilterFactory
name=prefixPathGatewayFilterFactory
name=preserveHostHeaderGatewayFilterFactory
name=redirectToGatewayFilterFactory
name=removeRequestHeaderGatewayFilterFactory
name=removeRequestParameterGatewayFilterFactory
name=removeResponseHeaderGatewayFilterFactory
name=rewritePathGatewayFilterFactory
name=retryGatewayFilterFactory
name=setPathGatewayFilterFactory
name=secureHeadersGatewayFilterFactory
name=setRequestHeaderGatewayFilterFactory
name=setRequestHostHeaderGatewayFilterFactory
name=setResponseHeaderGatewayFilterFactory
name=rewriteResponseHeaderGatewayFilterFactory
name=rewriteLocationResponseHeaderGatewayFilterFactory
name=setStatusGatewayFilterFactory
name=saveSessionGatewayFilterFactory
name=stripPrefixGatewayFilterFactory
name=requestHeaderToRequestUriGatewayFilterFactory
name=requestSizeGatewayFilterFactory
name=requestHeaderSizeGatewayFilterFactory

	// web适配层应用的/user/get接口
    @GetMapping(value="/get")
	public UserVO getUser(@RequestParam Long id) {
		if (Objects.isNull(id) || id < 1) {
			return null;
		}
		log.info("getUser, id={}", id);
		
		// 测试网关的AddRequestHeader过滤器
		String addHeadVal = req.getHeader("addHead");
		log.info("addHeadVal={}", addHeadVal);
		
		return userFeign.getUser(id);
	}

/*
测试结果：请求头addHead添加成功 日志如下：
o.l.a.web.controller.UserController      : addHeadVal=abc
*/

        predicates:
配置中增加 Path断言：
        # After断言
        # 严格按照下面的格式来，小于10的话，前加0
        - After=2021-09-11T14:13:13.000+08:00[Asia/Shanghai]
        # 路径断言：只接受 /web 开头的请求，，配合下面的 RewritePath过滤器一起使用
        - Path=/web/**
        # 过滤器配置
        filters:
        - AddRequestHeader=addHead,abc
        # RewritePath过滤器，重写 /web开头的请求——去掉开头的/web
        - RewritePath=/web/(?<segment>.*), /$\{segment}

添加 Path断言后，/user/get?id=1 访问失败：
{
    "timestamp": "2021-09-11T14:25:35.873+00:00",
    "path": "/user/get",
    "status": 404,
    "error": "Not Found",
    "message": null,
    "requestId": "73eb6d32-1, L:/0:0:0:0:0:0:0:1:25001 - R:/0:0:0:0:0:0:0:1:62670"
}

package org.lib.external.gateway.filters;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.web.server.ServerWebExchange;

import reactor.core.publisher.Mono;

/**
 * 请求时间日志输出
 * 一个参数：true-输出，false-不输出
 * @author ben
 * @date 2021-09-13 09:45:28 CST
 */
public class RequestTimeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestTimeGatewayFilterFactory.Config> {

	// 为什么是 GatewayFilter.class 而不是 当前类呢？
	private static final Log log = LogFactory.getLog(GatewayFilter.class);
	
	private static final String REQUEST_TIME_BEGIN = "reqTimeBegin";
	private static final String KEY = "logEnabled";

	// 必须，否则不会输出日志
	// 为何实现这个函数？
	@Override
	public List<String> shortcutFieldOrder() {
		return Arrays.asList(KEY);
	}
	
	// 默认构造函数
	public RequestTimeGatewayFilterFactory() {
		// 必须调用下面的语句，否则抛出 ClassCastException
		super(Config.class);
	}
	
	@Override
	public GatewayFilter apply(Config config) {
		// 匿名类方式（可以转换为 lambda表达式方式——这是个 函数式接口）
		return new GatewayFilter() {

			@Override
			public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
				// 添加属性值
				exchange.getAttributes().put(REQUEST_TIME_BEGIN, System.currentTimeMillis());
				
				return chain
						.filter(exchange)
						.then(
							Mono.fromRunnable(()->{
								Long startTime = exchange.getAttribute(REQUEST_TIME_BEGIN);
								if (config.logEnabled && Objects.nonNull(startTime)) {
									// 输出日志
									StringBuilder sb = new StringBuilder();
									sb.append(exchange.getRequest().getURI().getRawPath())
									  .append(": ")
									  .append(System.currentTimeMillis() - startTime)
									  .append("毫秒");
									
									log.info(sb.toString());
								}
							})
						);
			}};
	}
	
	/**
	 * RequestTimeGatewayFilter的配置
	 * @author ben
	 * @date 2021-09-13 09:43:35 CST
	 */
	public static class Config {
		/**
		 * true: 输出日志；false：不输出日志
		 */
		private boolean logEnabled;

		public boolean isLogEnabled() {
			return logEnabled;
		}

		public void setLogEnabled(boolean logEnabled) {
			this.logEnabled = logEnabled;
		}
		
	}
	
}

@Configuration
public class APPConfig {

	/**
	 * 注册新增过滤器工厂
	 * 注册后，即可在配置文件中使用
	 */
	@Bean
	public RequestTimeGatewayFilterFactory RequestTimeGatewayFilterFactory() {
		return new RequestTimeGatewayFilterFactory();
	}
	
}

# application.yml文件
    #
    # 路由配置
    gateway:
      # 配置2个GatewayFilter全局生效
      default-filters:
      - AddResponseHeader=X-Response-Default-Red, Default-Blue
      - RequestTime=true
      routes:
      ...省略...

# 访问/actuator/gateway/routes
# 注意 order值，，系统自动排的
[
    {
        "predicate": "(After: 2021-09-11T14:13:13+08:00[Asia/Shanghai] && Paths: [/web/**], match trailing slash: true)",
        "route_id": "route1",
        "filters": [
            "[[AddResponseHeader X-Response-Default-Red = 'Default-Blue'], order = 1]",
            "[[AddRequestHeader addHead = 'abc'], order = 1]",
            "[[RequestTime logEnabled=true], order = 2]",
            "[[RewritePath /web/(?<segment>.*) = '/${segment}'], order = 2]"
        ],
        "uri": "http://localhost:21001",
        "order": 0
    }
]

# 测试代码 ConfigurableApplicationContext ctx
String[] beanNames = ctx.getBeanDefinitionNames();
Arrays.stream(beanNames).forEach((name)->{
    Object bean = ctx.getBean(name);
    if (bean instanceof GlobalFilter) {
        cs.accept("name=" + name);
    }
});
        
# 测试结果
name=routingFilter
name=nettyWriteResponseFilter
name=adaptCachedBodyGlobalFilter
name=removeCachedBodyFilter
name=routeToRequestUrlFilter
name=forwardRoutingFilter
name=forwardPathFilter
name=websocketRoutingFilter
name=gatewayMetricFilter
name=noLoadBalancerClientFilter

package org.lib.external.gateway.filters;

import java.util.Objects;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;

import reactor.core.publisher.Mono;

/**
 * Token检查
 * 功能：请求头 有token 放行；无token 阻止。
 * 进一步：检查token是否有效——结合S.C.Security TODO
 * @author ben
 * @date 2021-09-13 11:46:03 CST
 */
public class TokenGlobalFilter implements GlobalFilter, Ordered {

	private static final Log log = LogFactory.getLog(TokenGlobalFilter.class);
	
	private static final String TOKEN = "token";
	
	@Override
	public int getOrder() {
		// 参考文档1 中，这里设置为 -100，，两个值都有效，-100的优先级更高
        return 0;
	}

	@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		String token = exchange.getRequest().getHeaders().getFirst(TOKEN);
		if (!StringUtils.hasText(token)) {
			// 没有token 阻止访问
			log.warn("请求没有token或token无效，禁止访问: url=" + exchange.getRequest().getURI());
			
			exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
			return exchange.getResponse().setComplete();
		}
		
		// 还可以做安全校验 TODO
		
		// 放行
		return chain.filter(exchange);
	}

}