Zuul请求处理流程

zuul框架在处理http请求时，由springmvc所管理，一起看下具体流程：

1. 请求由DispatchServlet分发，查找HandlerMapping，zuul框架定义了ZuulHandlerMapping，它是将路由规则绑定到了ZuulController上面；
2. 查找HandlerMappingAdapter映射器处理器，由SimpleControllerHandlerAdapter来处理ZuulController的请求；
3. SimpleControllerHandlerAdapter调用ZuulController的handleRequest方法处理请求，ZuulController中注册了ZuulServlet实例，调用ZuulServlet的service方法；
4. ZuulServlet中调用filter过滤器，做请求过滤，依次处理pre、route、post类型的filter（如果出现异常会由error级别filter捕获），ZuulController返回ModelAndView；
5. View视图为空，springmvc请求处理完成，交给web服务输出response响应。

Zuul核心组件

ZuulHandlerMapping

HandlerMapping的一个具体实现，spring程序启动时，将urlpath绑定到了对应的Handler（我们说的Controller）上。而在Zuul框架中，请求的urlpath会从Route路由表中加载，并绑定到ZuulController上。代码实现也比较简单，具体分析如下：

public class ZuulHandlerMapping extends AbstractUrlHandlerMapping {

	private final RouteLocator routeLocator;

	private final ZuulController zuul;

	private ErrorController errorController;

	private volatile boolean dirty = true;

	public ZuulHandlerMapping(RouteLocator routeLocator, ZuulController zuul) {
		this.routeLocator = routeLocator;
		this.zuul = zuul;
		setOrder(-200);
	}

	public void setErrorController(ErrorController errorController) {
		this.errorController = errorController;
	}

    //刷新路由
	public void setDirty(boolean dirty) {
		this.dirty = dirty;
		if (this.routeLocator instanceof RefreshableRouteLocator) {
			((RefreshableRouteLocator) this.routeLocator).refresh();
		}
	}

    //查找urlPath对应的handler处理器
	@Override
	protected Object lookupHandler(String urlPath, HttpServletRequest request)
			throws Exception {
		if (this.errorController != null
				&& urlPath.equals(this.errorController.getErrorPath())) {
			return null;
		}
		String[] ignored = this.routeLocator.getIgnoredPaths().toArray(new String[0]);
		if (PatternMatchUtils.simpleMatch(ignored, urlPath)) {
			return null;
		}
		RequestContext ctx = RequestContext.getCurrentContext();
		if (ctx.containsKey("forward.to")) {
			return null;
		}
		if (this.dirty) {
			synchronized (this) {
				if (this.dirty) {
					registerHandlers();
					this.dirty = false;
				}
			}
		}
        //spring启动时，将urlPath绑定到了HandlerMap上
		return super.lookupHandler(urlPath, request);
	}

    //将路由信息注册到ZuulController上
	private void registerHandlers() {
		Collection<Route> routes = this.routeLocator.getRoutes();
		if (routes.isEmpty()) {
			this.logger.warn("No routes found from RouteLocator");
		}
		else {
			for (Route route : routes) {
                //调用父类的注册方法
				registerHandler(route.getFullPath(), this.zuul);
			}
		}
	}

}

ZuulController

public class ZuulController extends ServletWrappingController {

	public ZuulController() {
          //设置servlet
          setServletClass(ZuulServlet.class);
          setServletName("zuul");
          setSupportedMethods((String[]) null); // Allow all
	}

	@Override
	protected ModelAndView handleRequestInternal(HttpServletRequest request,
			HttpServletResponse response) throws Exception {
		try {
			return super.handleRequestInternal(request, response);
		}
		finally {
			RequestContext.getCurrentContext().unset();
		}
	}

}

ZuulController调用父类的handleRequestInternal处理请求，转到父类中，我们看方法的具体实现：

@Override
protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response)throws Exception {
		this.servletInstance.service(request, response);
		return null;
	}

 这里调用serletInstance的实例就是ZuulServlet

ZuulServlet

应用程序启动时，会将实现了filter接口的自定义过滤器注册到FilterRegistry中。当ZuulServlet处理请求时，会把同一类型的filter放入List集合中处理，每个filter的处理顺序做了Collecitons.sort处理。ZuulServlet源码如下，可以看到zuul会先处理pre类型的filter，如果有异常会被error类型filter捕获掉，然后是route类型filter，最后是post类型filter。

