摘要：公司要做自己的網(wǎng)關(guān)，于是先把的過(guò)了一遍，然后把源碼在看了一遍，這樣公司的需求就搞定了。包括動(dòng)態(tài)路由，多緯度限流，記錄請(qǐng)求參數(shù)及返回參數(shù)也可修改。至此，流程就走完了。

公司要做自己的網(wǎng)關(guān)，于是先把github的issue過(guò)了一遍，然后把gateway源碼在看了一遍，這樣公司的需求就搞定了。包括動(dòng)態(tài)路由，多緯度限流，記錄請(qǐng)求參數(shù)及返回參數(shù)（也可修改）。先從請(qǐng)求進(jìn)入網(wǎng)關(guān)說(shuō)起吧：
請(qǐng)求先進(jìn)入HttpWebHandlerAdapter 類(lèi)里

@Override
    public Mono handle(ServerHttpRequest request, ServerHttpResponse response) {
        ServerWebExchange exchange = createExchange(request, response);
        //getDelegate()獲取的是ExceptionHandlingWebHandler,用來(lái)處理全局的異常
        return getDelegate().handle(exchange)
                .onErrorResume(ex -> handleFailure(request, response, ex))
                .then(Mono.defer(response::setComplete));
    }

    protected ServerWebExchange createExchange(ServerHttpRequest request, ServerHttpResponse response) {
//這里的DefaultServerWebExchange就是后面過(guò)濾器用到的ServerWebExchange,包括封裝的請(qǐng)求參數(shù)，以及再執(zhí)行過(guò)濾器時(shí)往里面添加參數(shù)，參數(shù)是線(xiàn)程安全的
        return new DefaultServerWebExchange(request, response, this.sessionManager,
                getCodecConfigurer(), getLocaleContextResolver(), this.applicationContext);
    }

往下走：

前面的getDelegate().handle(exchange)進(jìn)入DefaultWebFilterChain類(lèi)里

public class DefaultWebFilterChain implements WebFilterChain {

    private final List filters;

    private final WebHandler handler;

    private final int index;

    ·······

    @Override
    public Mono filter(ServerWebExchange exchange) {
        return Mono.defer(() -> {
            if (this.index < this.filters.size()) {//先執(zhí)行完所有的 WebFilter 
                WebFilter filter = this.filters.get(this.index);
                //這里重新new DefaultWebFilterChain然后調(diào)用filter方法,也就會(huì)順序執(zhí)行所有的過(guò)濾器了
                WebFilterChain chain = new DefaultWebFilterChain(this, this.index + 1);
                return filter.filter(exchange, chain);
            }
            else {//然后才會(huì)執(zhí)行網(wǎng)關(guān)自定義的過(guò)濾器
                return this.handler.handle(exchange);
            }
        });
    }

}

往下：

this.handler.handle(exchange),進(jìn)入到DispatcherHandler類(lèi)里

