dubbo原始碼解析（三十）遠端呼叫——rest協議

CrazyHzm發表於2019-01-29

遠端呼叫——rest協議

目標：介紹rest協議的設計和實現，介紹dubbo-rpc-rest的原始碼。

前言

REST的英文名是RepresentationalState Transfer，它是一種開發風格，關於REST不清楚的朋友可以瞭解一下。在dubbo中利用的是紅帽子RedHat公司的Resteasy來使dubbo支援REST風格的開發使用。在本文中主要講解的是基於Resteasy來實現rest協議的實現。

原始碼分析

（一）RestServer

該介面是rest協議的伺服器介面。定義了伺服器相關的方法。

public interface RestServer {

    /**
     * 伺服器啟動
     * @param url
     */
    void start(URL url);

    /**
     * 部署伺服器
     * @param resourceDef it could be either resource interface or resource impl
     */
    void deploy(Class resourceDef, Object resourceInstance, String contextPath);

    /**
     * 取消伺服器部署
     * @param resourceDef
     */
    void undeploy(Class resourceDef);

    /**
     * 停止伺服器
     */
    void stop();
}

（二）BaseRestServer

該類實現了RestServer介面，是rest服務的抽象類，把getDeployment和doStart方法進行抽象，讓子類專注於中這兩個方法的實現。

1.start

    @Override
    public void start(URL url) {
        // 支援兩種 Content-Type
        getDeployment().getMediaTypeMappings().put("json", "application/json");
        getDeployment().getMediaTypeMappings().put("xml", "text/xml");
//        server.getDeployment().getMediaTypeMappings().put("xml", "application/xml");
        // 新增攔截器
        getDeployment().getProviderClasses().add(RpcContextFilter.class.getName());
        // TODO users can override this mapper, but we just rely on the current priority strategy of resteasy
        // 異常類對映
        getDeployment().getProviderClasses().add(RpcExceptionMapper.class.getName());

        // 新增需要載入的類
        loadProviders(url.getParameter(Constants.EXTENSION_KEY, ""));

        // 開啟伺服器
        doStart(url);
    }

2.deploy

@Override
public void deploy(Class resourceDef, Object resourceInstance, String contextPath) {
    // 如果
    if (StringUtils.isEmpty(contextPath)) {
        // 新增自定義資源實現端點，部署伺服器
        getDeployment().getRegistry().addResourceFactory(new DubboResourceFactory(resourceInstance, resourceDef));
    } else {
        // 新增自定義資源實現端點。指定contextPath
        getDeployment().getRegistry().addResourceFactory(new DubboResourceFactory(resourceInstance, resourceDef), contextPath);
    }
}

3.undeploy

@Override
public void undeploy(Class resourceDef) {
    // 取消伺服器部署
    getDeployment().getRegistry().removeRegistrations(resourceDef);
}

4.loadProviders

protected void loadProviders(String value) {
    for (String clazz : Constants.COMMA_SPLIT_PATTERN.split(value)) {
        if (!StringUtils.isEmpty(clazz)) {
            getDeployment().getProviderClasses().add(clazz.trim());
        }
    }
}

該方法是把類都加入到ResteasyDeployment的providerClasses中，加入各類元件。

（三）DubboHttpServer

該類繼承了BaseRestServer，實現了doStart和getDeployment方法，當配置選擇servlet、jetty或者tomcat作為遠端通訊的實現時，實現的伺服器類

1.屬性

/**
 * HttpServletDispatcher例項
 */
private final HttpServletDispatcher dispatcher = new HttpServletDispatcher();
/**
 * Resteasy的服務部署器
 */
private final ResteasyDeployment deployment = new ResteasyDeployment();
/**
 * http繫結者
 */
private HttpBinder httpBinder;
/**
 * http伺服器
 */
private HttpServer httpServer;

2.doStart

@Override
protected void doStart(URL url) {
    // TODO jetty will by default enable keepAlive so the xml config has no effect now
    // 建立http伺服器
    httpServer = httpBinder.bind(url, new RestHandler());

    // 獲得ServletContext
    ServletContext servletContext = ServletManager.getInstance().getServletContext(url.getPort());
    // 如果為空 ，則獲得預設埠對應的ServletContext物件
    if (servletContext == null) {
        servletContext = ServletManager.getInstance().getServletContext(ServletManager.EXTERNAL_SERVER_PORT);
    }
    // 如果還是為空 ，則丟擲異常
    if (servletContext == null) {
        throw new RpcException("No servlet context found. If you are using server=`servlet`, " +
                "make sure that you`ve configured " + BootstrapListener.class.getName() + " in web.xml");
    }

    // 設定屬性部署器
    servletContext.setAttribute(ResteasyDeployment.class.getName(), deployment);

    try {
        // 初始化
        dispatcher.init(new SimpleServletConfig(servletContext));
    } catch (ServletException e) {
        throw new RpcException(e);
    }
}

