springcloud 系列 -- 初识 zuul

RequestContext

Zuul 的上下文，继承 ConcurrentHashMap。内置 ThreadLocal 变量。所以每一个线程都会有本身的 RequestContext 变量

ZuulFilter

ZuulFilter 实现 IZuulFilter Comparable 接口。

IZuulFilter 定义了 2 个方法

public interface IZuulFilter {
    // 是否该拦截
    boolean shouldFilter();
    // 拦截以后作什么处理。注：若是返回值为非 boolean，不会作处理，这其实表示，该方法返回值 无心义
    Object run() throws ZuulException;
}

来看 ZuulFilter 中 2 个抽象方法

abstract public String filterType();
abstract public int filterOrder();

Zuul filterType 有如下几个值：pre、route、post、error

• pre

执行前拦截

• route

执行远程服务

• post

执行后拦截

• error

发生错误时拦截

关于 filterOrder() 先看 compareTo() 方法

public abstract class ZuulFilter implements Comparable<ZuulFilter> {
    // 升序
    public int compareTo(ZuulFilter filter) {
        return Integer.compare(this.filterOrder(), filter.filterOrder());
    }
}

ZuulFilter 实现了 Comparable 接口。代表，每一个 ZuulFilter 之间是具有顺序的，filterOrder() 方法返回的值 越小越靠前

再来看 runFilter() 方法

public ZuulFilterResult runFilter() {
    ZuulFilterResult zr = new ZuulFilterResult();
    if (!isFilterDisabled()) {
        if (shouldFilter()) {
            Tracer t = TracerFactory.instance().startMicroTracer("ZUUL::" + this.getClass().getSimpleName());
            try {
                Object res = run();
                zr = new ZuulFilterResult(res, ExecutionStatus.SUCCESS);
            } catch (Throwable e) {
                t.setName("ZUUL::" + this.getClass().getSimpleName() + " failed");
                zr = new ZuulFilterResult(ExecutionStatus.FAILED);
                zr.setException(e);
            } finally {
                t.stopAndLog();
            }
        } else {
            zr = new ZuulFilterResult(ExecutionStatus.SKIPPED);
        }
    }
    return zr;
}

对于每一个返回值，均被封装为 ZuulFiterResult 若是有异常，也不会被抛出，而是放入 ZuulFiterResult 中。

从 ZuulFilter 的实现原理来看，ZuulFilter 并不是是基于传统的 Filter 实现。

ZuulProcessor

ZuulProcessor 为 Zuul 的处理器。先看 runFilters() 方法

public class FilterProcessor {
    public Object runFilters(String sType) throws Throwable {
        if (RequestContext.getCurrentContext().debugRouting()) {
            Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
        }
        boolean bResult = false;
        List<ZuulFilter> list = FilterLoader.getInstance().getFiltersByType(sType);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                ZuulFilter zuulFilter = list.get(i);
                Object result = processZuulFilter(zuulFilter);
                if (result != null && result instanceof Boolean) {
                    bResult |= ((Boolean) result);
                }
            }
        }
        return bResult;
    }
}

public class FilterProcessor {
    public Object processZuulFilter(ZuulFilter filter) throws ZuulException {
        RequestContext ctx = RequestContext.getCurrentContext();
        boolean bDebug = ctx.debugRouting();
        final String metricPrefix = "zuul.filter-";
        long execTime = 0;
        String filterName = "";
        try {
            long ltime = System.currentTimeMillis();
            filterName = filter.getClass().getSimpleName();
            
            RequestContext copy = null;
            Object o = null;
            Throwable t = null;

            if (bDebug) {
                Debug.addRoutingDebug("Filter " + filter.filterType() + " " + filter.filterOrder() + " " + filterName);
                copy = ctx.copy();
            }
            
            ZuulFilterResult result = filter.runFilter();
            ExecutionStatus s = result.getStatus();
            execTime = System.currentTimeMillis() - ltime;

            switch (s) {
                case FAILED:
                    t = result.getException();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                    break;
                case SUCCESS:
                    o = result.getResult();
                    ctx.addFilterExecutionSummary(filterName, ExecutionStatus.SUCCESS.name(), execTime);
                    if (bDebug) {
                        Debug.addRoutingDebug("Filter {" + filterName + " TYPE:" + filter.filterType() + " ORDER:" + filter.filterOrder() + "} Execution time = " + execTime + "ms");
                        Debug.compareContextState(filterName, copy);
                    }
                    break;
                default:
                    break;
            }
            
            if (t != null) throw t;

            usageNotifier.notify(filter, s);
            return o;

        } catch (Throwable e) {
            if (bDebug) {
                Debug.addRoutingDebug("Running Filter failed " + filterName + " type:" + filter.filterType() + " order:" + filter.filterOrder() + " " + e.getMessage());
            }
            usageNotifier.notify(filter, ExecutionStatus.FAILED);
            if (e instanceof ZuulException) {
                throw (ZuulException) e;
            } else {
                ZuulException ex = new ZuulException(e, "Filter threw Exception", 500, filter.filterType() + ":" + filterName);
                ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
                throw ex;
            }
        }
    }
}

