【androidx86 5.1.1】Android HttpClient请求过程解析(下)

接上一篇：【androidx86 5.1.1】Android HttpClient请求过程解析(上)

4、继续调用HttpRequestExecutor的execute函数，其代码位置位于external\apache-http\src\org\apache\http\protocol\HttpRequestExecutor.java

/**

    * Synchronously send a request and obtain the response.

    *

    * @param request  the request tosend. It will be preprocessed.

    * @param conn     the openconnection over which to send

    *

    * @return the response to therequest, postprocessed

    *

    * @throws HttpException     incase of a protocol or processing problem

    * @throws IOException       incase of an I/O problem

    */   

   public HttpResponse execute(

           final HttpRequest request,

           final HttpClientConnection conn,

           final HttpContext context)

               throws IOException,HttpException {

       if (request == null) {

           throw new IllegalArgumentException("HTTP request may not benull");

       }

       if (conn == null) {

           throw new IllegalArgumentException("Client connection may not benull");

       }

       if (context == null) {

           throw new IllegalArgumentException("HTTP context may not benull");

       }

 

       try {

                    //通过doSendRequest函数发送请求，发送成功返回null

           HttpResponse response = doSendRequest(request, conn, context);

           if (response == null) {

                           //发送成功则接受数据

               response =doReceiveResponse(request, conn, context);

           }

           return response;

       } catch (IOException ex) {

           conn.close();

           throw ex;

       } catch (HttpException ex) {

           conn.close();

           throw ex;

       } catch (RuntimeException ex) {

           conn.close();

           throw ex;

       }

}

 

5、接下来通过doSendRequest发送请求，总体作用是判断连接情况，其源代码位于external\apache-http\src\org\apache\http\protocol\HttpRequestExecutor.java

      /**

    * Send a request over a connection.

    * This method also handles the expect-continue handshake if necessary.

    * If it does not have to handle an expect-continue handshake, it will

    * not use the connection for reading or anything else that depends on

    * data coming in over the connection.

    *

    * @param request  the request tosend, already

    *                 {@link #preProcesspreprocessed}

    * @param conn     the connectionover which to send the request,

    *                 alreadyestablished

    * @param context  the context forsending the request

    *

    * @return a terminal responsereceived as part of an expect-continue

    *         handshake, or

    *         <code>null</code> if the expect-continue handshake is notused

    *

    * @throws HttpException     incase of a protocol or processing problem

    * @throws IOException       incase of an I/O problem

    */

   protected HttpResponse doSendRequest(

           final HttpRequest request,

           final HttpClientConnection conn,

           final HttpContext context)

               throws IOException,HttpException {

       if (request == null) {

           throw new IllegalArgumentException("HTTP request may not benull");

       }

       if (conn == null) {

           throw new IllegalArgumentException("HTTP connection may not benull");

       }

       if (context == null) {

           throw new IllegalArgumentException("HTTP context may not benull");

       }

 

       HttpResponse response = null;

       context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.FALSE);

 

             //发送http首部

       conn.sendRequestHeader(request);

       if (request instanceof HttpEntityEnclosingRequest) {

           // Check for expect-continue handshake. We have to flush the

           // headers and wait for an 100-continue response to handle it.

           // If we get a different response, we must not send the entity.

           boolean sendentity = true;

           final ProtocolVersion ver =

               request.getRequestLine().getProtocolVersion();

           if (((HttpEntityEnclosingRequest) request).expectContinue() &&

               !ver.lessEquals(HttpVersion.HTTP_1_0)) {

 

               conn.flush();

               // As suggested by RFC 2616section 8.2.3, we don't wait for a

               // 100-continue responseforever. On timeout, send the entity.

               int tms =request.getParams().getIntParameter(

                       CoreProtocolPNames.WAIT_FOR_CONTINUE, 2000);

               //判断服务端对于连接中的数据状态是否正常

               if(conn.isResponseAvailable(tms)) {

                   response =conn.receiveResponseHeader();

                   if(canResponseHaveBody(request, response)) {

                       conn.receiveResponseEntity(response);

                   }

                   int status = response.getStatusLine().getStatusCode();

                   if (status < 200) {

                       if (status !=HttpStatus.SC_CONTINUE) {

                           throw newProtocolException(

                                   "Unexpected response: " + response.getStatusLine());

                       }

                       // discard 100-continue

                       response = null;

                   } else {

                       sendentity = false;

                   }

               }

           }

                    //如果数据状态正确，则发送内容

           if (sendentity) {

               conn.sendRequestEntity((HttpEntityEnclosingRequest) request);

           }

       }

       conn.flush();

       context.setAttribute(ExecutionContext.HTTP_REQ_SENT, Boolean.TRUE);

       return response;

}

总体来说分为三步，第一步，发送请求行并获取状态行；第二步，判断连接状态；第三步，发送实体。

6、然后通过EntitySerializer.java中的serialize方法进行发送，对应代码位于src\org\apache\http\impl\entity\EntitySerializer.java

public void serialize(

           final SessionOutputBuffer outbuffer,

           final HttpMessage message,

           final HttpEntity entity) throws HttpException, IOException {

       if (outbuffer == null) {

           throw new IllegalArgumentException("Session output buffer may notbe null");

       }

       if (message == null) {

           throw new IllegalArgumentException("HTTP message may not benull");

       }

       if (entity == null) {

           throw new IllegalArgumentException("HTTP entity may not benull");

       }

       OutputStream outstream = doSerialize(outbuffer, message);

       entity.writeTo(outstream);

       outstream.close();

}

 

7、doReceiveResponse接收响应报文，

/**

    * Wait for and receive a response.

    * This method will automatically ignore intermediate responses

    * with status code 1xx.

    *

    * @param request  the request forwhich to obtain the response

    * @param conn     the connectionover which the request was sent

    * @param context  the context forreceiving the response

    *

    * @return the final response, notyet post-processed

    *

    * @throws HttpException     incase of a protocol or processing problem

    * @throws IOException       incase of an I/O problem

    */

   protected HttpResponse doReceiveResponse(

           final HttpRequest         request,

           final HttpClientConnection conn,

           final HttpContext         context)

               throws HttpException,IOException {

             //异常判断

       if (request == null) {

           throw new IllegalArgumentException("HTTP request may not benull");

       }

       if (conn == null) {

           throw new IllegalArgumentException("HTTP connection may not benull");

       }

       if (context == null) {

           throw new IllegalArgumentException("HTTP context may not benull");

       }

 

       HttpResponse response = null;

       int statuscode = 0;

             

            //循环读取返回状态以及响应报文

       while (response == null || statuscode < HttpStatus.SC_OK) {

 

           response = conn.receiveResponseHeader();

           if (canResponseHaveBody(request, response)) {

               conn.receiveResponseEntity(response);

           }

           statuscode = response.getStatusLine().getStatusCode();

 

       } // while intermediate response

 

       return response;

 

}

最后，通过死循环，在statu表明连接正常的情况下不断读取响应报文，读取成功则存储到reponse当中进行返回。