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

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

前提

最近在项目中使用了SpringCloud,基于Zuul搭建了一个提供加解密、鉴权等功能的网关服务。鉴于之前没怎么使用过Zuul,于是顺便仔细阅读了它的源码。实际上,Zuul原来提供的功能是很单一的:通过一个统一的Servlet入口(ZuulServlet,或者Filter入口,使用ZuulServletFilter)拦截所有的请求,然后通过内建的com.netflix.zuul.IZuulFilter链对请求做拦截和过滤处理。ZuulFilterjavax.servlet.Filter的原理相似,但是它们本质并不相同。javax.servlet.Filter在Web应用中是独立的组件,ZuulFilterZuulServlet处理请求时候调用的,后面会详细分析。

源码环境准备

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。

z-s-c-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构建成功后如下:

z-s-c-2

zuul-1.3.1中提供了一个Web应用的Sample项目,我们直接运行zuul-simple-webapp的Gradle配置中的Tomcat插件即可启动项目,开始Debug之旅:

z-s-c-3

源码分析

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类型执行所有对应类型的ZuulFilterrunFilters(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、routerunFilters(String sType)方法进行调用,至于这些FilterType的执行位置见下一个小节的分析。

ZuulServletFilter和ZuulServlet

Zuul本来就是设计为Servlet规范组件的一个类库,ZuulServlet就是javax.servlet.http.HttpServlet的实现类,而ZuulServletFilterjavax.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();
}
}

ZuulServletFilterZuulServlet不相同的地方仅仅是初始化和处理方法的方法签名(参数列表和方法名),其他逻辑甚至是代码是一模一样,使用过程中我们需要了解javax.servlet.http.HttpServletjavax.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();,实际上是从RequestContextThreadLocal实例中移除当前的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正常启动后打印出熟悉的日志如下:

z-s-c-4

接下来,用POSTMAN请求模拟一下请求:

z-s-c-5

小结

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 r-a-20190310 最近996,不能经常更新,顺便祝自己生日快乐…)

文章作者: throwable
文章链接: http://www.throwable.club/2019/03/14/java-netflix-zuul-implementation/
版权声明: 本博客所有文章除特别声明外,均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 Throwable
❤支付宝打赏❤
❤微信打赏❤