Zuul源码分析

目标

明确Zuul的执行流程和重要类的分析

Zuul过滤器的生命周期

zuul.jpg

源码分析

zuul怎么拦截我们的请求？

ZuulServletFilter - 继承 Filter | ZuulServlet - 继承 HttpServlet
可以通过这两个类，让Zuul接管请求。由于他们的逻辑基本一致，下面用ZuulServletFilter来分析

/**
* Zuul核心处理类，拦截请求
**/
public class ZuulServletFilter implements Filter {

    private ZuulRunner zuulRunner;

        // 省略...

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        try {
                // 初始化requests和responses到RequestContext中，详见ZuulRunner#init
            init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
            try {
                // 执行 filterType=pre 的过滤器
                preRouting();
            } catch (ZuulException e) {
                // 执行 filterType=error 的过滤器
                error(e);
                postRouting();
                return;
            }
            
            // Only forward onto to the chain if a zuul response is not being sent
            if (!RequestContext.getCurrentContext().sendZuulResponse()) {
                filterChain.doFilter(servletRequest, servletResponse);
                return;
            }
            
            try {
                  // 执行 filterType=route 的过滤器
                routing();
            } catch (ZuulException e) {
                error(e);
                postRouting();
                return;
            }
            try {
                // 执行 filterType=post 的过滤器
                postRouting();
            } catch (ZuulException e) {
                error(e);
                return;
            }
        } catch (Throwable e) {
            error(new ZuulException(e, 500, "UNCAUGHT_EXCEPTION_FROM_FILTER_" + e.getClass().getName()));
        } finally {
            // 清空线程变量
            RequestContext.getCurrentContext().unset();
        }
    }
}

以上方法核心步骤：

• 初始化请求上下文RequestContext

• 执行 pre、route、post过滤器，如果有错，执行error过滤器

ZuulRunner - 初始化RequestContext中的requests和responses并转发Filter相关方法到FilterProcessor

public class ZuulRunner {

    private boolean bufferRequests;

    // 省略...

    /**
     * 初始化RequestContext：生成请求和响应wapper保存
     * RequestContext：继承了ConcurrentHashMap，是一个Map容器，主要存放请求、响应供ZuulFilters使用。
     */
    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));
    }

    /**
     * executes "post" filterType  ZuulFilters
     *
     * @throws ZuulException
     */
    public void postRoute() throws ZuulException {
        FilterProcessor.getInstance().postRoute();
    }

   // 省略route() preRoute() error() 方法
}   

以上看出Zuul是通过ZuulServletFilter以filter的方式（或者以ZuulServlet以servlet的方式）拦截或者承接我们的请求，并在doFilter方法（service方法）中处理各种类型的ZuulFilters，并通过ZuulRunner转发到FilterProcessor中找到对应的filter并执行相关逻辑。整个大致流程比较简单清晰，类似于设计模式中的门面模式。

​ 其中，RequestContext是存在ThreadLocal当中，可以注意到当Zuul处理完毕之后，会清空线程变量RequestContext,以防止内存泄露。

FilterProcessor怎么找到相应ZuulFilters并执行呢？

FilterProcessor - 执行filters的核心类

/**
* 执行对应阶段ZuulFilters
* sType：即为filterType，例如"post"、"pre"、"route"、"error"
* 
*/
public Object runFilters(String sType) throws Throwable {
        if (RequestContext.getCurrentContext().debugRouting()) {
            Debug.addRoutingDebug("Invoking {" + sType + "} type filters");
        }
        boolean bResult = false;
              // 获取已经注册了的ZuulFilters，根本是从FilterRegistry中获取。并且list是已经排好序的，
            // 根据给定的filterOrder
        List list = FilterLoader.getInstance().getFiltersByType(sType);
        if (list != null) {
            for (int i = 0; i < list.size(); i++) {
                ZuulFilter zuulFilter = list.get(i);
                // 执行ZuulFilter逻辑并
                Object result = processZuulFilter(zuulFilter);
                if (result != null && result instanceof Boolean) {
                    bResult |= ((Boolean) result);
                }
            }
        }
        return bResult;
    }