@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 {
            //threadlocal移除
            RequestContext.getCurrentContext().unset();
        }
    }

动态路由实现

    Zuul框架默认是从配置文件中加载路由规则的，但是很显然这种方式无法满足我们项目生产中的使用。我们更希望能从数据库中加载配置，当有新的服务加进来时，可以直接操作db就将新的路由规则生效，而无需重启网关服务。

路由加载

  自定义路由加载核心是重写locateRoutes方法，把路由信息从db加载中加载，实现源码如下：

public class CustomRouteLocator extends SimpleRouteLocator implements RefreshableRouteLocator {

	Logger logger = LoggerFactory.getLogger(CustomRouteLocator.class);

	ZuulProperties properties;
	@Autowired
	GatewayMapper gatewayMapper;

	/**
	 * @param servletPath
	 * @param properties
	 */
	public CustomRouteLocator(String servletPath, ZuulProperties properties) {
		super(servletPath, properties);
		this.properties = properties;
	}

	@Override
	public void refresh() {
		doRefresh();
	}

	@Override
	protected Map<String, ZuulRoute> locateRoutes() {
		LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap<String, ZuulRoute>();
		//从配置文件中加载路由配置
		routesMap.putAll(super.locateRoutes());
		routesMap.putAll(locateRoutesFromDB());
		//优化一下配置
		LinkedHashMap<String, ZuulRoute> values = new LinkedHashMap<>();
		for (Map.Entry<String, ZuulRoute> entry : routesMap.entrySet()) {
			String path = entry.getKey();
			// Prepend with slash if not already present.
			if (!path.startsWith("/")) {
				path = "/" + path;
			}
			if (StringUtils.hasText(this.properties.getPrefix())) {
				path = this.properties.getPrefix() + path;
				if (!path.startsWith("/")) {
					path = "/" + path;
				}
			}
			values.put(path, entry.getValue());
		}
		return values;
	}

    //从db中加载路由信息，此处是动态路由实现的核心
	private Map<String, ZuulRoute> locateRoutesFromDB() {
		LinkedHashMap<String, ZuulRoute> routesMap = new LinkedHashMap<String, ZuulRoute>();
		List<ZuulRouteDO> results = gatewayMapper.getZuulRouteDOList();
		for (ZuulRouteDO result : results) {
			if (StringUtils.isEmpty(result.getPath()) || StringUtils.isEmpty(result.getUrl())) {
				continue;
			}
			ZuulRoute zuulRoute = new ZuulRoute();
			try {
				BeanUtils.copyProperties(result, zuulRoute);
			} catch (Exception e) {
				logger.error("locateRoutesFromDB Exception:{}", e);
			}
			routesMap.put(zuulRoute.getPath(), zuulRoute);
		}
		return routesMap;
	}
}

路由刷新

路由刷新是基于Spring事件机制，RoutesRefreshedEvent定义事件内容，ZuulDiscoveryRefreshListener接收事件变化，执行路由刷新。

private static class ZuulDiscoveryRefreshListener implements ApplicationListener<ApplicationEvent> {

	private HeartbeatMonitor monitor = new HeartbeatMonitor();

	@Autowired
	private ZuulHandlerMapping zuulHandlerMapping;

	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		if (event instanceof InstanceRegisteredEvent) {
			reset();
		}
		else if (event instanceof ParentHeartbeatEvent) {
			ParentHeartbeatEvent e = (ParentHeartbeatEvent) event;
			resetIfNeeded(e.getValue());
		}
		else if (event instanceof HeartbeatEvent) {
			HeartbeatEvent e = (HeartbeatEvent) event;
			resetIfNeeded(e.getValue());
		}

	}

	private void resetIfNeeded(Object value) {
		if (this.monitor.update(value)) {
			reset();
		}
	}

	private void reset() {
	  //setDirty为true时，会执行刷新路由操作
	  this.zuulHandlerMapping.setDirty(true);
	}

}

//路由刷新
public void setDirty(boolean dirty) {
	this.dirty = dirty;
	if (this.routeLocator instanceof RefreshableRouteLocator) {
		((RefreshableRouteLocator) this.routeLocator).refresh();
	}
}