带你梳理Jetty自定义ProxyServlet实现反向代理服务

作者: 虞磨

更新时间:2022-03-26 14:31:40

4804 阅读

摘要:最近要做一个将K8s中的某组件UI通过反向代理映射到自定义规则的链接地址上,提供给用户访问的需求。所以顺便研究了一下Jetty的ProxyServlet。

本文分享自华为云社区《Jetty自定义ProxyServlet实现反向代理服务(含源码分析)》,作者: 小焱 。

一、背景概述

最近要做一个将K8s中的某组件UI通过反向代理映射到自定义规则的链接地址上,提供给用户访问的需求。所以顺便研究了一下Jetty的ProxyServlet。在这里做一下分析,如果有理解不到位的还希望可以补充指正。

二、Jetty 的基本架构

Jetty 是一个Servlet 引擎,它的架构比较简单,也是一个可扩展性和非常灵活的应用服务器,它有一个基本数据模型,这个数据模型就是 Handler,所有可以被扩展的组件都可以作为一个 Handler,添加到 Server 中,Jetty 就是帮你管理这些 Handler。

整个 Jetty 的核心组件由 Server 和 Connector 两个组件构成,整个 Server 组件是基于 Handler 容器工作的,Jetty 中另外一个比不可少的组件是 Connector,它负责接受客户端的连接请求,并将请求分配给一个处理队列去执行。Jetty 中还有一些可有可无的组件,我们可以在它上做扩展。如 JMX,我们可以定义一些 Mbean 把它加到 Server 中,当 Server 启动的时候,这些 Bean 就会一起工作。

整个 Jetty 的核心是围绕着 Server 类来构建,Server 类继承了 Handler,关联了 Connector 和 Container。Container 是管理 Mbean 的容器。Jetty 的 Server 的扩展主要是实现一个个 Handler 并将 Handler 加到 Server 中,Server 中提供了调用这些 Handler 的访问规则。整个 Jetty 的所有组件的生命周期管理是基于观察者模板设计,实现LifeCycle。

三、Handler 的体系结构

Jetty 主要是基于 Handler 来设计的,Handler 的体系结构影响着整个 Jetty 的方方面面。下面总结了一下 Handler 的种类及作用:

Jetty 主要提供了两种 Handler 类型,一种是 HandlerWrapper,它可以将一个 Handler 委托给另外一个类去执行,如我们要将一个 Handler 加到 Jetty 中,那么就必须将这个 Handler 委托给 Server 去调用。配合 ScopeHandler 类我们可以拦截 Handler 的执行,在调用 Handler 之前或之后,可以做一些另外的事情,类似于 Tomcat 中的 Valve;另外一个 Handler 类型是 HandlerCollection,这个 Handler 类可以将多个 Handler 组装在一起,构成一个 Handler 链,方便我们做扩展。

四、编码设计

这里我提供一个设计框架,具体内容可以根据需要自定义。

public class RestApi {
    private static final Logging LOGGER = Logging.getLogging(RestApi.class.getName());
​
    private Server server;
​
    /**
     * 启动方法,需要在程序启动时调用该方法
     */
    public void start() {
        try {
            ContextHandlerCollection collection = new ContextHandlerCollection();
            WebAppContext appContext = new WebAppContext();
            appContext.setContextPath("/");
            // 设置资源文件地址,可略
            appContext.setResourceBase("/opt/appHome/myDemo/webapp");
            // 设置web.xml,可在里面进行一些Servlet配置,可略
            appContext.setDescriptor("/opt/appHome/myDemo/webapp/WEB-INF/web.xml"); 
            appContext.setParentLoaderPriority(true);
            collection.addHandler(appContext);
            addProxyHandler(collection);
​
            server = new Server(8080);
            server.setHandler(collection);
            server.start();
        } catch (Throwable t) {
            LOGGER.error("Start RESTful API server failed", t);
        }
    }
 
    private static void addProxyHandler(ContextHandlerCollection collection) {
        ProxyServlet proxyServlet = new WebProxyServlet();      // 添加自定义ProxyServlet
​
        ServletHolder holder = new ServletHolder(proxyServlet);
​
        holder.setInitParameter("idleTimeout", 120000);         // 设置空闲释放时间
        holder.setInitParameter("timeout", 300000);             // 设置超时时间
        holder.setInitParameter("maxConnections", 256);         // 设置最大连接数
​
        ServletContextHandler contextHandler = new ServletContextHandler();
        contextHandler.addServlet(holder, "/proxy/*");
        contextHandler.setContextPath("/demo");
        collection.addHandler(contextHandler);
    }
}

自定义 ProxyServlet,在此列出一部分常用的重写方法,还有很多方法可以查询文档自行重写

