Zuul 是在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和 Netflix 流应用的 Web 网站后端所有请求的前门。Zuul 可以适当的对多个 Amazon Auto Scaling Groups 进行路由请求。
其架构如下图所示：
Zuul提供了一个框架，可以对过滤器进行动态的加载，编译，运行。过滤器之间没有直接的相互通信。他们是通过一个RequestContext的静态类来进行数据传递的。RequestContext类中有ThreadLocal变量来记录每个Request所需要传递的数据。
过滤器是由Groovy写成。这些过滤器文件被放在Zuul Server上的特定目录下面。Zuul会定期轮询这些目录。修改过的过滤器会动态的加载到Zuul Server中以便于request使用。
客户定制：比如我们可以定制一种STATIC类型的过滤器，用来模拟生成返回给客户的response。
过滤器的生命周期如下所示：
就像上图中所描述的一样，Zuul 提供了四种过滤器的 API，分别为前置（Pre）、后置（Post）、路由（Route）和错误（Error）四种处理方式。
一个请求会先按顺序通过所有的前置过滤器，之后在路由过滤器中转发给后端应用，得到响应后又会通过所有的后置过滤器，最后响应给客户端。在整个流程中如果发生了异常则会跳转到错误过滤器中。
一般来说，如果需要在请求到达后端应用前就进行处理的话，会选择前置过滤器，例如鉴权、请求转发、增加请求参数等行为。在请求完成后需要处理的操作放在后置过滤器中完成，例如统计返回值和调用时间、记录日志、增加跨域头等行为。路由过滤器一般只需要选择 Zuul 中内置的即可，错误过滤器一般只需要一个，这样可以在 Gateway 遇到错误逻辑时直接抛出异常中断流程，并直接统一处理返回结果。
Zuul可以通过加载动态过滤机制，从而实现以下各项功能：
验证与安全保障: 识别面向各类资源的验证要求并拒绝那些与要求不符的请求。
审查与监控: 在边缘位置追踪有意义数据及统计结果，从而为我们带来准确的生产状态结论。
动态路由: 以动态方式根据需要将请求路由至不同后端集群处。
压力测试: 逐渐增加指向集群的负载流量，从而计算性能水平。
负载分配: 为每一种负载类型分配对应容量，并弃用超出限定值的请求。
静态响应处理: 在边缘位置直接建立部分响应，从而避免其流入内部集群。
多区域弹性: 跨越AWS区域进行请求路由，旨在实现ELB使用多样化并保证边缘位置与使用者尽可能接近。
除此之外，Netflix公司还利用Zuul的功能通过金丝雀版本实现精确路由与压力测试。
Ribbon客户端默认选择静态类HttpClientRibbonConfiguration创建的HttpClientRibbonCommandFactory工厂类创建，HTTP Client客户端选择HttpClientConfiguration中静态类ApacheHttpClientConfiguration创建Apache相关客户端。
候选类ZuulProxyAutoConfiguration初始化RestClientRibbonConfiguration、OkHttpRibbonConfiguration、HttpClientRibbonConfiguration以及RibbonRoutingFilter、SimpleHostRoutingFilter。
RibbonCommandFactoryConfiguration:设置Ribbon相关属性。
ZuulServerAutoConfiguration：初始化ZuulController、ZuulHandlerMapping、CompositeRouteLocator、SimpleRouteLocator。
Zuul提供了两种形式的网关服务：微服务【服务治理】方式 & http协议方式。
1.http协议方式提供网关功能
public class ZuulProxyAutoConfiguration extends ZuulServerAutoConfiguration {
@Autowired
private DiscoveryClient discovery;
@Bean
@ConditionalOnMissingBean(DiscoveryClientRouteLocator.class)
public DiscoveryClientRouteLocator discoveryRouteLocator() {
String prefix = this.server.getServlet().getServletPrefix()
return new DiscoveryClientRouteLocator(prefix, this.discovery, this.zuulProperties,
this.serviceRouteMapper, this.registration);
}
}
public class ZuulServerAutoConfiguration {
@Autowired
protected ZuulProperties zuulProperties;
@Bean
@Primary
public CompositeRouteLocator primaryRouteLocator(Collection<RouteLocator> routeLocators) {
//routeLocators：DiscoveryClientRouteLocator
return new CompositeRouteLocator(routeLocators);
}
}1.1.ZuulProperties
ZuulProperties：负责加载zuul相关的路由属性。
zuul.routes.blog.path=/blog/**
zuul.routes.blog.serviceId=http://mp-admin-blog.csdn.net@ConfigurationProperties("zuul")
public class ZuulProperties {
private String prefix = "";
// 集合routes中key表示 服务名 或者 域名
private Map<String, ZuulRoute> routes = new LinkedHashMap<>();
private Set<String> ignoredServices = new LinkedHashSet<>();
private Set<String> ignoredPatterns = new LinkedHashSet<>();
private Host host = new Host();//设置http连接相关属性，如超时相关属性
public static class ZuulRoute {
//zuul.routes.blog.path=/blog/** ,其中id 即为blog
private String id;
private String path;
private String serviceId;
private String url;
private boolean stripPrefix = true;
private Boolean retryable;
private Set<String> sensitiveHeaders = new LinkedHashSet<>();
private boolean customSensitiveHeaders = false;
}
}1.2.ZuulHandlerMapping 的初始化
ZuulHandlerMapping通过Order控制其所有接口HandlerMapping实现类中优先级最高。
public class ZuulHandlerMapping extends AbstractUrlHandlerMapping {
private final RouteLocator routeLocator;
private final ZuulController zuul;
public ZuulHandlerMapping(RouteLocator routeLocator, ZuulController zuul) {
this.routeLocator = routeLocator;//CompositeRouteLocator
this.zuul = zuul;
setOrder(-200);
}
}
截此为止服务启动过程中完成 ZuulHandlerMapping 持有路由相关属性。
1.3.ZuulHandlerMapping执行路由匹配请求
当SpringMVC处理请求时，由于在众多HandlerMapping实现类中ZuulHandlerMapping优先级是最高的，所以任何请求ZuulHandlerMapping优先处理。如果ZuulHandlerMapping通过request uri可以得到目标handler，即ZuulController，则后续请求流程由当前ZuulHandlerMapping触发完成，否则RequestMappingHandlerMapping完成。那ZuulHandlerMapping是如何匹配到ZuulController呢？
public class ZuulHandlerMapping extends AbstractUrlHandlerMapping {
private final RouteLocator routeLocator;
private final ZuulController zuul;
private volatile boolean dirty = true;
@Override
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
if (this.errorController != null && urlPath.equals(this.errorController.getErrorPath())) {
return null;
}
// 集合 IgnoredPaths 是否包含 当前路径 urlPath
if (isIgnoredPath(urlPath, this.routeLocator.getIgnoredPaths())) return null;
RequestContext ctx = RequestContext.getCurrentContext();
if (ctx.containsKey("forward.to")) {
return null;
}
if (this.dirty) {
synchronized (this) {
if (this.dirty) {
// 将 ZuulProperties 配置的所有路由path信息 与 ZuulController建立绑定关系， 添加至 HandlerMapping抽象类
registerHandlers();
this.dirty = false;
}
}
}
// SpringMVC 正常相关逻辑
return super.lookupHandler(urlPath, request);
}
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) {
// 最后将fullPath & ZuulController对应关系添加到抽象类AbstractUrlHandlerMapping属性handlerMap中
registerHandler(route.getFullPath(), this.zuul);
}
}
}
}
urlPath【当前请求对应的uri】如果命中集合 IgnoredPaths 中元素，表明当前请求是被ZuulFilter所忽略，返回null即意味着当前请求继续被RequestMappingHandlerMapping处理。
lookupHandler：利用urlPath正则匹配【Ant模式】抽象类AbstractUrlHandlerMapping属性handlerMap中元素，如果匹配通过则返回handler之ZuulController。
属性dirty的重要性：提前建立ZuulRoute 与 ZuulController之间的对应关系。
1.3.1.dirty属性
抽象类AbstractUrlHandlerMapping存在Map类型的属性之handlerMap。属性元素key为fullPath，value为ZuulController。当务之急就是将类ZuulRoute中属性转化为类Route相关属性。
public Route(String id, String path, String location, String prefix,
Boolean retryable, Set<String> ignoredHeaders, boolean prefixStripped) {
this(id, path, location, prefix, retryable, ignoredHeaders);
this.prefixStripped = prefixStripped;
}- path：请求下游服务真实URI路径。
- location： 优先获取ZuulRoute中URL属性，否则选择path属性。
- prefix：ZuulProperties中prefix属性。
- prefixStripped：ZuulRoute中属性stripPrefix，默认为true。
- fullPath：prefix + path。
- ZuulRoute & ZuulProperties均存在属性stripPrefix，表示是否对path进行截取，最终目的是得到path。
public class CompositeRouteLocator{
private final Collection<? extends RouteLocator> routeLocators;
@Override
public List<Route> getRoutes() {
List<Route> route = new ArrayList<>();
// 通常情况下 集合routeLocators 中元素只有 DiscoveryClientRouteLocator
for (RouteLocator locator : routeLocators) {
route.addAll(locator.getRoutes());
}
return route;
}
}
public class SimpleRouteLocator{
@Override
public List<Route> getRoutes() {
List<Route> values = new ArrayList<>();
// ZuulRoute元素其实即为ZuulProperties映射的配置属性
for (Entry<String, ZuulRoute> entry : getRoutesMap().entrySet()) {
ZuulRoute route = entry.getValue();
String path = route.getPath();
values.add(getRoute(route, path));
}
return values;
}
protected Route getRoute(ZuulRoute route, String path) {
if (route == null) {
return null;
}
String targetPath = path;
//首先判断ZuulProperties中属性 zuul.prefix 是否存在值
String prefix = this.properties.getPrefix();
if(prefix.endsWith("/")) {//去掉前缀值中存在的后斜杠
prefix = prefix.substring(0, prefix.length() - 1);
}
if (path.startsWith(prefix + "/") && this.properties.isStripPrefix()) {
targetPath = path.substring(prefix.length());//将path中prefix截掉
}
if (route.isStripPrefix()) {
// 获取首个字符 * 的索引index
int index = route.getPath().indexOf("*") - 1;
if (index > 0) {
// 获取path中首个字符 * 之前的全部字符
String routePrefix = route.getPath().substring(0, index);
//将 routePrefix 字符串 全部替换为 空字符串
targetPath = targetPath.replaceFirst(routePrefix, "");
// 重新在 routePrefix 之前拼接 prefix。
// 如果 prefix = admin, path = admin/like/**, 则此时 prefix 为 admin/admin/like
prefix = prefix + routePrefix;
}
}
Boolean retryable = this.properties.getRetryable();
if (route.getRetryable() != null) {
retryable = route.getRetryable();
}
return new Route(route.getId(), targetPath, route.getLocation(), prefix,
retryable,
route.isCustomSensitiveHeaders() ? route.getSensitiveHeaders() : null,
route.isStripPrefix());
}
}通过dirty属性提前在handlerMap建立ZuulRoute 与 ZuulController之间的对应关系，下一步就需要通过请求URL从handlerMap获取对应的ZuulController。
以上完成请求地址的路由匹配。
1.4.ZuulController执行过滤器ZuulFilter
- 通过ZuulServlet触发过滤器流程的开始。毕竟过滤器属于Servlet的范畴。
- 由ZuulRunner引申出FilterProcessor，FilterProcessor控制pre、route、post三类过滤器先后执行顺序。
- FilterProcessor加载出不同类型的全部过滤器，并依次执行全部的过滤器。
- 过滤器真正执行逻辑是由抽象类ZuulFilter定义的。
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return (handler instanceof Controller);
}
@Override
@Nullable
public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler){
return ((Controller) handler).handleRequest(request, response);
}
ZuulController匹配的adapter为SimpleControllerHandlerAdapter。
public class ZuulController extends ServletWrappingController {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
return super.handleRequestInternal(request, response);
}
}public class ServletWrappingController extends AbstractController{
private Servlet servletInstance;//ZuulServlet
protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response){
this.servletInstance.service(request, response);
return null;
}
}由ZuulServlet真正触发过滤器的执行流程。
public class ZuulServlet extends HttpServlet {
public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
RequestContext context = RequestContext.getCurrentContext();
context.setZuulEngineRan();
try {
preRoute();//前置路由
route();// 路由
postRoute();// 后置路由
} catch (ZuulException e) {
postRoute();
return;
}
}
}public class ZuulServlet extends HttpServlet {
private ZuulRunner zuulRunner;
public void service(javax.servlet.ServletRequest servletRequest, javax.servlet.ServletResponse servletResponse) throws ServletException, IOException {
init((HttpServletRequest) servletRequest, (HttpServletResponse) servletResponse);
RequestContext context = RequestContext.getCurrentContext();
context.setZuulEngineRan();
try {
preRoute();//前置路由
route();// 路由
postRoute();// 后置路由
} catch (ZuulException e) {
postRoute();
return;
}
}
void postRoute() throws ZuulException {
zuulRunner.postRoute();
}
void route() throws ZuulException {
zuulRunner.route();
}
void preRoute() throws ZuulException {
zuulRunner.preRoute();
}
}public class ZuulRunner {
public void postRoute() throws ZuulException {
FilterProcessor.getInstance().postRoute();
}
public void route() throws ZuulException {
//FilterProcessor#
FilterProcessor.getInstance().route();
}
public void preRoute() throws ZuulException {
FilterProcessor.getInstance().preRoute();
}
}public class FilterProcessor {
public void postRoute() throws ZuulException {
runFilters("post");
}
public void route() throws ZuulException {
runFilters("route");
}
public void preRoute() throws ZuulException {
runFilters("pre");
}
public Object runFilters(String sType) {// 所有网关涉及的全部过滤器必经路径
boolean bResult = false;
//获取当前类型【pre 、post、route】的全部过滤器
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);
}
}
}
//pre 、post、route返回值没有任何意义
return bResult;
}
public Object processZuulFilter(ZuulFilter filter) throws ZuulException {
RequestContext ctx = RequestContext.getCurrentContext();
String filterName = "";
RequestContext copy = null;
Object o = null;
Throwable t = null;
// 执行全部过滤器的父类过滤器
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);
break;
default:
break;
}
if (t != null) throw t;
usageNotifier.notify(filter, s);
return o;
}
}前置过滤器包含：ServletDetectionFilter、Servlet30WrapperFilter、FormBodyWrapperFilter、DebugFilter、PreDecorationFilter。
PreDecorationFilter主要是设置一些代理东西，不常用
对于route类型的过滤器存在三种默认的过滤器： RibbonRoutingFilter、SimpleHostRoutingFilter、SendForwardFilter【重定向相关拦截处理】。
后置过滤器：SendResponseFilter。
1.4.1.ZuulFilter
以下是每个类型的过滤器都会执行的必经逻辑：
- 首先执行shoulderFilter。
- 其次执行真正的核心流程run。
核心方法run任何返回值类型都按success处理；只有出现异常则按失败处理，即过滤器直接抛出异常。
public abstract class ZuulFilter{
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) {// 只有核心方法run 出现异常，才会终止请求流程
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;
}
}1.5.调用下游downstream服务
对于route类型的过滤器，自定义的过滤器的优先级远高于自带三种过滤器。如果需要触发下游服务继续调用，目前只有RibbonRoutingFilter、SimpleHostRoutingFilter两种过滤器支持。其中，RibbonRoutingFilter是通过微服务（服务治理）方式实现，SimpleHostRoutingFilter则是通过http方式调用下游服务。
RibbonRoutingFilter、SimpleHostRoutingFilter、SendResponseFilter过滤器生效的共同条件是：RequestContext之sendZuulResponse属性必须为true。意味着在自定义过滤器内部如果允许下游服务继续访问，必须显式设置sendZuulResponse的属性值。
1.5.1.RibbonRoutingFilter
public class RibbonRoutingFilter extends ZuulFilter {
@Override
public boolean shouldFilter() {
RequestContext ctx = RequestContext.getCurrentContext();
return (ctx.getRouteHost() == null && ctx.get("serviceId") != null
&& ctx.sendZuulResponse());
}
}1.5.2.SimpleHostRoutingFilter
public class SimpleHostRoutingFilter extends ZuulFilter {
@Override
public boolean shouldFilter() {
return RequestContext.getCurrentContext().getRouteHost() != null && RequestContext.getCurrentContext().sendZuulResponse();
}
public Object run() {
RequestContext context = RequestContext.getCurrentContext();
...
String uri = this.helper.buildZuulRequestURI(request);
this.helper.addIgnoredHeaders();
// 通过http方式调用下游服务
CloseableHttpResponse response = forward(this.httpClient, verb, uri, request,headers, params, requestEntity);
setResponse(response);
return null;
}
private void setResponse(HttpResponse response) throws IOException {
// 将下游服务的响应封装在 上下文 属性zuulResponse中
RequestContext.getCurrentContext().set("zuulResponse", response);
// 将下游服务的响应头、响应实体等信息 单独添加至 上下文中
this.helper.setResponse(response.getStatusLine().getStatusCode(),
response.getEntity() == null ? null : response.getEntity().getContent(),
revertHeaders(response.getAllHeaders()));
}
}触发下游服务 & 将下游服务响应的相关属性跟上下文RequestContext绑定。
1.5.3.SendResponseFilter
通过以下得知，该过滤器整合下游服务响应内容的前提是RibbonRoutingFilter or SimpleHostRoutingFilter 至少有一个生效。
public class SendResponseFilter extends ZuulFilter {
@Override
public boolean shouldFilter() {
RequestContext context = RequestContext.getCurrentContext();
return context.getThrowable() == null
&& (!context.getZuulResponseHeaders().isEmpty()// 下游服务的响应头必须被添加至上下文ZuulResponseHeaders属性中
// 此处是指下游服务的响应不能为空
|| context.getResponseDataStream() != null
|| context.getResponseBody() != null);
}
@Override
public Object run() {
addResponseHeaders();
writeResponse();
return null;
}
private void writeResponse() throws Exception {
RequestContext context = RequestContext.getCurrentContext();
if (context.getResponseBody() == null && context.getResponseDataStream() == null) {
return;
}
HttpServletResponse servletResponse = context.getResponse();
if (servletResponse.getCharacterEncoding() == null) { // only set if not set
servletResponse.setCharacterEncoding("UTF-8");
}
//此处是指在自定义过滤器中添加的响应信息
OutputStream outStream = servletResponse.getOutputStream();
InputStream is = null;
if (context.getResponseBody() != null) {// 如果在自定义过滤器中添加了ResponseBody，则下游服务的响应不会被添加到最终响应值中
String body = context.getResponseBody();
is = new ByteArrayInputStream(body.getBytes(servletResponse.getCharacterEncoding()));
}else {
is = context.getResponseDataStream();// 获取下游服务的响应值
if (is!=null && context.getResponseGZipped()) {// 下游服务是否需要压缩
if (isGzipRequested(context)) {
servletResponse.setHeader(ZuulHeaders.CONTENT_ENCODING, "gzip");
}else {
is = handleGzipStream(is);
}
}
}
if (is!=null) {
// 将下游服务的响应is写到 outStream中，即为最终响应内容
writeResponse(is, outStream);
}
...
}
}自定义过滤器内部如果存在通过字符流Writer写入数据，则在SendResponseFilter内部抛出异常：getWriter() has already been called for this response，但是不会打印出堆栈信息，该异常非常隐蔽。自定义过滤器内部可以选择字节流方式写入数据。
记 SpringBoot 拦截器报错 getWriter() has already been called for this response
![[大模型]Qwen2-7B-Instruct 接入 LangChain 搭建知识库助手](https://img-blog.csdnimg.cn/direct/35a9895a6529488ba6e1ae90cd568f55.png#pic_center)
