简约之美Jodd-http--深入源码理解http协议

Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！

jodd-http是一个轻巧的HTTP客户端。现在我们以一个简单的示例从源码层看看是如何实现的？

  　HttpRequest httpRequest = HttpRequest.get("http://jodd.org"); //1. 构建一个get请求
    HttpResponse response = httpRequest.send(); //2.发送请求并接受响应信息

    System.out.println(response);//3.打印响应信息

构建一个get请求

先复习一下http请求报文的格式：

下图展示一般请求所带有的属性

调用get方法构建http请求：

    /**
     * Builds a GET request.
     */
    public static HttpRequest get(String destination) {
        return new HttpRequest()
                .method("GET")
                .set(destination);
    }

method方法如下：

    /**
     * Specifies request method. It will be converted into uppercase.
     */
    public HttpRequest method(String method) {
        this.method = method.toUpperCase();
        return this;
    }

set方法如下：

/**
     * Sets the destination (method, host, port... ) at once.
     */
    public HttpRequest set(String destination) {
        destination = destination.trim();

        // http method

        int ndx = destination.indexOf(' ');

        if (ndx != -1) {
            method = destination.substring(0, ndx).toUpperCase();
            destination = destination.substring(ndx + 1);
        }

        // protocol

        ndx = destination.indexOf("://");

        if (ndx != -1) {
            protocol = destination.substring(0, ndx);
            destination = destination.substring(ndx + 3);
        }

        // host

        ndx = destination.indexOf('/');

        if (ndx == -1) {
            ndx = destination.length();
        }

        if (ndx != 0) {

            host = destination.substring(0, ndx);
            destination = destination.substring(ndx);

            // port

            ndx = host.indexOf(':');

            if (ndx == -1) {
                port = DEFAULT_PORT;
            } else {
                port = Integer.parseInt(host.substring(ndx + 1));
                host = host.substring(0, ndx);
            }
        }

        // path + query

        path(destination);

        return this;
    }

上述方法，根据destination解析出一下几个部分：

1. 方法：HTTP1.1支持7种请求方法:GET、POST、HEAD、OPTIONS、PUT、DELETE和TARCE。

2. 协议：http或者https

3. 主机：请求的服务器地址

4. 端口：请求的服务器端口

5. 路径+查询参数，其中参数以“?”开头，使用“&”连接

    /**
     * Sets request path. Query string is allowed.
     * Adds a slash if path doesn't start with one.
     * Query will be stripped out from the path.
     * Previous query is discarded.
     * @see #query()
     */
    public HttpRequest path(String path) {
        // this must be the only place that sets the path

        if (path.startsWith(StringPool.SLASH) == false) {
            path = StringPool.SLASH + path;
        }

        int ndx = path.indexOf('?');

        if (ndx != -1) {
            String queryString = path.substring(ndx + 1);

            path = path.substring(0, ndx);

            query = HttpUtil.parseQuery(queryString, true);
        } else {
            query = HttpValuesMap.ofObjects();
        }

        this.path = path;

        return this;
    }

发送请求

先熟悉一下http响应报文的格式：

响应首部一般包含如下内容：

/**
     * {@link #open() Opens connection} if not already open, sends request,
     * reads response and closes the request. If keep-alive mode is enabled
     * connection will not be closed.
     */
    public HttpResponse send() {
        if (httpConnection == null) {
            open();
        }

        // prepare http connection

        if (timeout != -1) {
            httpConnection.setTimeout(timeout);
        }

        // sends data
        HttpResponse httpResponse;
        try {
            OutputStream outputStream = httpConnection.getOutputStream();

            sendTo(outputStream);

            InputStream inputStream = httpConnection.getInputStream();

            httpResponse = HttpResponse.readFrom(inputStream);

            httpResponse.assignHttpRequest(this);
        } catch (IOException ioex) {
            throw new HttpException(ioex);
        }

        boolean keepAlive = httpResponse.isConnectionPersistent();

        if (keepAlive == false) {
            // closes connection if keep alive is false, or if counter reached 0
            httpConnection.close();
            httpConnection = null;
        }

        return httpResponse;
    }

