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 這兄弟的文章真不錯。