public class DispatcherHandler implements WebHandler, ApplicationContextAware {
    ····
    @Nullable
    //HandlerMapping用來(lái)判斷請(qǐng)求進(jìn)來(lái)的地址應(yīng)該怎么處理，可能會(huì)匹配到spring webflux的HandlerFunction，
    或者是controller，然后才是我們?cè)诰W(wǎng)關(guān)配置的路由，都匹配不上的話(huà)就到SimpleUrlHandlerMapping來(lái)處理404            
    了,這里其實(shí)有點(diǎn)不太明白為什么作者會(huì)把網(wǎng)關(guān)路由的優(yōu)先級(jí)設(shè)置低于HandlerFunction，controller，網(wǎng)關(guān)畢竟是            
    用來(lái)轉(zhuǎn)發(fā)，所以我另外加了個(gè)類(lèi)設(shè)置了最高的優(yōu)先級(jí)(修改RoutePredicateHandlerMapping中的order)
    private List handlerMappings;

    @Nullable
    private List handlerAdapters;

    @Nullable
    //處理網(wǎng)關(guān)調(diào)用第三方服務(wù)返回的結(jié)果
    private List resultHandlers;
 
     ·····
    public DispatcherHandler(ApplicationContext applicationContext) {
        initStrategies(applicationContext);
    }
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) {
        initStrategies(applicationContext);
    }

    //網(wǎng)關(guān)啟動(dòng)時(shí)調(diào)用,設(shè)置三個(gè)list變量并排序
    protected void initStrategies(ApplicationContext context) {
        Map mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
                context, HandlerMapping.class, true, false);

        ArrayList mappings = new ArrayList<>(mappingBeans.values());
        AnnotationAwareOrderComparator.sort(mappings);
        this.handlerMappings = Collections.unmodifiableList(mappings);

        Map adapterBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
                context, HandlerAdapter.class, true, false);

        this.handlerAdapters = new ArrayList<>(adapterBeans.values());
        AnnotationAwareOrderComparator.sort(this.handlerAdapters);

        Map beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(
                context, HandlerResultHandler.class, true, false);

        this.resultHandlers = new ArrayList<>(beans.values());
        AnnotationAwareOrderComparator.sort(this.resultHandlers);
    }


    @Override
    public Mono handle(ServerWebExchange exchange) {
        if (logger.isDebugEnabled()) {
            ServerHttpRequest request = exchange.getRequest();
            logger.debug("Processing " + request.getMethodValue() + " request for [" + request.getURI() + "]");
        }
        if (this.handlerMappings == null) {
            return Mono.error(HANDLER_NOT_FOUND_EXCEPTION);
        }
        return Flux.fromIterable(this.handlerMappings)
                //handlerMappings根據(jù)路由匹配合適的handler,確定是網(wǎng)關(guān)處理還是代理到第三方
                .concatMap(mapping -> mapping.getHandler(exchange))
                //上面的匹配可能會(huì)出現(xiàn)多個(gè)符合條件的，next()的作用在于匹配到第一個(gè)就停止匹配
                .next()
                .switchIfEmpty(Mono.error(HANDLER_NOT_FOUND_EXCEPTION))
                .flatMap(handler -> invokeHandler(exchange, handler))
                .flatMap(result -> handleResult(exchange, result));
    }

    private Mono invokeHandler(ServerWebExchange exchange, Object handler) {
        if (this.handlerAdapters != null) {
            for (HandlerAdapter handlerAdapter : this.handlerAdapters) {
                if (handlerAdapter.supports(handler)) {//前面匹配到handler后，循環(huán)便利是否支持并執(zhí)行    
                    hadler方法
                    return handlerAdapter.handle(exchange, handler); 
                }
            }
        }
        return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
    }

    private Mono handleResult(ServerWebExchange exchange, HandlerResult result) {
        return getResultHandler(result).handleResult(exchange, result)
                .onErrorResume(ex -> result.applyExceptionHandler(ex).flatMap(exceptionResult ->
                        //同樣是循環(huán)遍歷是否支持并執(zhí)行  handleResult方法
                        getResultHandler(exceptionResult).handleResult(exchange, exceptionResult)));
    }

    private HandlerResultHandler getResultHandler(HandlerResult handlerResult) {
        if (this.resultHandlers != null) {
            for (HandlerResultHandler resultHandler : this.resultHandlers) {
                if (resultHandler.supports(handlerResult)) { 
                    return resultHandler;
                }
            }
        }
        throw new IllegalStateException("No HandlerResultHandler for " + handlerResult.getReturnValue());
    }

}

接上面 ：

handlerAdapter.handle(exchange, handler); 
只說(shuō)匹配到我們配置的路由的情況
進(jìn)入到SimpleHandlerAdapter類(lèi)
public class SimpleHandlerAdapter implements HandlerAdapter {

    @Override
    public boolean supports(Object handler) {
        return WebHandler.class.isAssignableFrom(handler.getClass());
    }