1. 打开HttpConnection

    /**
     * Opens a new {@link HttpConnection connection} using
     * {@link JoddHttp#httpConnectionProvider default connection provider}.
     */
    public HttpRequest open() {
        return open(JoddHttp.httpConnectionProvider);
    }

    /**
     * Opens a new {@link jodd.http.HttpConnection connection}
     * using given {@link jodd.http.HttpConnectionProvider}.
     */
    public HttpRequest open(HttpConnectionProvider httpConnectionProvider) {
        if (this.httpConnection != null) {
            throw new HttpException("Connection already opened");
        }
        try {
            this.httpConnectionProvider = httpConnectionProvider;
            this.httpConnection = httpConnectionProvider.createHttpConnection(this);
        } catch (IOException ioex) {
            throw new HttpException(ioex);
        }

        return this;
    }

判断是否有连接，若没有连接则创建一个新的连接。

2. 创建连接实现

    /**
     * Creates new connection from current {@link jodd.http.HttpRequest request}.
     *
     * @see #createSocket(String, int)
     */
    public HttpConnection createHttpConnection(HttpRequest httpRequest) throws IOException {
        Socket socket;

        if (httpRequest.protocol().equalsIgnoreCase("https")) {
            SSLSocket sslSocket = createSSLSocket(httpRequest.host(), httpRequest.port());

            sslSocket.startHandshake();

            socket = sslSocket;
        } else {
            socket = createSocket(httpRequest.host(), httpRequest.port());
        }

        return new SocketHttpConnection(socket);
    }

3. 创建socket

　　根据协议的不同，http使用SocketFactory创建socket，https使用SSLSocketFactory创建SSLSocket。最终使用SocketHttpConnection进行包装。

SocketHttpConnection继承自HttpConnection，实现了socket的输入输出流连接。注意：https创建完SSLSocket时需要进行握手。

public class SocketHttpConnection implements HttpConnection {

    protected final Socket socket;

    public SocketHttpConnection(Socket socket) {
        this.socket = socket;
    }

    public OutputStream getOutputStream() throws IOException {
        return socket.getOutputStream();
    }

    public InputStream getInputStream() throws IOException {
        return socket.getInputStream();
    }

    public void close() {
        try {
            socket.close();
        } catch (IOException ignore) {
        }
    }

    public void setTimeout(int milliseconds) {
        try {
            socket.setSoTimeout(milliseconds);
        } catch (SocketException sex) {
            throw new HttpException(sex);
        }
    }

    /**
     * Returns <code>Socket</code> used by this connection.
     */
    public Socket getSocket() {
        return socket;
    }
}

 打开Connection的输出流发送信息，打开connection的输入流接受返回信息。

            OutputStream outputStream = httpConnection.getOutputStream();

            sendTo(outputStream);

            InputStream inputStream = httpConnection.getInputStream();

发送过程：

    protected HttpProgressListener httpProgressListener;

    /**
     * Sends request or response to output stream.
     */
    public void sendTo(OutputStream out) throws IOException {
        Buffer buffer = buffer(true);

        if (httpProgressListener == null) {
            buffer.writeTo(out);
        }
        else {
            buffer.writeTo(out, httpProgressListener);
        }

        out.flush();
    }

将缓冲区的数据写入输出流，并发送。

接受数据并读取报文内容：

/**
     * Reads response input stream and returns {@link HttpResponse response}.
     * Supports both streamed and chunked response.
     */
    public static HttpResponse readFrom(InputStream in) {
        InputStreamReader inputStreamReader;
        try {
            inputStreamReader = new InputStreamReader(in, StringPool.ISO_8859_1);
        } catch (UnsupportedEncodingException ignore) {
            return null;
        }
        BufferedReader reader = new BufferedReader(inputStreamReader);

        HttpResponse httpResponse = new HttpResponse();

        // the first line
        String line;
        try {
            line = reader.readLine();
        } catch (IOException ioex) {
            throw new HttpException(ioex);
        }

        if (line != null) {

            line = line.trim();

            int ndx = line.indexOf(' ');
            httpResponse.httpVersion(line.substring(0, ndx));

            int ndx2 = line.indexOf(' ', ndx + 1);
            if (ndx2 == -1) {
                ndx2 = line.length();
            }
            httpResponse.statusCode(Integer.parseInt(line.substring(ndx, ndx2).trim()));

            httpResponse.statusPhrase(line.substring(ndx2).trim());
        }

        httpResponse.readHeaders(reader);
        httpResponse.readBody(reader);

        return httpResponse;
    }

小结

  从上面的代码，我们可以看出http使用socket来建立和destination的连接，然后通过连接的输出流和输入流来进行通信。

参考文献：

【1】http://www.it165.net/admin/html/201403/2541.html

【2】http://jodd.org/doc/http.html