/**
* 执行ZuulFilter，并把执行情况组合成ZuulFilterResult并返回
*/
public Object processZuulFilter(ZuulFilter filter) throws ZuulException {
  // 省略部分代码...
  // 具体执行在 ZuulFilter#runFilter
  ZuulFilterResult result = filter.runFilter();
  ExecutionStatus s = result.getStatus();

  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);
    default:
      break;
  }
            
  if (t != null) throw t;

  // 统计每个filter的每次执行情况
  usageNotifier.notify(filter, s);
  return o;
}

以上方法核心步骤：

• 按序执行各阶段ZuulFilters

• 记录ZuulFilter执行结果

• 统计执行情况

ZuulFilter - 最基本的Filter抽象类，自定义的Filter是继承此Filter，FilterProcessor执行Filter最终会转发到此类的runFilter方法

 public ZuulFilterResult runFilter() {
   // 执行结果以及执行成功与否情况包装成ZuulFilterResult返回
   ZuulFilterResult zr = new ZuulFilterResult();
   // 此filter是已被archaius禁用 「archaius是netflix开源的动态属性配置框架」
   if (!isFilterDisabled()) {
     // 执行自定filter的shouldFilter方法判断是否执行此filter
     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;
 }

Zuul把ZuulFilters存储在类FilterLoader属性名为hashFiltersByType的ConcurrentHashMap中，key为filterType(eg: pre、route、post、error或者自定义)

那么问题来了，这些存在于FilterLoader的ZuulFilter是怎么加载进来的呢？

ZuulFIlter的加载

通过层层搜索，找到类FilterFileManager ，在此类初始化的时候，会到指定路径下读取指定文件。同时在初始时，会创建守护线程来定时扫描加载文件。

public class FilterFileManager {
  // 省略代码...

  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();
  }
  
  void manageFiles() throws Exception, IllegalAccessException, InstantiationException {
        // 读取文件
                List aFiles = getFiles();
            // 通过FilterLoader来处理文件
        processGroovyFiles(aFiles);
    }
  
  // 扫描指定目录下的指定类型文件
  List getFiles() {
    List list = new ArrayList();
    for (String sDirectory : aDirectories) {
      if (sDirectory != null) {
        File directory = getDirectory(sDirectory);
        // Zuul有自带类`GroovyFileFilter`是扫描 .groovy 文件.
        File[] aFiles = directory.listFiles(FILENAME_FILTER);
        if (aFiles != null) {
          list.addAll(Arrays.asList(aFiles));
        }
      }
    }
    return list;
  }
  
  // 开启守护线程进行轮询
  void startPoller() {
    poller = new Thread("GroovyFilterFileManagerPoller") {
      public void run() {
        while (bRunning) {
          try {
            sleep(pollingIntervalSeconds * 1000);
            manageFiles();
          } catch (Exception e) {
            e.printStackTrace();
          }
        }
      }
    };
    poller.setDaemon(true);
    poller.start();
  }
  
}

public class FilterLoader {
  
  // 处理文件
  public boolean putFilter(File file) throws Exception {
    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) {
      // 编译文件 - zuul自带GroovyCompiler编译groovy编写的文件
      Class clazz = COMPILER.compile(file);
      // 如果不是抽象类即ZuulFilter，则进行实例化并放入内存
      if (!Modifier.isAbstract(clazz.getModifiers())) {
        filter = (ZuulFilter) FILTER_FACTORY.newInstance(clazz);
        List list = hashFiltersByType.get(filter.filterType());
        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;
  } 
}

以上两个类核心步骤 即为 FilterFileManager初始化过程

• 扫描指定目录下的groovy文件，通过FilterLoader编译文件，并加载ZuulFilter
• 开启守护进程，轮询文件，动态加载ZuulFilter

总结

• Zuul的源码执行路径：

Zuul源码执行流程

• ZuulFilter的加载方式：是通过扫描.groovy文件来加载，并支持动态加载，具体可以看官方示例zuul-simple-webapp

• Zuul的整个流程，是基于servlet或filter方式在service或doFilter方法中衔接请求，并运用类似门面模式编写

​ 至此，Zuulfilter的加载以及各类型Filter的执行都在源码中找到了。zuul-core的代码还是很容易能看懂。下一篇，会分析SpringCloud怎么整合Zuul。