3.RestHandler

private class RestHandler implements HttpHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        // 設定遠端地址
        RpcContext.getContext().setRemoteAddress(request.getRemoteAddr(), request.getRemotePort());
        // 請求相關的服務
        dispatcher.service(request, response);
    }
}

該內部類是服務請求的處理器

4.SimpleServletConfig

private static class SimpleServletConfig implements ServletConfig {

    // ServletContext物件
    private final ServletContext servletContext;

    public SimpleServletConfig(ServletContext servletContext) {
        this.servletContext = servletContext;
    }

    @Override
    public String getServletName() {
        return "DispatcherServlet";
    }

    @Override
    public ServletContext getServletContext() {
        return servletContext;
    }

    @Override
    public String getInitParameter(String s) {
        return null;
    }

    @Override
    public Enumeration getInitParameterNames() {
        return new Enumeration() {
            @Override
            public boolean hasMoreElements() {
                return false;
            }

            @Override
            public Object nextElement() {
                return null;
            }
        };
    }
}

該內部類是配置類。

（四）NettyServer

該類繼承了BaseRestServer，當配置了netty作為遠端通訊的實現時，實現的伺服器。

public class NettyServer extends BaseRestServer {

    /**
     * NettyJaxrsServer物件
     */
    private final NettyJaxrsServer server = new NettyJaxrsServer();

    @Override
    protected void doStart(URL url) {
        // 獲得ip
        String bindIp = url.getParameter(Constants.BIND_IP_KEY, url.getHost());
        if (!url.isAnyHost() && NetUtils.isValidLocalHost(bindIp)) {
            // 設定服務的ip
            server.setHostname(bindIp);
        }
        // 設定埠
        server.setPort(url.getParameter(Constants.BIND_PORT_KEY, url.getPort()));
        // 通道選項集合
        Map<ChannelOption, Object> channelOption = new HashMap<ChannelOption, Object>();
        // 保持連線檢測對方主機是否崩潰
        channelOption.put(ChannelOption.SO_KEEPALIVE, url.getParameter(Constants.KEEP_ALIVE_KEY, Constants.DEFAULT_KEEP_ALIVE));
        // 設定配置
        server.setChildChannelOptions(channelOption);
        // 設定執行緒數，預設為200
        server.setExecutorThreadCount(url.getParameter(Constants.THREADS_KEY, Constants.DEFAULT_THREADS));
        // 設定核心執行緒數
        server.setIoWorkerCount(url.getParameter(Constants.IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS));
        // 設定最大的請求數
        server.setMaxRequestSize(url.getParameter(Constants.PAYLOAD_KEY, Constants.DEFAULT_PAYLOAD));
        // 啟動服務
        server.start();
    }

    @Override
    public void stop() {
        server.stop();
    }

    @Override
    protected ResteasyDeployment getDeployment() {
        return server.getDeployment();
    }
}

（五）DubboResourceFactory

該類實現了ResourceFactory介面，是資源工程實現類，封裝了以下兩個屬性，實現比較簡單。

/**
 * 資源類
 */
private Object resourceInstance;
/**
 * 掃描的型別
 */
private Class scannableClass;

（六）RestConstraintViolation

該類是當約束違反的實體類，封裝了以下三個屬性，具體使用可以看下面的介紹。

/**
 * 地址
 */
private String path;
/**
 * 訊息
 */
private String message;
/**
 * 值
 */
private String value;

（七）RestServerFactory

該類是伺服器工程類，用來提供相應的例項，裡面邏輯比較簡單。

public class RestServerFactory {

    /**
     * http繫結者
     */
    private HttpBinder httpBinder;

    public void setHttpBinder(HttpBinder httpBinder) {
        this.httpBinder = httpBinder;
    }

