public class NioEndpoint extends AbstractJsseEndpoint<NioChannel,SocketChannel> {

    // 在NioEndpoint#bind方法中被调用
    protected void initServerSocket() throws Exception {
        // AbstractSelectableChannel#configureBlocking方法的javadoc如下：
        // If true then this channel will be placed inblocking mode; if false then it will be placednon-blocking mode
        serverSock.configureBlocking(true); //mimic APR behavior
    }
}

public class RequestContext extends ConcurrentHashMap<String, Object> {

    protected static final ThreadLocal<? extends RequestContext> threadLocal = new ThreadLocal<RequestContext>() {
        @Override
        protected RequestContext initialValue() {
            try {
                return contextClass.newInstance();
            } catch (Throwable e) {
                throw new RuntimeException(e);
            }
        }
    };

    // 通过getCurrentContext()方法获取
    public static RequestContext getCurrentContext() {
        if (testContext != null) return testContext;

        RequestContext context = threadLocal.get();
        return context;
    }
}

/**
 * This class is one of the core classes in Zuul. It compiles, loads from a File, and checks if source code changed.
 * It also holds ZuulFilters by filterType.
 */
public class FilterLoader {

    private final ConcurrentHashMap<String, List<ZuulFilter>> hashFiltersByType = new ConcurrentHashMap<String, List<ZuulFilter>>();
    private FilterRegistry filterRegistry = FilterRegistry.instance();

    /**
     * Returns a list of filters by the filterType specified
     */
    public List<ZuulFilter> getFiltersByType(String filterType) {

        // 第一次获取返回null
        List<ZuulFilter> list = hashFiltersByType.get(filterType);
        if (list != null) return list;

        // list is null.
        list = new ArrayList<ZuulFilter>();

        // 从FilterRegistry#getAllFilters取所有的ZuulFilters。
        // 在ZuulFilterInitializer的PostConstruct方法里，会把ZuulFilters放进FilterRegistry
        // 的一个ConcurrentHashMap里。
        Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
        for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
            ZuulFilter filter = iterator.next();
            if (filter.filterType().equals(filterType)) {
                // 所需类型的ZuulFilter
                list.add(filter);
            }
        }
        // 排序
        Collections.sort(list); // sort by priority

        // 把对应类型的ZuulFilters放进hashFiltersByType（一个ConcurrentHashMap），
        // 这样第二次调用这个方法可以直接返回所需的ZuulFilters
        hashFiltersByType.putIfAbsent(filterType, list);
        return list;
    }
}

public class ZuulServlet extends HttpServlet {
    @Override
    public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
        // 调用了ZuulRunner#init初始化RequestContext，并把ServletRequest、ServletResponse放进RequestContext。
        init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
        // 这里可以看出ZuulFilter的处理顺序：
        // pre->route->post；
        // 如果pre和route阶段出现异常，调用error->post；
        // 如果post阶段出现异常，调用error。
        try {
            preRoute(); // 调用了ZuulRunner#preRoute
        } catch (ZuulException e) {
            error(e); // 把异常放进RequestContext后调用了ZuulRunner#error
            postRoute(); // 调用了ZuulRunner#postRoute
            return;
        }
        try {
            route(); // 调用了ZuulRunner#route
        } catch (ZuulException e) {
            error(e);
            postRoute();
            return;
        }
        try {
            postRoute();
        } catch (ZuulException e) {
            error(e);
            return;
        }
    }

public class ZuulRunner {

    public void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
        // 被ZuulServlet#service调用
        RequestContext ctx = RequestContext.getCurrentContext();
        if (bufferRequests) {
            ctx.setRequest(new HttpServletRequestWrapper(servletRequest));
        } else { // ZuulServlet#init创建了一个bufferRequests为false的ZuulRunner，所以没有warp request。
            ctx.setRequest(servletRequest);
        }
        // 把request和response放进RequestContext
        ctx.setResponse(new HttpServletResponseWrapper(servletResponse));
    }

    public void postRoute() throws ZuulException {
        // 调用FilterProcessor#postRoute，其他route、preRoute和error也是调用的FilterProcessor里的同名方法。
        FilterProcessor.getInstance().postRoute();
    }
    ...
}

