淺談服務閘道器和聯邦雲

Zuul is implemented as a Servlet. For the general cases, Zuul is embedded into the 
Spring Dispatch mechanism. This lets Spring MVC be in control of the routing. 
In this case, Zuul buffers requests. 
If there is a need to go through Zuul without buffering requests (for example, for large file uploads), 
the Servlet is also installed outside of the Spring Dispatcher. 
By default, the servlet has an address of /zuul. This path can be changed 
with the zuul.servlet-path property.
來自官方文件

/**
 * Servlet Path是URI路中的一部分。它以 / 開頭，並指向某個Servlet的名字
 * <p>
 * 如果目標Servlet使用了萬用字元 /*， 這個方法應當返回空字串
 */
public String getServletPath();
/**
  HttpServletMapping 也是提供了非常靈活的Servlet匹配策略
    <servlet>
       <servlet-name>MyServlet</servlet-name>
       <servlet-class>MyServlet</servlet-class>
   </servlet>
   <servlet-mapping>
       <servlet-name>MyServlet</servlet-name>
       <url-pattern>/MyServlet</url-pattern>
       <url-pattern>""</url-pattern>
       <url-pattern>*.extension</url-pattern>
       <url-pattern>/path/*</url-pattern>
   </servlet-mapping>
   例如有這樣的 Servlet 宣告，那麼當有如下請求進來時，匹配情況各不相同
   如下圖

@Bean
@ConditionalOnMissingBean(name = "zuulServlet")
@ConditionalOnProperty(name = "zuul.use-filter", havingValue = "false", matchIfMissing = true)
public ServletRegistrationBean zuulServlet() {
   // 這裡初始化了ZuulServlet，並且將它註冊到配置好的pattern上
   // 後續匹配這個pattern的請求將會直接由ZuulServlet處理
   ServletRegistrationBean<ZuulServlet> servlet = new ServletRegistrationBean<>(
         new ZuulServlet(), this.zuulProperties.getServletPattern());
   // The whole point of exposing this servlet is to provide a route that doesn't
   // buffer requests.
   servlet.addInitParameter("buffer-requests", "false");
   return servlet;
}

    public String getServletPattern() {
        // 在這裡呼叫了servletPath的屬性    
    String path = this.servletPath;
    if (!path.startsWith("/")) {
        path = "/" + path;
    }
    if (!path.contains("*")) {
        path = path.endsWith("/") ? (path + "*") : (path + "/*");
    }
    return path;
    }

private ServletRegistration.Dynamic addServlet(String servletName, String servletClass,
        Servlet servlet, Map<String,String> initParams) throws IllegalStateException {
    ...
    Wrapper wrapper = (Wrapper) context.findChild(servletName);
    // Context中的Child一般都是Wrapper，wrapper是對Servlet物件的一層包裝。
    if (wrapper == null) {
        wrapper = context.createWrapper();
        wrapper.setName(servletName);
        context.addChild(wrapper);
    } else {
		...
    }
    ServletSecurity annotation = null;
    if (servlet == null) {
        wrapper.setServletClass(servletClass);
        Class<?> clazz = Introspection.loadClass(context, servletClass);
        if (clazz != null) {
            annotation = clazz.getAnnotation(ServletSecurity.class);
        }
    } else {
        // 把 Servlet 例項設定到 wrapper 中，以供後續呼叫
        wrapper.setServletClass(servlet.getClass().getName());
        wrapper.setServlet(servlet);
        if (context.wasCreatedDynamicServlet(servlet)) {
            annotation = servlet.getClass().getAnnotation(ServletSecurity.class);
        }
    }
	...
    return registration;
}

@Override
public final void invoke(Request request, Response response)
    throws IOException, ServletException {
    ...
    Wrapper wrapper = request.getWrapper();
    if (wrapper == null || wrapper.isUnavailable()) {
        ...
    }
    // Acknowledge the request
    ...
    // 在這裡會把請求傳送到Request中對應的wrapper， 也就是代理給匹配的Servlet
    // 來進行處理
    wrapper.getPipeline().getFirst().invoke(request, response);
}

zuul.servletPath: /zuul

/zuul/* -> ZuulServlet

public ZuulHandlerMapping(RouteLocator routeLocator, ZuulController zuul) {
   
   // 這裡設定了Zuul自己的路由表
   // 使用者可以定義這個RouteLocator的實現，並生成Bean
   // Auto config會自動載入這些Bean
   this.routeLocator = routeLocator;
   // 這裡設定Zuul Controll， 它實際上只是給
   // Zuul Servlet包了一層皮，從而讓Spring把請求Dispatch到Zuul的Servlet中
   this.zuul = zuul;
   setOrder(-200);
}

    @Bean
    public ZuulController zuulController() {
    // 這個Controller幾乎沒有任何邏輯，只是handle請求
    // Zuul servlet會呼叫我們定義的ZuulFilter
    return new ZuulController();
    }
    @Bean
    public ZuulHandlerMapping zuulHandlerMapping(RouteLocator routes) {
    // 這邊Autowire了route locator，也就是一個composite route locator
    // 意思就是它可以把多個Route Locator的Bean合成一個
    ZuulHandlerMapping mapping = new ZuulHandlerMapping(routes, zuulController());
    mapping.setErrorController(this.errorController);
    mapping.setCorsConfigurations(getCorsConfigurations());
    return mapping;
    }

@Bean
public ZuulFilter actorAuthenticationFilter() {
    return new ActorAuthenticationFilterFactory(ActorLocator.class).apply(actorLocator(), 1);
}

@Bean
RouteLocator zuulDispatchingRouteLocator() {
    return new RouteLocator() {
        // 所有以fed開頭的請求會被路由到Zuul的Handler
        // 這裡無需寫死目標地址，因為我們會透過服務發現機制，在Filter中動態為Context中注入這些地址
        private final Route fedRoute = new Route(
                "fed", ProxyConsts.FEDERATION_EP_PATTERN, "no://op", "", false, new HashSet<>()
        );
        @Override
        public Collection<String> getIgnoredPaths() {
            return Collections.EMPTY_LIST;
        }
        @Override
        public List<Route> getRoutes() {
            // 框架會呼叫這個方法獲取路由，並註冊Handler
            return Collections.singletonList(fedRoute);
        }
        @Override
        public Route getMatchingRoute(String path) {
            if (path.startsWith(ProxyConsts.FEDERATION_EP_PREFIX)) {
                return fedRoute;
            }
            return null;
        }
    };
}

/fed/api/v1/tenants

// Should filter 就是我們實現的方法了，走到這一步
// 說明已經成功進入Zuul Filter Chain
shouldFilter:16, TCCFederationPreFilter (io.transwarp.tcc.federation.filters)
runFilter:114, ZuulFilter (com.netflix.zuul)
processZuulFilter:193, FilterProcessor (com.netflix.zuul)
runFilters:157, FilterProcessor (com.netflix.zuul)
preRoute:133, FilterProcessor (com.netflix.zuul)
preRoute:105, ZuulRunner (com.netflix.zuul)
preRoute:125, ZuulServlet (com.netflix.zuul.http)
service:74, ZuulServlet (com.netflix.zuul.http)
internalDoFilter:231, ApplicationFilterChain x 8
...
Valve
...
lookupHandler:86, ZuulHandlerMapping (org.springframework.cloud.netflix.zuul.web)
getHandlerInternal:124, AbstractUrlHandlerMapping (org.springframework.web.servlet.handler)
getHandler:405, AbstractHandlerMapping (org.springframework.web.servlet.handler)
getHandler:1233, DispatcherServlet (org.springframework.web.servlet)
doDispatch:1016, DispatcherServlet (org.springframework.web.servlet)
doService:943, DispatcherServlet (org.springframework.web.servlet)
processRequest:1006, FrameworkServlet (org.springframework.web.servlet)
doGet:898, FrameworkServlet (org.springframework.web.servlet)
service:626, HttpServlet (javax.servlet.http)
service:883, FrameworkServlet (org.springframework.web.servlet)
service:733, HttpServlet (javax.servlet.http)
internalDoFilter:231, ApplicationFilterChain x 8
... 
Valve
...

public class MyFilter extends ZuulFilter {
    private final RouteService rs;
    public MyFilter(RouteService rs) {
        // 初始化
        // 這裡的RouteService繼承了服務發現，路由轉發和認證功能
        this.rs = rs;
    }
    @Override
    public String filterType() {
        // 這個Filter會在請求被路由之前呼叫
        return "pre";
    }
    @Override
    public int filterOrder() {
        // 這邊定義請求的次序
        // 在實踐中，我推薦將所有的Filter order在同一個類中集中管理
        return 5;
    }
    @Override
    public boolean shouldFilter() {
        // 由於是多執行緒同步模式，一旦這個執行緒開始處理請求，
        // 這個請求都能透過Context直接獲取，不用透過引數進行傳遞
        // 這裡的Context使用Thread Local實現
        HttpServletRequest request = RequestContext
                .getCurrentContext().getRequest();
        // 可以透過uri進行判斷是否過濾該請求
        boolean shouldFilter = request.getRequestURI().startsWith("/tdc-fed");
        // 當然也可以透過Attribute等靈活的方式進行判斷
        shouldFilter = request.getAttribute("X-TDC-Fed-Remote").equals(true);
        return shouldFilter;
    }
    @Override
    public Object run() throws ZuulException {
        HttpServletRequest request = RequestContext.getCurrentContext().getRequest();
        // 為這個請求獲取token
        String token = rs.getToken(request);
        if (token == null) {
            throw new ZuulException("Unauthorized", 401, "Failed to get token");
        }
        // 我們不用去直接修改請求，只需要往Context中設定請求頭等引數
        // Zuul 框架會在路由前將Context中的變數覆蓋到請求中，非常方便
        RequestContext.getCurrentContext().addZuulRequestHeader(
                "Authorization", "Bearer " + token
        );
        // 這裡直接將目標服務的URL設定到Context中
        // 這裡的locateService可以整合各種不同的服務發現機制
        RequestContext.getCurrentContext().setRouteHost(rs.locateService(request));
        // 更改請求的路徑
        // 這邊直接透過繼承Request並設定到Context中就能實現
        RequestContext.getCurrentContext().setRequest(new HttpServletRequestWrapper(request) {
            @Override
            public String getRequestURI() {
                return rs.targetUri(request);
            }
        });
        return null;
    }
}

zuul.ignoredHeaders:
  - set-cookie