    /**
     * 建立伺服器
     * @param name
     * @return
     */
    public RestServer createServer(String name) {
        // TODO move names to Constants
        // 如果是servlet或者jetty或者tomcat，則建立DubboHttpServer
        if ("servlet".equalsIgnoreCase(name) || "jetty".equalsIgnoreCase(name) || "tomcat".equalsIgnoreCase(name)) {
            return new DubboHttpServer(httpBinder);
        } else if ("netty".equalsIgnoreCase(name)) {
            // 如果是netty，那麼直接建立netty伺服器
            return new NettyServer();
        } else {
            // 否則 丟擲異常
            throw new IllegalArgumentException("Unrecognized server name: " + name);
        }
    }
}

可以看到，根據配置的不同，來建立不同的伺服器實現。

（八）RpcContextFilter

該類是過濾器。增加了對協議頭大小的限制。

public class RpcContextFilter implements ContainerRequestFilter, ClientRequestFilter {

    /**
     * 附加值key
     */
    private static final String DUBBO_ATTACHMENT_HEADER = "Dubbo-Attachments";

    // currently we use a single header to hold the attachments so that the total attachment size limit is about 8k
    /**
     * 目前我們使用單個標頭來儲存附件，以便總附件大小限制大約為8k
     */
    private static final int MAX_HEADER_SIZE = 8 * 1024;

    @Override
    public void filter(ContainerRequestContext requestContext) throws IOException {
        // 獲得request
        HttpServletRequest request = ResteasyProviderFactory.getContextData(HttpServletRequest.class);
        // 把它放到rpc上下文中
        RpcContext.getContext().setRequest(request);

        // this only works for servlet containers
        if (request != null && RpcContext.getContext().getRemoteAddress() == null) {
            // 設定遠端地址
            RpcContext.getContext().setRemoteAddress(request.getRemoteAddr(), request.getRemotePort());
        }

        // 設定response
        RpcContext.getContext().setResponse(ResteasyProviderFactory.getContextData(HttpServletResponse.class));

        // 獲得協議頭資訊
        String headers = requestContext.getHeaderString(DUBBO_ATTACHMENT_HEADER);
        // 分割協議頭資訊，把附加值分解開存入上下文中
        if (headers != null) {
            for (String header : headers.split(",")) {
                int index = header.indexOf("=");
                if (index > 0) {
                    String key = header.substring(0, index);
                    String value = header.substring(index + 1);
                    if (!StringUtils.isEmpty(key)) {
                        RpcContext.getContext().setAttachment(key.trim(), value.trim());
                    }
                }
            }
        }
    }

    @Override
    public void filter(ClientRequestContext requestContext) throws IOException {
        int size = 0;
        // 遍歷附加值
        for (Map.Entry<String, String> entry : RpcContext.getContext().getAttachments().entrySet()) {
            // 如果key或者value有出現=或者，則丟擲異常
            if (entry.getValue().contains(",") || entry.getValue().contains("=")
                    || entry.getKey().contains(",") || entry.getKey().contains("=")) {
                throw new IllegalArgumentException("The attachments of " + RpcContext.class.getSimpleName() + " must not contain `,` or `=` when using rest protocol");
            }

            // TODO for now we don`t consider the differences of encoding and server limit
            // 加入UTF-8配置，計算協議頭大小
            size += entry.getValue().getBytes("UTF-8").length;
            // 如果大於限制，則丟擲異常
            if (size > MAX_HEADER_SIZE) {
                throw new IllegalArgumentException("The attachments of " + RpcContext.class.getSimpleName() + " is too big");
            }

            // 拼接
            String attachments = entry.getKey() + "=" + entry.getValue();
            // 加入到請求頭上
            requestContext.getHeaders().add(DUBBO_ATTACHMENT_HEADER, attachments);
        }
    }
}

可以看到有兩個filter的方法實現，第一個是解析對於附加值，並且放入上下文中。第二個是對協議頭大小的限制。

（九）RpcExceptionMapper

該類是異常的處理類。

public class RpcExceptionMapper implements ExceptionMapper<RpcException> {

    @Override
    public Response toResponse(RpcException e) {
        // TODO do more sophisticated exception handling and output
        // 如果是約束違反異常
        if (e.getCause() instanceof ConstraintViolationException) {
            return handleConstraintViolationException((ConstraintViolationException) e.getCause());
        }
        // we may want to avoid exposing the dubbo exception details to certain clients
        // TODO for now just do plain text output
        return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Internal server error: " + e.getMessage()).type(ContentType.TEXT_PLAIN_UTF_8).build();
    }