public class FilterProcessor {
    public void postRoute() throws ZuulException {
        // route方法和preRoute方法和postRoute方法一样，区别是调用runFilters时参数分别是route和pre
        // 出现异常往上抛出，try catch 代码略去
        runFilters("post");
    }
    public void error() {
        try {
            runFilters("error");
        } catch (Throwable e) {
            // 异常被捕获而不抛出，但是在ZuulServlet中异常已经被放进RequestContext。
        }
    }
    /**
     * runs all filters of the filterType sType/ Use this method within filters to run custom filters by type
     */
    public Object runFilters(String sType) throws Throwable {
        // 从FilterLoader中获取对应类型的ZuulFilter，是排过序的
        List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);
        for (int i = 0; i < list.size(); i++) {
            ZuulFilter zuulFilter = list.get(i);
            // 获取ZuulFilter，并调用processZuulFilter方法
            Object result = processZuulFilter(zuulFilter);
            if (result != null && result instanceof Boolean) {
                // |= 操作，与 += 一样但比较少见，此外还有 &= 、^=
                bResult |= ((Boolean) result);
            }
        }
        return bResult;
    }

    /**
     * Processes an individual ZuulFilter. This method adds Debug information.
     * Any uncaught Thowables are caught by this method and converted to a ZuulException with a 500 status code.
     */
    public Object processZuulFilter(ZuulFilter filter) throws ZuulException {
        // get RequestContext
        RequestContext ctx = RequestContext.getCurrentContext();
        try {
            // 调用ZuulFilter#runFilter。根据过滤器里的shouldFilter判断是否执行过滤器的run()方法。
            // 如果执行过滤器的run()方法，返回执行成功（SUCCESS）或失败（FAILED），不执行则返回跳过（SKIPPED）
            ZuulFilterResult result = filter.runFilter();
            // ZuulFilter#runFilter执行状态
            ExecutionStatus s = result.getStatus();
            switch (s) {
                case FAILED:
                    // 过滤器的run()执行异常
                    t = result.getException();
                    break;
                case SUCCESS:
                    // 过滤器的的run()执行结束
                    o = result.getResult();
                    break;
                default:
                    // 过滤器的shouldFilter是false
                    break;
            }
            // 如果过滤器的run()异常，抛异常
            if (t != null) throw t;
            return o;
        } catch (Throwable e) {
            // 异常往上抛出，在ZuulServlet#service方法里被捕获，然后通过error类型的过滤器处理异常。
        }
    }
}

public abstract class ZuulFilter implements IZuulFilter, Comparable<ZuulFilter> {
    // 过滤器类型
    abstract public String filterType();
    // 过滤器优先级
    abstract public int filterOrder();
    // 过滤器是否被禁用。
    // 在runFilter()方法里，通过判断isFilterDisabled与过滤器的shouldFilter方法，来确定是否执行过滤器的run方法
    public boolean isFilterDisabled() {
        ...
    }
    /**
     * runFilter checks !isFilterDisabled() and shouldFilter(). The run() method is invoked if both are true.
     */
    public ZuulFilterResult runFilter() {
        ZuulFilterResult zr = new ZuulFilterResult();
        // 是否被禁用
        if (!isFilterDisabled()) {
            // 是否应该执行
            if (shouldFilter()) {
                try {
                    Object res = run(); // 执行过滤器的run()
                    zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS);
                } catch (Throwable e) {
                    zr = new ZuulFilterResult(ExecutionStatus.FAILED);
                    zr.setException(e);
                } finally {
                }
            } else {
                zr = new ZuulFilterResult(ExecutionStatus.SKIPPED);
            }
        }
        return zr;
    }
}

public class ReactorHttpHandlerAdapter implements BiFunction<HttpServerRequest, HttpServerResponse, Mono<Void>> {
  @Override
  public Mono<Void> apply(HttpServerRequest reactorRequest, HttpServerResponse reactorResponse) {
    NettyDataBufferFactory bufferFactory = new NettyDataBufferFactory(reactorResponse.alloc());
    try {
      ReactorServerHttpRequest request = new ReactorServerHttpRequest(reactorRequest, bufferFactory);
      ServerHttpResponse response = new ReactorServerHttpResponse(reactorResponse, bufferFactory);

      if (request.getMethod() == HttpMethod.HEAD) {
        response = new HttpHeadResponseDecorator(response);
      }

      return this.httpHandler.handle(request, response)
          .doOnError(ex -> logger.trace(request.getLogPrefix() + "Failed to complete: " + ex.getMessage()))
          .doOnSuccess(aVoid -> logger.trace(request.getLogPrefix() + "Handling completed"));
    }
    catch (URISyntaxException ex) {
      if (logger.isDebugEnabled()) {
        logger.debug("Failed to get request URI: " + ex.getMessage());
      }
      reactorResponse.status(HttpResponseStatus.BAD_REQUEST);
      return Mono.empty();
    }
  }
}