runFilters 方法遍历全部的 ZuulFilters 并执行 processZuulFilter 方法. processZuulFilter 方法主要是执行了 ZuulFilter.runFilter 方法。
能够看到，只有在当 ZuulFilter.runFilter 返回 Boolean 时，才会作处理

ZuulServlet、ZuulServletFilter

Zuul 为了适配 HttpServlet，也所以有了 ZuulServlet、ZuulServletFilter.
默认状况下，启用的是 ZuulServlet. 不过能够经过 zuul.use-filter 值修改启用类

public class ZuulServerAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(name = "zuulServlet")
    @ConditionalOnProperty(name = "zuul.use-filter", havingValue = "false", matchIfMissing = true)
    public ServletRegistrationBean zuulServlet() {
        ServletRegistrationBean<ZuulServlet> servlet = new ServletRegistrationBean<>(
                new ZuulServlet(), this.zuulProperties.getServletPattern());
        // The whole point of exposing this servlet is to provide a route that doesn't
        // buffer requests.
        servlet.addInitParameter("buffer-requests", "false");
        return servlet;
    }

    @Bean
    @ConditionalOnMissingBean(name = "zuulServletFilter")
    @ConditionalOnProperty(name = "zuul.use-filter", havingValue = "true", matchIfMissing = false)
    public FilterRegistrationBean zuulServletFilter() {
        final FilterRegistrationBean<ZuulServletFilter> filterRegistration = new FilterRegistrationBean<>();
        filterRegistration.setUrlPatterns(
                Collections.singleton(this.zuulProperties.getServletPattern()));
        filterRegistration.setFilter(new ZuulServletFilter());
        filterRegistration.setOrder(Ordered.LOWEST_PRECEDENCE);
        // The whole point of exposing this servlet is to provide a route that doesn't
        // buffer requests.
        filterRegistration.addInitParameter("buffer-requests", "false");
        return filterRegistration;
    }
}

ZuulServlet、ZuulServletFilter 本质区别是：前者是基于 HttpServlet 实现，后者是基于 Filter 实现。从 j2ee 层面来讲，Filter 的执行顺序在 HttpServlet 以前

由于 ZuulServlet、ZuulServletFilter 核心实现差很少，这里用 ZuulServlet 来讲明

public class ZuulServlet extends HttpServlet {
    @Override
    public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
        try {
            init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);

            RequestContext context = RequestContext.getCurrentContext();
            context.setZuulEngineRan();

            try {
                preRoute();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                route();
            } catch (ZuulException e) {
                error(e);
                postRoute();
                return;
            }
            try {
                postRoute();
            } catch (ZuulException e) {
                error(e);
                return;
            }

        } catch (Throwable e) {
            error(new ZuulException(e, 500, "UNHANDLED_EXCEPTION_" + e.getClass().getName()));
        } finally {
            RequestContext.getCurrentContext().unset();
        }
    }
}

有几个细节处理一下：

1. 由于 RequestConext 是基于 ThreadLocal 实现，所以在 finally 中调用 unset()， 而 unset() 方法，则是在内部调用了 ThreadLocal.remove()
2. 若是未发生异常，则正确的处理流程为：pre -> route -> post
3. pre 阶段发生异常

pre -> error -> post

1. route 阶段发生异常

pre -> route -> error -> post

1. post 阶段发生异常

pre -> route -> post -> error

1. 在执行 pre, route, post, error 时，内部借助 zuulRunner，zuulRunner 由借助 FilterProcessor 调用对应的 runFilters("pre" || "route" ...)

SpringCloud 动态路由

动态路由定义：不单单能够从配置文件中加载路由，还能够从别的地方加载，例如数据库。当有新的路由添加后，须要能够动态的刷新路由

先看下 RouteLocator 接口

public interface RouteLocator {
    Collection<String> getIgnoredPaths();
    List<Route> getRoutes();
    Route getMatchingRoute(String path);
}

RouteLocator 的继承体系以下

其中 SimpleRouteLocator 不具有刷新功能，RefreshableRouteLocator 接口具有刷新功能。可是 SpringCloud 默认提供的实现类是 SimpleRouteLocator

这里再看，Zuul 启动后，如何加载路由

能够看到，是经过事件监听，从而刷新路由的。

动态路由食用 DEMO

public class MyRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator {
    
    public MyRouteLocator(String servletPath, ZuulProperties properties) {
        super(servletPath, properties);
    }
    
    @Override
    public void refresh() {
        super.doRefresh();
    }
    
    protected Map<String, ZuulRoute> locateRoutes() {
        Map<String, ZuulRoute> routesMap = super.locateRoutes();

        // TODO 实现你本身的加载逻辑
        return routesMap;
    }
}

@RestController
@EnableZuulProxy
@SpringBootApplication
public class ZuulApplication {
    
    @Lazy
    @Resource
    MyRouteLocator myRouteLocator;
    
    @Autowired
    ApplicationContext applicationContext;
    
    @GetMapping("/test")
    public Object test() {
        // 从源码流程看，咱们须要发布刷新事件。由于发布刷新事件，dirty 会被设置为  true, 设置为 true 后，才会从新注册对应 URL 的 HandlerMapping
        applicationContext.publishEvent(new RoutesRefreshedEvent(myRouteLocator));
        return "12";
    }
}

参考

zuul源码分析-探究原生zuul的工做原理