zuul源码分析-探究原生zuul的工作原理
前提
最近在项目中使用了SpringCloud，基于zuul搭建了一个提供加解密、鉴权等功能的网关服务。鉴于之前没怎么使用过Zuul，于是顺便仔细阅读了它的源码。实际上，zuul原来提供的功能是很单一的：通过一个统一的Servlet入口(ZuulServlet，或者Filter入口，使用ZuulServletFilter)拦截所有的请求，然后通过内建的com.netflix.zuul.IZuulFilter链对请求做拦截和过滤处理。ZuulFilter和javax.servlet.Filter的原理相似，但是它们本质并不相同。javax.servlet.Filter在Web应用中是独立的组件，ZuulFilter是ZuulServlet处理请求时候调用的，后面会详细分析。
源码环境准备
zuul的项目地址是https://github.com/Netflix/zuul，它是著名的"开源框架提供商"Netflix的作品，项目的目的是：Zuul是一个网关服务，提供动态路由、监视、弹性、安全性等。在SpringCloud中引入了zuul，配合Netflix的另一个负载均衡框架Ribbon和Netflix的另一个提供服务发现与注册框架Eureka，可以实现服务的动态路由。值得注意的是，zuul在2.x甚至3.x的分支中已经引入了netty，框架的复杂性大大提高。但是当前的SpringCloud体系并没有升级zuul的版本，目前使用的是zuul1.x的最高版本1.3.1：
因此我们需要阅读它的源码的时候可以选择这个发布版本。值得注意的是，由于这些版本的发布时间已经比较久，有部分插件或者依赖包可能找不到，笔者在构建zuul1.3.1的源码的时候发现这几个问题：
- 1、
nebula.netflixoss插件的旧版本已经不再支持，所有build.gradle文件中的nebula.netflixoss插件的版本修改为5.2.0。 - 2、2017年的时候Gradle支持的版本是2.x，笔者这里选择了gradle-2.14，选择高版本的Gradle有可能在构建项目的时候出现
jetty插件不支持。 - 3、Jdk最好使用1.8，Gradle构建文件中的sourceCompatibility、targetCompatibility、languageLevel等配置全改为1.8。
另外，如果使用IDEA进行构建，注意配置项目的Jdk和Java环境，所有配置改为Jdk1.8，Gradle构建成功后如下：
zuul-1.3.1中提供了一个Web应用的Sample项目，我们直接运行zuul-simple-webapp的Gradle配置中的Tomcat插件即可启动项目，开始Debug之旅：
源码分析
ZuulFilter的加载
从Zuul的源码来看，ZuulFilter的加载模式可能跟我们想象的大有不同，Zuul设计的初衷是ZuulFilter是存放在Groovy文件中，可以实现基于最后修改时间进行热加载。我们先看看Zuul核心类之一com.netflix.zuul.filters.FilterRegistry(Filter的注册中心，实际上是ZuulFilter的全局缓存)：
public class FilterRegistry {
// 饿汉式单例，确保全局只有一个ZuulFilter的缓存
private static final FilterRegistry INSTANCE = new FilterRegistry();
public static final FilterRegistry instance() {
return INSTANCE;
}
//缓存字符串到ZuulFilter实例的映射关系，如果是从文件加载，字符串key的格式是：文件绝对路径 + 文件名，当然也可以自实现
private final ConcurrentHashMap<String, ZuulFilter> filters = new ConcurrentHashMap<String, ZuulFilter>();
private FilterRegistry() {
}
public ZuulFilter remove(String key) {
return this.filters.remove(key);
}
public ZuulFilter get(String key) {
return this.filters.get(key);
}
public void put(String key, ZuulFilter filter) {
this.filters.putIfAbsent(key, filter);
}
public int size() {
return this.filters.size();
}
public Collection<ZuulFilter> getAllFilters() {
return this.filters.values();
}
}
实际上Zuul使用了简单粗暴的方式(直接使用ConcurrentHashMap)缓存了ZuulFilter，这些缓存除非主动调用remove方法，否则不会自动清理。Zuul提供默认的动态代码编译器，接口是DynamicCodeCompiler，目的是把代码编译为Java的类，默认实现是GroovyCompiler，功能就是把Groovy代码编译为Java类。还有一个比较重要的工厂类接口是FilterFactory，它定义了ZuulFilter类生成ZuulFilter实例的逻辑，默认实现是DefaultFilterFactory，实际上就是利用Class#newInstance()反射生成ZuulFilter实例。接着，我们可以进行分析FilterLoader的源码，这个类的作用就是加载文件中的ZuulFilter实例：
public class FilterLoader {
//静态final实例，注意到访问权限是包许可，实际上就是饿汉式单例
final static FilterLoader INSTANCE = new FilterLoader();
private static final Logger LOG = LoggerFactory.getLogger(FilterLoader.class);
//缓存Filter名称(主要是从文件加载，名称为绝对路径 + 文件名的形式)->Filter最后修改时间戳的映射
private final ConcurrentHashMap<String, Long> filterClassLastModified = new ConcurrentHashMap<String, Long>();
//缓存Filter名字->Filter代码的映射，实际上这个Map只使用到get方法进行存在性判断，一直是一个空的结构
private final ConcurrentHashMap<String, String> filterClassCode = new ConcurrentHashMap<String, String>();
//缓存Filter名字->Filter名字的映射，用于存在性判断
private final ConcurrentHashMap<String, String> filterCheck = new ConcurrentHashMap<String, String>();
//缓存Filter类型名称->List<ZuulFilter>的映射
private final ConcurrentHashMap<String, List<ZuulFilter>> hashFiltersByType = new ConcurrentHashMap<String, List<ZuulFilter>>();
//前面提到的ZuulFilter全局缓存的单例
private FilterRegistry filterRegistry = FilterRegistry.instance();
//动态代码编译器实例，Zuul提供的默认实现是GroovyCompiler
static DynamicCodeCompiler COMPILER;
//ZuulFilter的工厂类
static FilterFactory FILTER_FACTORY = new DefaultFilterFactory();
//下面三个方法说明DynamicCodeCompiler、FilterRegistry、FilterFactory可以被覆盖
public void setCompiler(DynamicCodeCompiler compiler) {
COMPILER = compiler;
}
public void setFilterRegistry(FilterRegistry r) {
this.filterRegistry = r;
}
public void setFilterFactory(FilterFactory factory) {
FILTER_FACTORY = factory;
}
//饿汉式单例获取自身实例
public static FilterLoader getInstance() {
return INSTANCE;
}
//返回所有缓存的ZuulFilter实例的总数量
public int filterInstanceMapSize() {
return filterRegistry.size();
}
//通过ZuulFilter的类代码和Filter名称获取ZuulFilter实例
public ZuulFilter getFilter(String sCode, String sName) throws Exception {
//检查filterCheck是否存在相同名字的Filter，如果存在说明已经加载过
if (filterCheck.get(sName) == null) {
//filterCheck中放入Filter名称
filterCheck.putIfAbsent(sName, sName);
//filterClassCode中不存在加载过的Filter名称对应的代码
if (!sCode.equals(filterClassCode.get(sName))) {
LOG.info("reloading code " + sName);
//从全局缓存中移除对应的Filter
filterRegistry.remove(sName);
}
}
ZuulFilter filter = filterRegistry.get(sName);
//如果全局缓存中不存在对应的Filter，就使用DynamicCodeCompiler加载代码，使用FilterFactory实例化ZuulFilter
//注意加载的ZuulFilter类不能是抽象的，必须是继承了ZuulFilter的子类
if (filter == null) {
Class clazz = COMPILER.compile(sCode, sName);
if (!Modifier.isAbstract(clazz.getModifiers())) {
filter = (ZuulFilter) FILTER_FACTORY.newInstance(clazz);
}
}
return filter;
}
//通过文件加加载ZuulFilter
public boolean putFilter(File file) throws Exception {
//Filter名称为文件的绝对路径+文件名(这里其实绝对路径已经包含文件名，这里再加文件名的目的不明确)
String sName = file.getAbsolutePath() + file.getName();
//如果文件被修改过则从全局缓存从移除对应的Filter以便重新加载
if (filterClassLastModified.get(sName) != null && (file.lastModified() != filterClassLastModified.get(sName))) {
LOG.debug("reloading filter " + sName);
filterRegistry.remove(sName);
}
//下面的逻辑和上一个方法类似
ZuulFilter filter = filterRegistry.get(sName);
if (filter == null) {
Class clazz = COMPILER.compile(file);
if (!Modifier.isAbstract(clazz.getModifiers())) {
filter = (ZuulFilter) FILTER_FACTORY.newInstance(clazz);
List<ZuulFilter> list = hashFiltersByType.get(filter.filterType());
//这里说明了一旦文件有修改，hashFiltersByType中对应的当前文件加载出来的Filter类型的缓存要移除，原因见下一个方法
if (list != null) {
hashFiltersByType.remove(filter.filterType()); //rebuild this list
}
filterRegistry.put(file.getAbsolutePath() + file.getName(), filter);
filterClassLastModified.put(sName, file.lastModified());
return true;
}
}
return false;
}
//通过Filter类型获取同类型的所有ZuulFilter
public List<ZuulFilter> getFiltersByType(String filterType) {
List<ZuulFilter> list = hashFiltersByType.get(filterType);
if (list != null) return list;
list = new ArrayList<ZuulFilter>();
//如果hashFiltersByType缓存被移除，这里从全局缓存中加载所有的ZuulFilter，按照指定类型构建一个新的列表
Collection<ZuulFilter> filters = filterRegistry.getAllFilters();
for (Iterator<ZuulFilter> iterator = filters.iterator(); iterator.hasNext(); ) {
ZuulFilter filter = iterator.next();
if (filter.filterType().equals(filterType)) {
list.add(filter);
}
}
//注意这里会进行排序，是基于filterOrder
Collections.sort(list); // sort by priority
//这里总是putIfAbsent，这就是为什么上个方法可以放心地在修改的情况下移除指定Filter类型中的全部缓存实例的原因
hashFiltersByType.putIfAbsent(filterType, list);
return list;
}
}
上面的几个方法和缓存容器都比较简单，这里实际上有加载和存放动作的方法只有putFilter，这个方法正是Filter文件管理器FilterFileManager依赖的，接着看FilterFileManager的源码：
public class FilterFileManager {
private static final Logger LOG = LoggerFactory.getLogger(FilterFileManager.class);
String[] aDirectories;
int pollingIntervalSeconds;
Thread poller;
boolean bRunning = true;
//文件名过滤器，Zuul中的默认实现是GroovyFileFilter，只接受.groovy后缀的文件
static FilenameFilter FILENAME_FILTER;
static FilterFileManager INSTANCE;
private FilterFileManager() {
}
public static void setFilenameFilter(FilenameFilter filter) {
FILENAME_FILTER = filter;
}
//init方法是核心静态方法，它具备了配置，预处理和激活后台轮询线程的功能
public static void init(int pollingIntervalSeconds, String... directories) throws Exception, IllegalAccessException, InstantiationException{
if (INSTANCE == null) INSTANCE = new FilterFileManager();
INSTANCE.aDirectories = directories;
INSTANCE.pollingIntervalSeconds = pollingIntervalSeconds;
INSTANCE.manageFiles();
INSTANCE.startPoller();
}
public static FilterFileManager getInstance() {
return INSTANCE;
}
public static void shutdown() {
INSTANCE.stopPoller();
}
void stopPoller() {
bRunning = false;
}
//启动后台轮询守护线程，每休眠pollingIntervalSeconds秒则进行一次文件扫描尝试更新Filter
void startPoller() {
poller = new Thread("GroovyFilterFileManagerPoller") {
public void run() {
while (bRunning) {
try {
sleep(pollingIntervalSeconds * 1000);
//预处理文件，实际上是ZuulFilter的预加载
manageFiles();
} catch (Exception e) {
e.printStackTrace();
}
}
}
};
//设置为守护线程
poller.setDaemon(true);
poller.start();
}
//根据指定目录路径获取目录，主要需要转换为ClassPath
public File getDirectory(String sPath) {
File directory = new File(sPath);
if (!directory.isDirectory()) {
URL resource = FilterFileManager.class.getClassLoader().getResource(sPath);
try {
directory = new File(resource.toURI());
} catch (Exception e) {
LOG.error("Error accessing directory in classloader. path=" + sPath, e);
}
if (!directory.isDirectory()) {
throw new RuntimeException(directory.getAbsolutePath() + " is not a valid directory");
}
}
return directory;
}
//遍历配置目录，获取所有配置目录下的所有满足FilenameFilter过滤条件的文件
List<File> getFiles() {
List<File> list = new ArrayList<File>();
for (String sDirectory : aDirectories) {
if (sDirectory != null) {
File directory = getDirectory(sDirectory);
File[] aFiles = directory.listFiles(FILENAME_FILTER);
if (aFiles != null) {
list.addAll(Arrays.asList(aFiles));
}
}
}
return list;
}
//遍历指定文件列表，调用FilterLoader单例中的putFilter
void processGroovyFiles(List<File> aFiles) throws Exception, InstantiationException, IllegalAccessException {
for (File file : aFiles) {
FilterLoader.getInstance().putFilter(file);
}
}
//获取指定目录下的所有文件，调用processGroovyFiles，个人认为这两个方法没必要做单独封装
void manageFiles() throws Exception, IllegalAccessException, InstantiationException {
List<File> aFiles = getFiles();
processGroovyFiles(aFiles);
}
分析完FilterFileManager源码之后，Zuul中基于文件加载ZuulFilter的逻辑已经十分清晰：后台启动一个守护线程，定时轮询指定文件夹里面的文件，如果文件存在变更，则尝试更新指定的ZuulFilter缓存，FilterFileManager的init方法调用的时候在启动后台线程之前会进行一次预加载。
RequestContext
在分析ZuulFilter的使用之前，有必要先了解Zuul中的请求上下文对象RequestContext。首先要有一个共识：每一个新的请求都是由一个独立的线程处理(这个线程是Tomcat里面起的线程)，换言之，请求的所有参数(Http报文信息解析出来的内容，如请求头、请求体等等)总是绑定在处理请求的线程中。RequestContext的设计就是简单直接有效，它继承于ConcurrentHashMap<String, Object>，所以参数可以直接设置在RequestContext中，zuul没有设计一个类似于枚举的类控制RequestContext的可选参数，因此里面的设置值和提取值的方法都是硬编码的，例如：
public HttpServletRequest getRequest() {
return (HttpServletRequest) get("request");
}
public void setRequest(HttpServletRequest request) {
put("request", request);
}
public HttpServletResponse getResponse() {
return (HttpServletResponse) get("response");
}
public void setResponse(HttpServletResponse response) {
set("response", response);
}
...
看起来很暴力并且不怎么优雅，但是实际上是高效的。RequestContext一般使用静态方法RequestContext#getCurrentContext()进行初始化，我们分析一下它的初始化流程：
//保存RequestContext自身类型
protected static Class<? extends RequestContext> contextClass = RequestContext.class;
//静态对象
private static RequestContext testContext = null;
//静态final修饰的ThreadLocal实例，用于存放所有的RequestContext，每个RequestContext都会绑定在自身请求的处理线程中
//注意这里的ThreadLocal实例的initialValue()方法，当ThreadLocal的get()方法返回null的时候总是会调用initialValue()方法
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);
}
}
};
public RequestContext() {
super();
}
public static RequestContext getCurrentContext() {
//这里混杂了测试的代码，暂时忽略
if (testContext != null) return testContext;
//当ThreadLocal的get()方法返回null的时候总是会调用initialValue()方法，所以这里是"无则新建RequestContext"的逻辑
RequestContext context = threadLocal.get();
return context;
}
注意上面的ThreadLocal覆盖了初始化方法initialValue()，ThreadLocal的初始化方法总是在ThreadLocal#get()方法返回null的时候调用，实际上静态方法RequestContext#getCurrentContext()的作用就是：如果ThreadLocal中已经绑定了RequestContext静态实例就直接获取绑定在线程中的RequestContext实例，否则新建一个RequestContext实例存放在ThreadLocal(绑定到当前的请求线程中)。了解这一点后面分析ZuulServletFilter和ZuulServlet的时候就很简单了。
ZuulFilter
抽象类com.netflix.zuul.ZuulFilter是Zuul里面的核心组件，它是用户扩展Zuul行为的组件，用户可以实现不同类型的ZuulFilter、定义它们的执行顺序、实现它们的执行方法达到定制化的目的，SpringCloud的netflix-zuul就是一个很好的实现包。ZuulFilter实现了IZuulFilter接口，我们先看这个接口的定义：
public interface IZuulFilter {
boolean shouldFilter();
Object run() throws ZuulException;
}
很简单，shouldFilter()方法决定是否需要执行(也就是执行时机由使用者扩展，甚至可以禁用)，而run()方法决定执行的逻辑。接着看ZuulFilter的源码：
public abstract class ZuulFilter implements IZuulFilter, Comparable<ZuulFilter> {
//netflix的配置组件，实际上就是基于配置文件提取的指定key的值
private final AtomicReference<DynamicBooleanProperty> filterDisabledRef = new AtomicReference<>();
//定义Filter的类型
abstract public String filterType();
//定义当前Filter实例执行的顺序
abstract public int filterOrder();
//是否静态的Filter，静态的Filter是无状态的
public boolean isStaticFilter() {
return true;
}
//禁用当前Filter的配置属性的Key名称
//Key=zuul.${全类名}.${filterType}.disable
public String disablePropertyName() {
return "zuul." + this.getClass().getSimpleName() + "." + filterType() + ".disable";
}
//判断当前的Filter是否禁用，通过disablePropertyName方法从配置中读取，默认是不禁用，也就是启用
public boolean isFilterDisabled() {
filterDisabledRef.compareAndSet(null, DynamicPropertyFactory.getInstance().getBooleanProperty(disablePropertyName(), false));
return filterDisabledRef.get().get();
}
//这个是核心方法，执行Filter，如果Filter不是禁用、并且满足执行时机则调用run方法，返回执行结果，记录执行轨迹
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;
}
//实现Comparable，基于filterOrder升序排序，也就是filterOrder越大，执行优先度越低
public int compareTo(ZuulFilter filter) {
return Integer.compare(this.filterOrder(), filter.filterOrder());
}
}
这里注意几个地方，第一个是filterOrder()方法和compareTo(ZuulFilter filter)方法，子类实现ZuulFilter时候，filterOrder()方法返回值越大，或者说Filter的顺序系数越大，ZuulFilter执行的优先度越低。第二个地方是可以通过zuul.${全类名}.${filterType}.disable=false通过类名和Filter类型禁用对应的Filter。第三个值得注意的地方是Zuul中定义了四种类型的ZuulFilter，后面分析ZuulRunner的时候再详细展开。ZuulFilter实际上就是使用者扩展的核心组件，通过实现ZuulFilter的方法可以在一个请求处理链中的特定位置执行特定的定制化逻辑。第四个值得注意的地方是runFilter()方法执行不会抛出异常，如果出现异常，Throwable实例会保存在ZuulFilterResult对象中返回到外层方法，如果正常执行，则直接返回runFilter()方法的结果。
FilterProcessor
前面花大量功夫分析完ZuulFilter基于Groovy文件的加载机制(在SpringCloud体系中并没有使用此策略，因此，我们持了解的态度即可)以及RequestContext的设计，接着我们分析FilterProcessor去了解如何使用加载好的缓存中的ZuulFilter。我们先看FilterProcessor的基本属性：
public class FilterProcessor {
static FilterProcessor INSTANCE = new FilterProcessor();
protected static final Logger logger = LoggerFactory.getLogger(FilterProcessor.class);
private FilterUsageNotifier usageNotifier;
public FilterProcessor() {
usageNotifier = new BasicFilterUsageNotifier();
}
public static FilterProcessor getInstance() {
return INSTANCE;
}
public static void setProcessor(FilterProcessor processor) {
INSTANCE = processor;
}
public void setFilterUsageNotifier(FilterUsageNotifier notifier) {
this.usageNotifier = notifier;
}
...
}
像之前分析的几个类一样，FilterProcessor设计为单例，提供可以覆盖单例实例的方法。需要注意的一点是属性usageNotifier是FilterUsageNotifier类型，FilterUsageNotifier接口的默认实现是BasicFilterUsageNotifier(FilterProcessor的一个静态内部类)，BasicFilterUsageNotifier依赖于Netflix的一个工具包servo-core，提供基于内存态的计数器统计每种ZuulFilter的每一次调用的状态ExecutionStatus。枚举ExecutionStatus的可选值如下：
- 1、SUCCESS，代表该Filter处理成功，值为1。
- 2、SKIPPED，代表该Filter跳过处理，值为-1。
- 3、DISABLED，代表该Filter禁用，值为-2。
- 4、SUCCESS，代表该FAILED处理出现异常，值为-3。
当然，使用者也可以覆盖usageNotifier属性。接着我们看FilterProcessor中真正调用ZuulFilter实例的核心方法：
//指定Filter类型执行该类型下的所有ZuulFilter
public Object runFilters(String sType) throws Throwable {
//尝试打印Debug日志
if (RequestContext.getCurrentContext().debugRouting()) {
Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
}
boolean bResult = false;
//获取所有指定类型的ZuulFilter
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);
//如果处理结果是Boolean类型尝试做或操作，其他类型结果忽略
if (result != null && result instanceof Boolean) {
bResult |= ((Boolean) result);
}
}
}
return bResult;
}
//执行ZuulFilter，这个就是ZuulFilter执行逻辑
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();
}
//简单调用ZuulFilter的runFilter方法
ZuulFilterResult result = filter.runFilter();
ExecutionStatus s = result.getStatus();
execTime = System.currentTimeMillis() - ltime;
switch (s) {
case FAILED:
t = result.getException();
//记录调用链中当前Filter的名称，执行结果状态和执行时间
ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
break;
case SUCCESS:
o = result.getResult();
//记录调用链中当前Filter的名称，执行结果状态和执行时间
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);
//记录调用链中当前Filter的名称，执行结果状态和执行时间
ctx.addFilterExecutionSummary(filterName, ExecutionStatus.FAILED.name(), execTime);
throw ex;
}
}
}
上面介绍了FilterProcessor中的processZuulFilter(ZuulFilter filter)方法主要提供ZuulFilter执行的一些度量相关记录(例如Filter执行耗时摘要，会形成一个链，记录在一个字符串中)和ZuulFilter的执行方法，ZuulFilter执行结果可能是成功或者异常，前面提到过，如果抛出异常Throwable实例会保存在ZuulFilterResult中，在processZuulFilter(ZuulFilter filter)发现ZuulFilterResult中的Throwable实例不为null则直接抛出，否则返回ZuulFilter正常执行的结果。另外，FilterProcessor中通过指定Filter类型执行所有对应类型的ZuulFilter的runFilters(String sType)方法，我们知道了runFilters(String sType)方法如果处理结果是Boolean类型尝试做或操作，其他类型结果忽略，可以理解为此方法的返回值是没有很大意义的。参考SpringCloud里面对ZuulFilter的返回值处理一般是直接塞进去当前线程绑定的RequestContext中，选择特定的ZuulFilter子类对前面的ZuulFilter产生的结果进行处理。FilterProcessor基于runFilters(String sType)方法提供了其他指定filterType的方法：
public void postRoute() throws ZuulException {
try {
runFilters("post");
} catch (ZuulException e) {
throw e;
} catch (Throwable e) {
throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_POST_FILTER_" + e.getClass().getName());
}
}
public void preRoute() throws ZuulException {
try {
runFilters("pre");
} catch (ZuulException e) {
throw e;
} catch (Throwable e) {
throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_PRE_FILTER_" + e.getClass().getName());
}
}
public void error() {
try {
runFilters("error");
} catch (Throwable e) {
logger.error(e.getMessage(), e);
}
}
public void route() throws ZuulException {
try {
runFilters("route");
} catch (ZuulException e) {
throw e;
} catch (Throwable e) {
throw new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_IN_ROUTE_FILTER_" + e.getClass().getName());
}
}
上面提供的方法很简单，无法是指定参数为post、pre、error、route对runFilters(String sType)方法进行调用，至于这些FilterType的执行位置见下一个小节的分析。
ZuulServletFilter和ZuulServlet
Zuul本来就是设计为Servlet规范组件的一个类库，ZuulServlet就是javax.servlet.http.HttpServlet的实现类，而ZuulServletFilter是javax.servlet.Filter的实现类。这两个类都依赖到ZuulRunner完成ZuulFilter的调用，它们的实现逻辑是完全一致的，我们只需要看其中一个类的实现，这里挑选ZuulServlet：
public class ZuulServlet extends HttpServlet {
private static final long serialVersionUID = -3374242278843351500L;
private ZuulRunner zuulRunner;
@Override
public void init(ServletConfig config) throws ServletException {
super.init(config);
String bufferReqsStr = config.getInitParameter("buffer-requests");
boolean bufferReqs = bufferReqsStr != null && bufferReqsStr.equals("true") ? true : false;
zuulRunner = new ZuulRunner(bufferReqs);
}
@Override
public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
try {
//实际上委托到ZuulRunner的init方法
init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
//初始化RequestContext实例
RequestContext context = RequestContext.getCurrentContext();
//设置RequestContext中zuulEngineRan=true
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();
}
}
void postRoute() throws ZuulException {
zuulRunner.postRoute();
}
void route() throws ZuulException {
zuulRunner.route();
}
void preRoute() throws ZuulException {
zuulRunner.preRoute();
}
void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
zuulRunner.init(servletRequest, servletResponse);
}
//这里会先设置RequestContext实例中的throwable属性为执行抛出的Throwable实例
void error(ZuulException e) {
RequestContext.getCurrentContext().setThrowable(e);
zuulRunner.error();
}
}
ZuulServletFilter和ZuulServlet不相同的地方仅仅是初始化和处理方法的方法签名(参数列表和方法名)，其他逻辑甚至是代码是一模一样，使用过程中我们需要了解javax.servlet.http.HttpServlet和javax.servlet.Filter的作用去选择到底使用ZuulServletFilter还是ZuulServlet。上面的代码可以看到，ZuulServlet初始化的时候可以配置初始化布尔值参数buffer-requests，这个参数默认为false，它是ZuulRunner实例化的必须参数。ZuulServlet中的调用ZuulFilter的方法都委托到ZuulRunner实例去完成，但是我们可以从service(servletRequest, servletResponse)方法看出四种FilterType(pre、route、post、error)的ZuulFilter的执行顺序，总结如下：
- 1、pre、route、post都不抛出异常，顺序是：pre->route->post，error不执行。
- 2、pre抛出异常，顺序是：pre->error->post。
- 3、route抛出异常，顺序是：pre->route->error->post。
- 4、post抛出异常，顺序是：pre->route->post->error。
注意，一旦出现了异常，会把抛出的Throwable实例设置到绑定到当前请求线程的RequestContext实例中的throwable属性。还需要注意在service(servletRequest, servletResponse)的finally块中调用了RequestContext.getCurrentContext().unset();，实际上是从RequestContext的ThreadLocal实例中移除当前的RequestContext实例，这样做可以避免ThreadLocal使用不当导致内存泄漏。
接着看ZuulRunner的源码：
public class ZuulRunner {
private boolean bufferRequests;
public ZuulRunner() {
this.bufferRequests = true;
}
public ZuulRunner(boolean bufferRequests) {
this.bufferRequests = bufferRequests;
}
public void init(HttpServletRequest servletRequest, HttpServletResponse servletResponse) {
RequestContext ctx = RequestContext.getCurrentContext();
if (bufferRequests) {
ctx.setRequest(new HttpServletRequestWrapper(servletRequest));
} else {
ctx.setRequest(servletRequest);
}
ctx.setResponse(new HttpServletResponseWrapper(servletResponse));
}
public void postRoute() throws ZuulException {
FilterProcessor.getInstance().postRoute();
}
public void route() throws ZuulException {
FilterProcessor.getInstance().route();
}
public void preRoute() throws ZuulException {
FilterProcessor.getInstance().preRoute();
}
public void error() {
FilterProcessor.getInstance().error();
}
}
postRoute()、route()、preRoute()、error()都是直接委托到FilterProcessor中完成的，实际上就是执行对应类型的所有ZuulFilter实例。这里需要注意的是，初始化ZuulRunner时候，HttpServletResponse会被包装为com.netflix.zuul.http.HttpServletResponseWrapper实例，它是Zuul实现的javax.servlet.http.HttpServletResponseWrapper的子类，主要是添加了一个属性status用来记录Http状态码。如果初始化参数bufferRequests为true，HttpServletRequest会被包装为com.netflix.zuul.http.HttpServletRequestWrapper，它是Zuul实现的javax.servlet.http.HttpServletRequestWrapper的子类，这个包装类主要是把请求的表单参数和请求体都缓存在实例属性中，这样在一些特定场景中可以提高性能。如果没有特殊需要，这个参数bufferRequests一般设置为false。
Zuul简单的使用例子
我们做一个很简单的例子，场景是：对于每个POST请求，使用pre类型的ZuulFilter打印它的请求体，然后使用post类型的ZuulFilter，响应结果硬编码为字符串"Hello World!"。我们先为CounterFactory、TracerFactory添加两个空的子类，因为Zuul处理逻辑中依赖到这两个组件实现数据度量：
public class DefaultTracerFactory extends TracerFactory {
@Override
public Tracer startMicroTracer(String name) {
return null;
}
}
public class DefaultCounterFactory extends CounterFactory {
@Override
public void increment(String name) {
}
}
接着我们分别继承ZuulFilter，实现一个pre类型的用于打印请求参数的Filter，命名为PrintParameterZuulFilter，实现一个post类型的用于返回字符串"Hello World!"的Filter，命名为SendResponseZuulFilter：
public class PrintParameterZuulFilter extends ZuulFilter {
@Override
public String filterType() {
return "pre";
}
@Override
public int filterOrder() {
return 0;
}
@Override
public boolean shouldFilter() {
RequestContext context = RequestContext.getCurrentContext();
HttpServletRequest request = context.getRequest();
return "POST".equalsIgnoreCase(request.getMethod());
}
@Override
public Object run() throws ZuulException {
RequestContext context = RequestContext.getCurrentContext();
HttpServletRequest request = context.getRequest();
if (null != request.getContentType()) {
if (request.getContentType().contains("application/json")) {
try {
ServletInputStream inputStream = request.getInputStream();
String result = StreamUtils.copyToString(inputStream, Charset.forName("UTF-8"));
System.out.println(String.format("请求URI为:%s,请求参数为:%s", request.getRequestURI(), result));
} catch (IOException e) {
throw new ZuulException(e, 500, "从输入流中读取请求参数异常");
}
} else if (request.getContentType().contains("application/x-www-form-urlencoded")) {
StringBuilder params = new StringBuilder();
Enumeration<String> parameterNames = request.getParameterNames();
while (parameterNames.hasMoreElements()) {
String name = parameterNames.nextElement();
params.append(name).append("=").append(request.getParameter(name)).append("&");
}
String result = params.toString();
System.out.println(String.format("请求URI为:%s,请求参数为:%s", request.getRequestURI(),
result.substring(0, result.lastIndexOf("&"))));
}
}
return null;
}
}
public class SendResponseZuulFilter extends ZuulFilter {
@Override
public String filterType() {
return "post";
}
@Override
public int filterOrder() {
return 0;
}
@Override
public boolean shouldFilter() {
RequestContext context = RequestContext.getCurrentContext();
HttpServletRequest request = context.getRequest();
return "POST".equalsIgnoreCase(request.getMethod());
}
@Override
public Object run() throws ZuulException {
RequestContext context = RequestContext.getCurrentContext();
String output = "Hello World!";
try {
context.getResponse().getWriter().write(output);
} catch (IOException e) {
throw new ZuulException(e, 500, e.getMessage());
}
return true;
}
}
接着，我们引入嵌入式Tomcat，简单地创建一个Servlet容器，Maven依赖为：
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-core</artifactId>
<version>8.5.34</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<version>8.5.34</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jasper</artifactId>
<version>8.5.34</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jasper-el</artifactId>
<version>8.5.34</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-jsp-api</artifactId>
<version>8.5.34</version>
</dependency>
添加带main方法的类把上面的组件和Tomcat的组件组装起来：
public class ZuulMain {
private static final String WEBAPP_DIRECTORY = "src/main/webapp/";
private static final String ROOT_CONTEXT = "";
public static void main(String[] args) throws Exception {
Tomcat tomcat = new Tomcat();
File tempDir = File.createTempFile("tomcat" + ".", ".8080");
tempDir.delete();
tempDir.mkdir();
tempDir.deleteOnExit();
//创建临时目录,这一步必须先设置,如果不设置默认在当前的路径创建一个'tomcat.8080文件夹'
tomcat.setBaseDir(tempDir.getAbsolutePath());
tomcat.setPort(8080);
StandardContext ctx = (StandardContext) tomcat.addWebapp(ROOT_CONTEXT,
new File(WEBAPP_DIRECTORY).getAbsolutePath());
WebResourceRoot resources = new StandardRoot(ctx);
resources.addPreResources(new DirResourceSet(resources, "/WEB-INF/classes",
new File("target/classes").getAbsolutePath(), "/"));
ctx.setResources(resources);
ctx.setDefaultWebXml(new File("src/main/webapp/WEB-INF/web.xml").getAbsolutePath());
// FixBug: no global web.xml found
for (LifecycleListener ll : ctx.findLifecycleListeners()) {
if (ll instanceof ContextConfig) {
((ContextConfig) ll).setDefaultWebXml(ctx.getDefaultWebXml());
}
}
//这里添加两个度量父类的空实现
CounterFactory.initialize(new DefaultCounterFactory());
TracerFactory.initialize(new DefaultTracerFactory());
//这里添加自实现的ZuulFilter
FilterRegistry.instance().put("printParameterZuulFilter", new PrintParameterZuulFilter());
FilterRegistry.instance().put("sendResponseZuulFilter", new SendResponseZuulFilter());
//这里添加ZuulServlet
Context context = tomcat.addContext("/zuul", null);
Tomcat.addServlet(context, "zuul", new ZuulServlet());
//设置Servlet的路径
context.addServletMappingDecoded("/*", "zuul");
tomcat.start();
tomcat.getServer().await();
}
}
执行main方法，Tomcat正常启动后打印出熟悉的日志如下：
接下来，用POSTMAN请求模拟一下请求：
小结
Zuul虽然在它的Github仓库中的简介中说它是一个提供动态路由、监视、弹性、安全性等的网关框架，但是实际上它原生并没有提供这些功能，这些功能是需要使用者扩展ZuulFilter实现的，例如基于负载均衡的动态路由需要配置Netflix自己家的Ribbon实现。Zuul在设计上的扩展性什么良好，ZuulFilter就像插件一个可以通过类型、排序系数构建一个调用链，通过Filter或者Servlet做入口，嵌入到Servlet(Web)应用中。不过，在Zuul后续的版本如2.x和3.x中，引入了Netty，基于TCP做底层的扩展，但是编码和使用的复杂度大大提高。也许这就是SpringCloud在netflix-zuul组件中选用了zuul1.x的最后一个发布版本1.3.1的原因吧。springcloud-netflix中使用到Netflix的zuul(动态路由)、robbin(负载均衡)、eureka(服务注册与发现)、hystrix(熔断)等核心组件，这里立个flag先逐个组件分析其源码，逐个击破后再对springcloud-netflix做一次完整的源码分析。
(本文完 c-5-d)
技术公众号（《Throwable文摘》），不定期推送笔者原创技术文章（绝不抄袭或者转载）：
娱乐公众号（《天天沙雕》），甄选奇趣沙雕图文和视频不定期推送，缓解生活工作压力：
