gateway&reactive(响应式流)函数编程的webflux

　　springcloud.gateway是springcloud2的全新项目，该项目提供了一个构建在spring生态之上的API网关，包括spring5，springboot2，projectReactor。gateway旨在提高一种简单而有效的途径来转发请求，并为他们提供横切关注点，如安全性，监控/指标和弹性。在之前springcloud提供的网关是zull，zuul基于servlet2.5，使用阻塞架构，不支持长连接。zuul和negix相似，除了编程语言不同，zuul已经发布了zuul2，支持长连接，非阻塞，但是springcloud还没有整合。

项目构建：

　　引入gateway和eureka依赖，gateway的网关提供了路由配置，路由断言，过滤器等功能。

一， 路由断言：

　　路由断言接口由函数式接口RouterFunction接口提供支持，通过RouterFunctions的静态route方法来实现，如下：

public static <T extends ServerResponse> RouterFunction<T> route(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
        return new RouterFunctions.DefaultRouterFunction(predicate, handlerFunction);
    }

private static final class DefaultRouterFunction<T extends ServerResponse> extends RouterFunctions.AbstractRouterFunction<T> {
        private final RequestPredicate predicate;
        private final HandlerFunction<T> handlerFunction;

        public DefaultRouterFunction(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
            super(null);
            Assert.notNull(predicate, "Predicate must not be null");
            Assert.notNull(handlerFunction, "HandlerFunction must not be null");
            this.predicate = predicate;
            this.handlerFunction = handlerFunction;
        }

        public Mono<HandlerFunction<T>> route(ServerRequest request) {
            if (this.predicate.test(request)) {
                if (RouterFunctions.logger.isTraceEnabled()) {
                    String logPrefix = request.exchange().getLogPrefix();
                    RouterFunctions.logger.trace(logPrefix + String.format("Matched %s", this.predicate));
                }

                return Mono.just(this.handlerFunction);
            } else {
                return Mono.empty();
            }
        }

        public void accept(RouterFunctions.Visitor visitor) {
            visitor.route(this.predicate, this.handlerFunction);
        }
    }

　　　　private abstract static class AbstractRouterFunction<T extends ServerResponse> implements RouterFunction<T> 

　　而生成需要两个参数他们分别是：RequestPredicate  predicate和 HandlerFunction<T>  handlerFunction。

predicate由RequestPredicates.path()产生，handlerFunction是接口HandlerFunction<T>的函数实现类，该类只有一个方法：Mono<T> handle(ServerRequest var1)。

　　所以添加路由断言的配置类方法如下：

@Bean//路由断言
    public RouterFunction<ServerResponse> doRouterFunction(){
        RouterFunction route = RouterFunctions.route(RequestPredicates.path("/test"),
                request -> ServerResponse.ok().body(BodyInserters.fromValue("this is ok")));
        return route;
    }

　　此时路由断言的作用是当请求的路径是/test时，直接返回状态吗200，且响应体为this is ok。

为什么呢？

@FunctionalInterface
public interface HandlerFunction<T extends ServerResponse> {
    Mono<T> handle(ServerRequest var1);
}

下图的类都在org.springframework.web.reactive包下：

 

 从上面可以看出，serverResponse持有serverHttpResponse，而serverHttpResponse持有HttpServletResponse。所以这就是webflux的reactive响应式流编程实现流程。

 二，过滤器：

　　网关经常要做的是对路由请求进行过滤，对符合条件的请求进行一些操作，如增加请求头，增加请求参数，增加响应头和断路器等功能。这个功能通过函数接口RouteLocator实现，RouteLocator通过RouteLocatorBuilder来获得：

　　@Bean//过滤器
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder){
        return builder.routes().route(

                r -> r.path("/baidu")
                        .filters(f -> f.addResponseHeader("X-AnotherHeader","baz"))  
 7 　　　　　　　　　　　　　　　　　　.uri("http://www.baidu.com")  
 8  
 9  　　　　).build(); 
}

RouteLocatorBuilder.Builder.routes就是路由表，如下图：

 具体类调用流程如下：

public RouteLocatorBuilder.Builder routes() {
        return new RouteLocatorBuilder.Builder(this.context);
    }

public RouteLocatorBuilder.Builder route(Function<PredicateSpec, AsyncBuilder> fn) {
            AsyncBuilder routeBuilder = (AsyncBuilder)fn.apply((new RouteLocatorBuilder.RouteSpec(this)).randomId());
            this.add(routeBuilder);
            return this;
        }

 void add(AsyncBuilder route) {
            this.routes.add(route);
        }

public RouteLocator build() {
            return () -> {
                return Flux.fromIterable(this.routes).map((routeBuilder) -> {
                    return routeBuilder.build();
                });
            };
        }

　　上面第5行的意思是Builder.route(Function<PredicateSpec, AsyncBuilder> fn)函数需要一个AsyncBuilder，这个AsyncBuilder是org.springframework.cloud.gateway.route.Route.AsyncBuilder，即route的异步构造器，第6行得到了这个异步构造器，第七，八行加到了Builder.routes集合中，并返回自己，然后调用自己的build方法，Flux是Reactive提供的返回结果工具类，原来返回User的话，那现在就返回Mono<User>；原来返回List<User>的话，那现在就返回Flux<User>。第18行调用build构造route。

 　　我们需要一个asyncbuilder，所以需要实现Function接口，如下：

　　r -> r.path("/baidu").filters(f -> f.addRequestHeader("X-AnotherHeader","baz")).uri("http://www.baidu.com")
　　上述方法体会最终得到一个asyncbuilder，然后开始上述带颜色部分的内容。上面的功能就是当请求路径中有baidu，就在返回头上加上一个属性，然后转到该http://www.baidu.com地址。

 三，网关与服务中心结合

spring:
  application:
    name: gateway #hystrix服务类型
  cloud:
    gateway:
      locator:
        enabled: true #开启gateway和eureka的结合
      routes:
        - id: service_eureka-service1 #id
          uri: lb://eureka-service1 #服务
          predicates:
          - Path=/service_eureka-service1/**  #匹配路径
          filters:
          - StripPrefix=1 #使用路径过滤器去掉第一部分前缀 即去除service_eureka-service1这一部分

下面是service1的controller：

　　

启动service1和gateway两个服务，注册到eureka，然后访问：

 ok，先到这里，源码后续再补充。

参考文章：https://blog.csdn.net/get_set/article/details/79480233 这兄弟的文章真不错。