    @Override
    public Mono handle(ServerWebExchange exchange, Object handler) {
        WebHandler webHandler = (WebHandler) handler;
        //根據(jù)傳進(jìn)來(lái)的不同handler處理不同的情況，匹配上路由的話(huà)傳進(jìn)來(lái)的是FilteringWebHandler
        Mono mono = webHandler.handle(exchange);
        return mono.then(Mono.empty());
    }

}
繼續(xù)看FilteringWebHandler類(lèi)：

public class FilteringWebHandler implements WebHandler {
    protected static final Log logger = LogFactory.getLog(FilteringWebHandler.class);

    private final List globalFilters;
    //在GatewayAutoConfiguration中配置bean,注入所有實(shí)現(xiàn)GlobalFilter的類(lèi)
    public FilteringWebHandler(List globalFilters) {
        this.globalFilters = loadFilters(globalFilters);
    }
    //將GlobalFilter和GatewayFilter合并并排序
    private static List loadFilters(List filters) {
        return filters.stream()
                .map(filter -> {
                    GatewayFilterAdapter gatewayFilter = new GatewayFilterAdapter(filter);
                    if (filter instanceof Ordered) {
                        int order = ((Ordered) filter).getOrder();
                        return new OrderedGatewayFilter(gatewayFilter, order);
                    }
                    return gatewayFilter;
                }).collect(Collectors.toList());
    }

    /* TODO: relocate @EventListener(RefreshRoutesEvent.class)
    void handleRefresh() {
        this.combinedFiltersForRoute.clear();
    }*/

    @Override
    public Mono handle(ServerWebExchange exchange) {
        //獲取前面在匹配路由時(shí)放進(jìn)ServerWebExchange中的路由數(shù)據(jù)
        Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
        //獲取本路由配置的過(guò)濾器
        List gatewayFilters = route.getFilters();

        List combined = new ArrayList<>(this.globalFilters);
        //把當(dāng)前路由的過(guò)濾器跟全局過(guò)濾器組合
        combined.addAll(gatewayFilters);
        //排序
        AnnotationAwareOrderComparator.sort(combined);

        if (logger.isDebugEnabled()) {
            logger.debug("Sorted gatewayFilterFactories: "+ combined);
        }

        return new DefaultGatewayFilterChain(combined).filter(exchange);
    }

    private static class DefaultGatewayFilterChain implements GatewayFilterChain {

        private final int index;
        private final List filters;

        public DefaultGatewayFilterChain(List filters) {
            this.filters = filters;
            this.index = 0;
        }

        private DefaultGatewayFilterChain(DefaultGatewayFilterChain parent, int index) {
            this.filters = parent.getFilters();
            this.index = index;
        }

        public List getFilters() {
            return filters;
        }

        @Override
        public Mono filter(ServerWebExchange exchange) {
            return Mono.defer(() -> {
                if (this.index < filters.size()) {
                //與之前的WebFilter 一樣,每次執(zhí)行都new DefaultGatewayFilterChain調(diào)用filter方法，
                //不斷往下執(zhí)行直到過(guò)濾器走完
                    GatewayFilter filter = filters.get(this.index);
                    DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
                    return filter.filter(exchange, chain);
                } else {
                    return Mono.empty(); // complete
                }
            });
        }
    }

    private static class GatewayFilterAdapter implements GatewayFilter {

        private final GlobalFilter delegate;

        public GatewayFilterAdapter(GlobalFilter delegate) {
            this.delegate = delegate;
        }

        @Override
        public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            return this.delegate.filter(exchange, chain);
        }

        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("GatewayFilterAdapter{");
            sb.append("delegate=").append(delegate);
            sb.append("}");
            return sb.toString();
        }
    }

}

然后，在排序倒數(shù)第二的過(guò)濾器NettyRoutingFilter中，調(diào)用默認(rèn)的HttpClient，代理到后面的服務(wù)。
至此，流程就走完了。