    /**
     * 處理引數不合法的異常
     * @param cve
     * @return
     */
    protected Response handleConstraintViolationException(ConstraintViolationException cve) {
        // 建立約束違反記錄
        ViolationReport report = new ViolationReport();
        // 遍歷約束違反
        for (ConstraintViolation cv : cve.getConstraintViolations()) {
            // 新增記錄
            report.addConstraintViolation(new RestConstraintViolation(
                    cv.getPropertyPath().toString(),
                    cv.getMessage(),
                    cv.getInvalidValue() == null ? "null" : cv.getInvalidValue().toString()));
        }
        // TODO for now just do xml output
        // 只支援xml輸出
        return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity(report).type(ContentType.TEXT_XML_UTF_8).build();
    }
}

主要是處理引數不合法的異常。

（十）ViolationReport

該類是約束違反的記錄類，其中就封裝了一個約束違反的集合。

public class ViolationReport implements Serializable {

    private static final long serialVersionUID = -130498234L;

    /**
     * 約束違反集合
     */
    private List<RestConstraintViolation> constraintViolations;

    public List<RestConstraintViolation> getConstraintViolations() {
        return constraintViolations;
    }

    public void setConstraintViolations(List<RestConstraintViolation> constraintViolations) {
        this.constraintViolations = constraintViolations;
    }

    public void addConstraintViolation(RestConstraintViolation constraintViolation) {
        if (constraintViolations == null) {
            constraintViolations = new LinkedList<RestConstraintViolation>();
        }
        constraintViolations.add(constraintViolation);
    }
}

（十一）RestProtocol

該類繼承了AbstractProxyProtocol，是rest協議實現的核心。

1.屬性

/**
 * 預設埠號
 */
private static final int DEFAULT_PORT = 80;

/**
 * 伺服器集合
 */
private final Map<String, RestServer> servers = new ConcurrentHashMap<String, RestServer>();

/**
 * 伺服器工廠
 */
private final RestServerFactory serverFactory = new RestServerFactory();

// TODO in the future maybe we can just use a single rest client and connection manager
/**
 * 客戶端集合
 */
private final List<ResteasyClient> clients = Collections.synchronizedList(new LinkedList<ResteasyClient>());

/**
 * 連線監控
 */
private volatile ConnectionMonitor connectionMonitor;

2.doExport

@Override
protected <T> Runnable doExport(T impl, Class<T> type, URL url) throws RpcException {
    // 獲得地址
    String addr = getAddr(url);
    // 獲得實現類
    Class implClass = (Class) StaticContext.getContext(Constants.SERVICE_IMPL_CLASS).get(url.getServiceKey());
    // 獲得服務
    RestServer server = servers.get(addr);
    if (server == null) {
        // 建立伺服器
        server = serverFactory.createServer(url.getParameter(Constants.SERVER_KEY, "jetty"));
        // 開啟伺服器
        server.start(url);
        // 加入集合
        servers.put(addr, server);
    }

    // 獲得contextPath
    String contextPath = getContextPath(url);
    // 如果以servlet的方式
    if ("servlet".equalsIgnoreCase(url.getParameter(Constants.SERVER_KEY, "jetty"))) {
        // 獲得ServletContext
        ServletContext servletContext = ServletManager.getInstance().getServletContext(ServletManager.EXTERNAL_SERVER_PORT);
        // 如果為空，則丟擲異常
        if (servletContext == null) {
            throw new RpcException("No servlet context found. Since you are using server=`servlet`, " +
                    "make sure that you`ve configured " + BootstrapListener.class.getName() + " in web.xml");
        }
        String webappPath = servletContext.getContextPath();
        if (StringUtils.isNotEmpty(webappPath)) {
            // 檢測配置是否正確
            webappPath = webappPath.substring(1);
            if (!contextPath.startsWith(webappPath)) {
                throw new RpcException("Since you are using server=`servlet`, " +
                        "make sure that the `contextpath` property starts with the path of external webapp");
            }
            contextPath = contextPath.substring(webappPath.length());
            if (contextPath.startsWith("/")) {
                contextPath = contextPath.substring(1);
            }
        }
    }

    // 獲得資源
    final Class resourceDef = GetRestful.getRootResourceClass(implClass) != null ? implClass : type;

    // 部署伺服器
    server.deploy(resourceDef, impl, contextPath);

    final RestServer s = server;
    return new Runnable() {
        @Override
        public void run() {
            // TODO due to dubbo`s current architecture,
            // it will be called from registry protocol in the shutdown process and won`t appear in logs
            s.undeploy(resourceDef);
        }
    };
}

該方法是服務暴露的方法。

3.doRefer