public class WebProxyServlet extends ProxyServlet {
    private static final Logging LOGGING = Logging.getLogging(WebProxyServlet.class);
​
    /**
     * 自定义目标地址重写方法
     */
    @Override
    protected String rewriteTarget(HttpServletRequest request) { }      
 
    /**
     * 自定义重写错误处理方法
     */
    @Override
    protected void onProxyRewriteFailed(HttpServletRequest clientRequest, HttpServletResponse clientResponse) { }
 
    /**
     * 自定义response错误处理方法
     */
    @Override
    protected void onProxyResponseFailure(
        HttpServletRequest clientRequest,
        HttpServletResponse proxyResponse,
        Response serverResponse,
        Throwable failure) { }
 
    /**
     * 自定义response头filter
     */
    @Override
    protected String filterServerResponseHeader(
        HttpServletRequest clientRequest,
        Response serverResponse,
        String headerName,
        String headerValue) { }
 
    /**
     * 自定义头XForwarded设置
     */
    @Override
    protected void addXForwardedHeaders(HttpServletRequest clientRequest, Request proxyRequest) { }
}

五、请求处理过程

下面通过跟踪源码初步梳理了一下,从 request 请求进入到返回 response 的整个流程

六、源码分析

1、Request 转发部分

当 Jetty 接收到一个请求时,Jetty 就把这个请求交给在 Server 中注册的 ContextHandlerCollection 去执行,查看 Service 的 handle 方法源码

 public void handle(HttpChannel channel) throws IOException, ServletException {
        String target = channel.getRequest().getPathInfo();
        Request request = channel.getRequest();
        Response response = channel.getResponse();
        if (LOG.isDebugEnabled()) {
            LOG.debug("{} {} {} on {}", new Object[]{request.getDispatcherType(), request.getMethod(), target, channel});
        }
​
        if (!HttpMethod.OPTIONS.is(request.getMethod()) && !"*".equals(target)) {
            this.handle(target, request, request, response);
        } else if (!HttpMethod.OPTIONS.is(request.getMethod())) {
            request.setHandled(true);
            response.sendError(400);
        } else {
            this.handleOptions(request, response);
            if (!request.isHandled()) {
                this.handle(target, request, request, response);
            }
        }
​
        if (LOG.isDebugEnabled()) {
            LOG.debug("handled={} async={} committed={} on {}", new Object[]{request.isHandled(), request.isAsyncStarted(), 
                                                                             response.isCommitted(), channel});
        }
    }

这里调用的 this.handle(target, request, request, response) 方法其实是父类 HandlerWrapper 的 handle 方法

 public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        Handler handler = this._handler;
        if (handler != null) {
            handler.handle(target, baseRequest, request, response);
        }
    }

创建 server 时曾调用过 server.setHandler(collection) ,所以这里就调用到了 ContextHandlerCollection 的 handle 方法

  public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        ContextHandlerCollection.Mapping mapping = (ContextHandlerCollection.Mapping)this._handlers.get();
        if (mapping != null) {
            Handler[] handlers = mapping.getHandlers();
            if (handlers != null && handlers.length != 0) {
                if (handlers.length == 1) {
                    handlers[0].handle(target, baseRequest, request, response);
                } else {
                    HttpChannelState async = baseRequest.getHttpChannelState();
                    if (async.isAsync()) {
                        ContextHandler context = async.getContextHandler();
                        if (context != null) {
                            Handler branch = (Handler)mapping._contextBranches.get(context);
                            if (branch == null) {
                                context.handle(target, baseRequest, request, response);
                            } else {
                                branch.handle(target, baseRequest, request, response);
                            }
​
                            return;
                        }
                    }
​
                    int limit;
                    if (target.startsWith("/")) {
                        Trie<Entry<String, ContextHandlerCollection.Branch[]>> pathBranches = mapping._pathBranches;
                        if (pathBranches == null) {
                            return;
                        }
​
                        int l;
                        for(limit = target.length() - 1; limit >= 0; limit = l - 2) {
                            Entry<String, ContextHandlerCollection.Branch[]> branches = 
                                (Entry)pathBranches.getBest(target, 1, limit);
                            if (branches == null) {
                                break;
                            }
​
                            l = ((String)branches.getKey()).length();
                            if (l == 1 || target.length() == l || target.charAt(l) == '/') {
                                ContextHandlerCollection.Branch[] var12 = 
                                    (ContextHandlerCollection.Branch[])branches.getValue();
                                int var13 = var12.length;
​
                                for(int var14 = 0; var14 < var13; ++var14) {
                                    ContextHandlerCollection.Branch branch = var12[var14];
                                    branch.getHandler().handle(target, baseRequest, request, response);
                                    if (baseRequest.isHandled()) {
                                        return;
                                    }
                                }
                            }
                        }
                    } else {
                        Handler[] var17 = handlers;
                        limit = handlers.length;
​
                        for(int var19 = 0; var19 < limit; ++var19) {
                            Handler handler = var17[var19];
                            handler.handle(target, baseRequest, request, response);
                            if (baseRequest.isHandled()) {
                                return;
                            }
                        }
                    }
                }
            }
        }
    }

