## org.apache.http.protocol
Class HttpRequestExecutor

    java.lang.Object
      org.apache.http.protocol.HttpRequestExecutor

    @Immutable
    public class HttpRequestExecutor

extends Object

`HttpRequestExecutor` is a client side HTTP protocol handler based on the blocking (classic) I/O model.

`HttpRequestExecutor` relies on `HttpProcessor` to generate mandatory protocol headers for all outgoing messages and apply common, cross-cutting message transformations to all incoming and outgoing messages. Application specific processing can be implemented outside `HttpRequestExecutor` once the request has been executed and a response has been received.

The following parameters can be used to customize the behavior of this class:

- `CoreProtocolPNames.WAIT_FOR_CONTINUE`

Since:
  4.0

Constructor Summary
`HttpRequestExecutor()` Create a new request executor.

Method Summary
`protected boolean` `canResponseHaveBody(HttpRequest request, HttpResponse response)` Decide whether a response comes with an entity.
`protected HttpResponse` `doReceiveResponse(HttpRequest request, HttpClientConnection conn, HttpContext context)` Waits for and receives a response.
`protected HttpResponse` `doSendRequest(HttpRequest request, HttpClientConnection conn, HttpContext context)` Send the given request over the given connection.
`HttpResponse` `execute(HttpRequest request, HttpClientConnection conn, HttpContext context)` Sends the request and obtain a response.
`void` `postProcess(HttpResponse response, HttpProcessor processor, HttpContext context)` Post-processes the given response using the given protocol processor and completes the process of request execution.
`void` `preProcess(HttpRequest request, HttpProcessor processor, HttpContext context)` Pre-process the given request using the given protocol processor and initiates the process of request execution.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### HttpRequestExecutor

    public HttpRequestExecutor()

  Create a new request executor.

Method Detail

### canResponseHaveBody

    protected boolean canResponseHaveBody(HttpRequest request,
                                          HttpResponse response)

  Decide whether a response comes with an entity. The implementation in this class is based on RFC 2616.
  Derived executors can override this method to handle methods and response codes not specified in RFC 2616.

  Parameters:
    `request` - the request, to obtain the executed method
    `response` - the response, to obtain the status code

### execute

    public HttpResponse execute(HttpRequest request,
                                HttpClientConnection conn,
                                HttpContext context)
                         throws IOException,
                                HttpException

  Sends the request and obtain a response.

  Parameters:
    `request` - the request to execute.
    `conn` - the connection over which to execute the request.
  Returns:
    the response to the request.
  Throws:
    `IOException` - in case of an I/O error.
    `HttpException` - in case of HTTP protocol violation or a processing problem.

### preProcess

    public void preProcess(HttpRequest request,
                           HttpProcessor processor,
                           HttpContext context)
                    throws HttpException,
                           IOException

  Pre-process the given request using the given protocol processor and initiates the process of request execution.

  Parameters:
    `request` - the request to prepare
    `processor` - the processor to use
    `context` - the context for sending the request
  Throws:
    `IOException` - in case of an I/O error.
    `HttpException` - in case of HTTP protocol violation or a processing problem.

### doSendRequest

    protected HttpResponse doSendRequest(HttpRequest request,
                                         HttpClientConnection conn,
                                         HttpContext context)
                                  throws IOException,
                                         HttpException

  Send the given request over the given 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.

  Parameters:
    `request` - the request to send, already `preprocessed`
    `conn` - the connection over which to send the request, already established
    `context` - the context for sending the request
  Returns:
    a terminal response received as part of an expect-continue handshake, or `null` if the expect-continue handshake is not used
  Throws:
    `IOException` - in case of an I/O error.
    `HttpException` - in case of HTTP protocol violation or a processing problem.

### doReceiveResponse

    protected HttpResponse doReceiveResponse(HttpRequest request,
                                             HttpClientConnection conn,
                                             HttpContext context)
                                      throws HttpException,
                                             IOException

  Waits for and receives a response. This method will automatically ignore intermediate responses with status code 1xx.

  Parameters:
    `request` - the request for which to obtain the response
    `conn` - the connection over which the request was sent
    `context` - the context for receiving the response
  Returns:
    the terminal response, not yet post-processed
  Throws:
    `IOException` - in case of an I/O error.
    `HttpException` - in case of HTTP protocol violation or a processing problem.

### postProcess

    public void postProcess(HttpResponse response,
                            HttpProcessor processor,
                            HttpContext context)
                     throws HttpException,
                            IOException

  Post-processes the given response using the given protocol processor and completes the process of request execution.

  This method does not read the response entity, if any. The connection over which content of the response entity is being streamed from cannot be reused until `EntityUtils.consume(HttpEntity)` has been invoked.

  Parameters:
    `response` - the response object to post-process
    `processor` - the processor to use
    `context` - the context for post-processing the response
  Throws:
    `IOException` - in case of an I/O error.
    `HttpException` - in case of HTTP protocol violation or a processing problem.

Copyright © 2005-2013 The Apache Software Foundation. All Rights Reserved.