protected <T> T doRefer(Class<T> serviceType, URL url) throws RpcException {
    // 如果連線監控為空，則建立
    if (connectionMonitor == null) {
        connectionMonitor = new ConnectionMonitor();
    }

    // TODO more configs to add
    // 建立http連線池
    PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager();
    // 20 is the default maxTotal of current PoolingClientConnectionManager
    // 最大連線數
    connectionManager.setMaxTotal(url.getParameter(Constants.CONNECTIONS_KEY, 20));
    // 最大的路由數
    connectionManager.setDefaultMaxPerRoute(url.getParameter(Constants.CONNECTIONS_KEY, 20));

    // 新增監控
    connectionMonitor.addConnectionManager(connectionManager);
    // 新建請求配置
    RequestConfig requestConfig = RequestConfig.custom()
            .setConnectTimeout(url.getParameter(Constants.CONNECT_TIMEOUT_KEY, Constants.DEFAULT_CONNECT_TIMEOUT))
            .setSocketTimeout(url.getParameter(Constants.TIMEOUT_KEY, Constants.DEFAULT_TIMEOUT))
            .build();

    // 設定socket配置
    SocketConfig socketConfig = SocketConfig.custom()
            .setSoKeepAlive(true)
            .setTcpNoDelay(true)
            .build();

    // 建立http客戶端
    CloseableHttpClient httpClient = HttpClientBuilder.create()
            .setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
                @Override
                public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
                    HeaderElementIterator it = new BasicHeaderElementIterator(response.headerIterator(HTTP.CONN_KEEP_ALIVE));
                    while (it.hasNext()) {
                        HeaderElement he = it.nextElement();
                        String param = he.getName();
                        String value = he.getValue();
                        if (value != null && param.equalsIgnoreCase("timeout")) {
                            return Long.parseLong(value) * 1000;
                        }
                    }
                    // TODO constant
                    return 30 * 1000;
                }
            })
            .setDefaultRequestConfig(requestConfig)
            .setDefaultSocketConfig(socketConfig)
            .build();

    // 建立ApacheHttpClient4Engine對應，為了使用resteasy
    ApacheHttpClient4Engine engine = new ApacheHttpClient4Engine(httpClient/*, localContext*/);

    //  建立ResteasyClient物件
    ResteasyClient client = new ResteasyClientBuilder().httpEngine(engine).build();
    // 加入集合
    clients.add(client);

    // 設定過濾器
    client.register(RpcContextFilter.class);
    // 註冊各類元件
    for (String clazz : Constants.COMMA_SPLIT_PATTERN.split(url.getParameter(Constants.EXTENSION_KEY, ""))) {
        if (!StringUtils.isEmpty(clazz)) {
            try {
                client.register(Thread.currentThread().getContextClassLoader().loadClass(clazz.trim()));
            } catch (ClassNotFoundException e) {
                throw new RpcException("Error loading JAX-RS extension class: " + clazz.trim(), e);
            }
        }
    }

    // TODO protocol
    // 建立 Service Proxy 物件。
    ResteasyWebTarget target = client.target("http://" + url.getHost() + ":" + url.getPort() + "/" + getContextPath(url));
    return target.proxy(serviceType);
}

該方法是服務引用的實現。

4.ConnectionMonitor

protected class ConnectionMonitor extends Thread {
    /**
     * 是否關閉
     */
    private volatile boolean shutdown;
    /**
     * 連線池集合
     */
    private final List<PoolingHttpClientConnectionManager> connectionManagers = Collections.synchronizedList(new LinkedList<PoolingHttpClientConnectionManager>());

    public void addConnectionManager(PoolingHttpClientConnectionManager connectionManager) {
        connectionManagers.add(connectionManager);
    }

    @Override
    public void run() {
        try {
            while (!shutdown) {
                synchronized (this) {
                    wait(1000);
                    for (PoolingHttpClientConnectionManager connectionManager : connectionManagers) {
                        // 關閉池中所有過期的連線
                        connectionManager.closeExpiredConnections();
                        // TODO constant
                        // 關閉池中的空閒連線
                        connectionManager.closeIdleConnections(30, TimeUnit.SECONDS);
                    }
                }
            }
        } catch (InterruptedException ex) {
            // 關閉
            shutdown();
        }
    }

    public void shutdown() {
        shutdown = true;
        connectionManagers.clear();
        synchronized (this) {
            notifyAll();
        }
    }
}

該內部類是處理連線的監控類，當連線過期獲取空間的時候，關閉它。