从上面的源码可以看出 ContextHandlerCollection 的 handle 方法继续调用了 collection.addHandler 设置进来 ServletContextHandler 的 handle 方法,通过跟踪,可以找到其实这里调用了父类 ScopedHandler 的 handle --> doScope --> nextScope

  public final void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        if (this.isStarted()) {
            if (this._outerScope == null) {
                this.doScope(target, baseRequest, request, response);
            } else {
                this.doHandle(target, baseRequest, request, response);
            }
        }
    }
​
    public void doScope(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        this.nextScope(target, baseRequest, request, response);
    }
​
    public final void nextScope(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        if (this._nextScope != null) {
            this._nextScope.doScope(target, baseRequest, request, response);
        } else if (this._outerScope != null) {
            this._outerScope.doHandle(target, baseRequest, request, response);
        } else {
            this.doHandle(target, baseRequest, request, response);
        }
    }

查看 ServletContextHandler 可以找到主要注册了以下三个 handler,均为 ScopedHandler 的子类,也就是 nextScope 方法中的 this._nextScope

protected SessionHandler _sessionHandler;
protected SecurityHandler _securityHandler;
protected ServletHandler _servletHandler;

SessionHandler 是对 ServletHandler 进行了一层包装(装饰器模式),用于一些session的预处理什么的,而SecurityHandler从名字分析是做一些安全相关的,这两个具体就不分析了,直接来看 ServletHandler 的 doScope 方法

   public void doScope(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        String old_servlet_path = baseRequest.getServletPath();
        String old_path_info = baseRequest.getPathInfo();
        DispatcherType type = baseRequest.getDispatcherType();
        ServletHolder servletHolder = null;
        Scope oldScope = null;
        MappedResource<ServletHolder> mapping = this.getMappedServlet(target);
        if (mapping != null) {
            servletHolder = (ServletHolder)mapping.getResource();
            if (mapping.getPathSpec() != null) {
                PathSpec pathSpec = mapping.getPathSpec();
                String servletPath = pathSpec.getPathMatch(target);
                String pathInfo = pathSpec.getPathInfo(target);
                if (DispatcherType.INCLUDE.equals(type)) {
                    baseRequest.setAttribute("javax.servlet.include.servlet_path", servletPath);
                    baseRequest.setAttribute("javax.servlet.include.path_info", pathInfo);
                } else {
                    baseRequest.setServletPath(servletPath);
                    baseRequest.setPathInfo(pathInfo);
                }
            }
        }
​
        if (LOG.isDebugEnabled()) {
            LOG.debug("servlet {}|{}|{} -> {}", 
                      new Object[]{baseRequest.getContextPath(), 
                                   baseRequest.getServletPath(), 
                                   baseRequest.getPathInfo(), 
                                   servletHolder});
        }
​
        try {
            oldScope = baseRequest.getUserIdentityScope();
            baseRequest.setUserIdentityScope(servletHolder);
            this.nextScope(target, baseRequest, request, response);
        } finally {
            if (oldScope != null) {
                baseRequest.setUserIdentityScope(oldScope);
            }
​
            if (!DispatcherType.INCLUDE.equals(type)) {
                baseRequest.setServletPath(old_servlet_path);
                baseRequest.setPathInfo(old_path_info);
            }
        }
    }

这里对 baseRequest 做了一些设置,将注册进来的 ServletHolder set 进了 baseRequest,之后又继续调用了 this.nextScope(target, baseRequest, request, response) ,根据上面的 nextScope 方法,所有 scope 执行完,则执行 doHandle 方法,继续跳过 SessionHandler 和 SecurityHandler,来看下ServletHandler 的 doHandle 方法

 public void doHandle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) 
        throws IOException, ServletException {
        ServletHolder servletHolder = (ServletHolder)baseRequest.getUserIdentityScope();
        FilterChain chain = null;
        if (servletHolder != null && this._filterMappings != null && this._filterMappings.length > 0) {
            chain = this.getFilterChain(baseRequest, target.startsWith("/") ? target : null, servletHolder);
        }
​
        if (LOG.isDebugEnabled()) {
            LOG.debug("chain={}", new Object[]{chain});
        }
​
        try {
            if (servletHolder == null) {
                this.notFound(baseRequest, request, response);
            } else {
                ServletRequest req = request;
                if (request instanceof ServletRequestHttpWrapper) {
                    req = ((ServletRequestHttpWrapper)request).getRequest();
                }
​
                ServletResponse res = response;
                if (response instanceof ServletResponseHttpWrapper) {
                    res = ((ServletResponseHttpWrapper)response).getResponse();
                }
​
                servletHolder.prepare(baseRequest, (ServletRequest)req, (ServletResponse)res);
                if (chain != null) {
                    chain.doFilter((ServletRequest)req, (ServletResponse)res);
                } else {
                    servletHolder.handle(baseRequest, (ServletRequest)req, (ServletResponse)res);
                }
            }
        } finally {
            if (servletHolder != null) {
                baseRequest.setHandled(true);
            }
        }
    }

doHandle 主要是取出注册的 FilterChain ServletHolder,如果存在 Filter,先执行 chain.doFilter 方法,否则执行 servletHolder.handle 我没有设置 filter 所有就直接看 ServletHolder 的 handle 方法了

 public void handle(Request baseRequest, ServletRequest request, ServletResponse response) 
        throws ServletException, UnavailableException, IOException {
        try {
            Servlet servlet = this.getServletInstance();
            if (servlet == null) {
                throw new UnavailableException("Servlet Not Initialized");
            }
​
            servlet.service(request, response);
        } catch (UnavailableException var5) {
            this.makeUnavailable(var5).service(request, response);
        }
    }

这里调用了 ServletHolder 中 Servlet 的 service 方法,也就是走到了我们自定义类 WebProxyServlet 类,因为没有重写,所以这里调用的是 ProxyServlet 的 service 方法

 protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        int requestId = this.getRequestId(request);
        String rewrittenTarget = this.rewriteTarget(request);
        if (this._log.isDebugEnabled()) {
            StringBuffer uri = request.getRequestURL();
            if (request.getQueryString() != null) {
                uri.append("?").append(request.getQueryString());
            }
​
            if (this._log.isDebugEnabled()) {
                this._log.debug("{} rewriting: {} -> {}", new Object[]{requestId, uri, rewrittenTarget});
            }
        }
​
        if (rewrittenTarget == null) {
            this.onProxyRewriteFailed(request, response);
        } else {
            Request proxyRequest = this.newProxyRequest(request, rewrittenTarget);
            this.copyRequestHeaders(request, proxyRequest);
            this.addProxyHeaders(request, proxyRequest);
            AsyncContext asyncContext = request.startAsync();
            asyncContext.setTimeout(0L);
            proxyRequest.timeout(this.getTimeout(), TimeUnit.MILLISECONDS);
            if (this.hasContent(request)) {
                if (this.expects100Continue(request)) {
                    DeferredContentProvider deferred = new DeferredContentProvider(new ByteBuffer[0]);
                    proxyRequest.content(deferred);
                    proxyRequest.attribute(CONTINUE_ACTION_ATTRIBUTE, () -> {
                        try {
                            ContentProvider provider = this.proxyRequestContent(request, response, proxyRequest);
                            (new ProxyServlet.DelegatingContentProvider(request, proxyRequest, 
                                                                        response, provider, deferred)).iterate();
                        } catch (Throwable var6) {
                            this.onClientRequestFailure(request, proxyRequest, response, var6);
                        }
​
                    });
                } else {
                    proxyRequest.content(this.proxyRequestContent(request, response, proxyRequest));
                }
            }
            this.sendProxyRequest(request, response, proxyRequest);
        }
    }

至此调用到了我们重写的最关键的方法 rewriteTarget 此方法可以自定义逻辑将 request 的地址解析,返回要代理到的目标地址,使用目标地址组成proxyRequest 最后调用 sendProxyRequest 实现代理转发。

2、Response 接收部分

如果继续跟 sendProxyRequest 会看到创建了一个 ProxyResponseListener,这里具体就不详细跟踪了,主要讲一下流程,有兴趣的可以自行动手看一下。Response 返回会通过反射机制触发 onHeader 方法 ProxyServlet 重写了该方法并跳转到了 onServerResponseHeaders 方法

  public void onHeaders(Response proxyResponse) {
        ProxyServlet.this.onServerResponseHeaders(this.request, this.response, proxyResponse);
    }

这个方法是设置 Response 的 header 内容的,其中有获取 headerValue 调用了 this.filterServerResponseHeader 方法,我们也可以通过重写此方法自定义返回体的 headerValue。

七、总结

到这里 Jetty 的 ProxyServlet 运行原理和自定义方法大致梳理完毕。还有许多漏掉的和理解不到位的地方,希望大家可以提出指正。工作中偶尔抽出一点时间读一下源码,既可以提升对所用技术的理解,又可以学习欣赏这些框架的巧妙设计,还是非常有意义的。

 

点击关注,第一时间了解华为云新鲜技术~

版权声明:本文著作权归作者【虞磨 】所有,不代表本网站立场。

侵权请联系:root_email@163.com

相关推荐