後記

該部分相關的原始碼解析地址：https://github.com/CrazyHZM/i…

該文章講解了遠端呼叫中關於rest協議實現的部分，關鍵是要對Resteasy的使用需要有所瞭解，其他的思路跟其他協議實現差距不大。接下來我將開始對rpc模組關於rmi協議部分進行講解。

dubbo原始碼解析（三十一）遠端呼叫——rmi協議
2019-01-19
原始碼協議
dubbo原始碼解析（三十二）遠端呼叫——thrift協議
2019-01-19
原始碼協議
Dubbo原始碼分析（五）Dubbo呼叫鏈-服務端
2018-10-04
原始碼服務端
Dubbo服務呼叫過程原始碼解析④
2020-12-27
原始碼
Dubbo原始碼學習--Rmi協議（八）
2018-04-14
原始碼協議
Dubbo原始碼解析之客戶端初始化及服務呼叫
2018-11-04
原始碼客戶端
Dubbo原始碼解析之服務呼叫過程
2019-04-08
原始碼
Dubbo原始碼分析（四）Dubbo呼叫鏈-消費端（叢集容錯機制）
2018-10-04
原始碼
consul 原始碼解析（一）raft 協議實現
2018-03-04
原始碼Raft協議
Dubbo原始碼解析之SPI
2018-10-31
原始碼
dubbo原始碼解析-spi(五)
2019-02-22
原始碼
ssh遠端登入協議
2024-05-05
協議
rdp(遠端桌面協議)配置
2023-02-02
協議
Dubbo-go 原始碼筆記（二）客戶端呼叫過程
2020-11-10
Go原始碼筆記客戶端
Dubbo原始碼分析（十）同步呼叫與非同步呼叫
2019-03-25
原始碼非同步
HDFS原始碼解析系列一——HDFS通訊協議
2022-02-16
原始碼協議
django rest framework 檢視原始碼解析
2018-11-04
DjangoRESTFramework原始碼
Dubbo服務暴露原始碼解析②
2020-12-26
原始碼
okhttp 原始碼解析 – http 協議的實現 – 重定向
2019-03-01
HTTP原始碼協議
協議：SpringCloud VS Dubbo
2018-07-09
協議SpringGCCloud
聊聊dubbo協議2
2022-01-19
協議
Dubbo原始碼解析之SPI機制
2019-04-02
原始碼
dubbo原始碼解析之ExtensionLoader類（二）
2018-10-14
原始碼
dubbo原始碼解析之基礎篇
2018-10-14
原始碼
dubbo原始碼解析之負載均衡
2020-06-29
原始碼負載
聊聊Dubbo – Dubbo可擴充套件機制原始碼解析
2019-01-19
套件原始碼
121 TeamViewer 遠端支援、遠端訪問、線上協作和會議
2018-08-24
View
玩轉直播系列之RTMP協議和原始碼解析（2）
2021-05-17
協議原始碼
Runtime原始碼 protocol(協議)
2018-11-01
原始碼Protocol協議
ipad協議及原始碼
2022-05-14
iPad協議原始碼
django-rest-framework原始碼分析2—認證(Authentication)原始碼解析
2020-12-15
DjangoRESTFramework原始碼
dubbo註冊協議（三）
2018-10-14
協議
Dubbo-通訊協議
2020-11-28
協議
Dubbo原始碼解析之負載均衡策略
2019-04-02
原始碼負載
Dubbo原始碼解析之服務叢集
2019-04-11
原始碼
Linux網路-ssh遠端連線協議
2024-05-05
Linux協議
Free自由協議鎖倉分紅系統NFT丨Free自由協議開發原始碼解析
2022-07-14
協議原始碼
Harbor配置Swagger遠端REST API
2018-06-28
SwaggerRESTAPI

dubbo原始碼解析（三十）遠端呼叫——rest協議

遠端呼叫——rest協議

前言

原始碼分析

（一）RestServer

（二）BaseRestServer

1.start

2.deploy

3.undeploy

4.loadProviders

（三）DubboHttpServer

1.屬性

2.doStart

3.RestHandler

4.SimpleServletConfig

（四）NettyServer

（五）DubboResourceFactory

（六）RestConstraintViolation

（七）RestServerFactory

（八）RpcContextFilter

（九）RpcExceptionMapper

（十）ViolationReport

（十一）RestProtocol

1.屬性

2.doExport

3.doRefer

4.ConnectionMonitor

後記

相關文章