Android HttpClient

超文本传输协议（HTTP）或许是当今互联网上使用的最重要的协议了。Web服务，有网络功能的设备和网络计算的发展。都持续扩展了HTTP协议的角色，超越了用户使用的Web浏览器范畴。同一时候，也添加了须要HTTP协议支持的应用程序的数量。

虽然java.net包提供了基本通过HTTP訪问资源的功能，但它没有提供全面的灵活性和其他非常多应用程序须要的功能。

HttpClient就是寻求弥补这项空白的组件，通过提供一个有效的，保持更新的。功能丰富的软件包来实现client最新的HTTP标准和建议。

为扩展而设计，同一时候为主要的HTTP协议提供强大的支持，HttpClient组件或许就是构建HTTPclient应用程序。比方web浏览器，web服务端，利用或扩展HTTP协议进行分布式通信的系统的开发者的关注点。

1. HttpClient的范围

  • 基于HttpCore[http://hc.apache.org/httpcomponents-core/index.html]的clientHTTP运输实现库
  • 基于经典（堵塞）I/O
  • 内容无关

2. 什么是HttpClient不能做的

  • HttpClient不是一个浏览器。它是一个client的HTTP通信实现库。HttpClient的目标是发送和接收HTTP报文。

    HttpClient不会去缓存内容，运行嵌入在HTML页面中的javascript代码，推測内容类型，又一次格式化请求/重定向URI。或者其他和HTTP运输无关的功能。

第一章 基础

1.1 运行请求

HttpClient最重要的功能是运行HTTP方法。

一个HTTP方法的运行包括一个或多个HTTP请求/HTTP响应交换，通常由HttpClient的内部来处理。

而期望用户提供一个要运行的请求对象，而HttpClient期望传输请求到目标server并返回相应的响应对象，或者当运行不成功时抛出异常。

非常自然地，HttpClient API的主要切入点就是定义描写叙述上述规约的HttpClient接口。

这里有一个非常easy的请求运行过程的演示样例：

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet("http://localhost/");
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream instream = entity.getContent();
int l;
byte[] tmp = new byte[2048];
while ((l = instream.read(tmp)) != -1) {
}
}

1.1.1 HTTP请求

全部HTTP请求有一个组合了方法名，请求URI和HTTP协议版本号的请求行。

HttpClient支持全部定义在HTTP/1.1版本号中的HTTP方法：GET。HEAD，POST，PUT。DELETE，TRACE和OPTIONS。

对于每一个方法类型都有一个特殊的类：HttpGet，HttpHead。HttpPost，HttpPut。HttpDelete，HttpTrace和HttpOptions。

请求的URI是统一资源定位符。它标识了应用于哪个请求之上的资源。HTTP请求URI包括一个协议模式，主机名称，可选的port，资源路径，可选的查询和可选的片段。

HttpGet httpget = new HttpGet(
"http://www.google.com/search?

hl=en&q=httpclient&btnG=Google+Search&aq=f&oq=");

HttpClient提供非常多工具方法来简化创建和改动运行URI。

URI也能够编程来拼装：
URI uri = URIUtils.createURI("http", "www.google.com", -1, "/search",
"q=httpclient&btnG=Google+Search&aq=f&oq=", null);
HttpGet httpget = new HttpGet(uri);
System.out.println(httpget.getURI());

输出内容为：

http://www.google.com/search?

q=httpclient&btnG=Google+Search&aq=f&oq=

查询字符串也能够从独立的參数中来生成：

List<NameValuePair> qparams = new ArrayList<NameValuePair>();
qparams.add(new BasicNameValuePair("q", "httpclient"));
qparams.add(new BasicNameValuePair("btnG", "Google Search"));
qparams.add(new BasicNameValuePair("aq", "f"));
qparams.add(new BasicNameValuePair("oq", null));
URI uri = URIUtils.createURI("http", "www.google.com", -1, "/search",
URLEncodedUtils.format(qparams, "UTF-8"), null);
HttpGet httpget = new HttpGet(uri);
System.out.println(httpget.getURI());

输出内容为：

http://www.google.com/search?

q=httpclient&btnG=Google+Search&aq=f&oq=

1.1.2 HTTP响应

HTTP响应是由server在接收和解释请求报文之后返回发送给client的报文。响应报文的第一行包括了协议版本号，之后是数字状态码和相关联的文本段。

HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1,
HttpStatus.SC_OK, "OK");
System.out.println(response.getProtocolVersion());
System.out.println(response.getStatusLine().getStatusCode());
System.out.println(response.getStatusLine().getReasonPhrase());
System.out.println(response.getStatusLine().toString());

输出内容为：

HTTP/1.1
200
OK
HTTP/1.1 200 OK

1.1.3 处理报文头部

一个HTTP报文能够包括非常多描写叙述如内容长度。内容类型等信息属性的头部信息。

HttpClient提供获取，加入，移除和枚举头部信息的方法。

HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1,
HttpStatus.SC_OK, "OK");
response.addHeader("Set-Cookie",
"c1=a; path=/; domain=localhost");
response.addHeader("Set-Cookie",
"c2=b; path=\"/\", c3=c; domain=\"localhost\"");
Header h1 = response.getFirstHeader("Set-Cookie");
System.out.println(h1);
Header h2 = response.getLastHeader("Set-Cookie");
System.out.println(h2);
Header[] hs = response.getHeaders("Set-Cookie");
System.out.println(hs.length);

输出内容为：

Set-Cookie: c1=a; path=/; domain=localhost
Set-Cookie: c2=b; path="/", c3=c; domain="localhost"

获得给定类型的全部头部信息最有效的方式是使用HeaderIterator接口。

HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1,
HttpStatus.SC_OK, "OK");
response.addHeader("Set-Cookie",
"c1=a; path=/; domain=localhost");
response.addHeader("Set-Cookie",
"c2=b; path=\"/\", c3=c; domain=\"localhost\"");
HeaderIterator it = response.headerIterator("Set-Cookie");
while (it.hasNext()) {
System.out.println(it.next());
}

输出内容为：

Set-Cookie: c1=a; path=/; domain=localhost
Set-Cookie: c2=b; path="/", c3=c; domain="localhost"

它也提供解析HTTP报文到独立头部信息元素的方法方法。

HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1,
HttpStatus.SC_OK, "OK");
response.addHeader("Set-Cookie",
"c1=a; path=/; domain=localhost");
response.addHeader("Set-Cookie",
"c2=b; path=\"/\", c3=c; domain=\"localhost\"");
HeaderElementIterator it = new BasicHeaderElementIterator(
response.headerIterator("Set-Cookie"));
while (it.hasNext()) {
HeaderElement elem = it.nextElement();
System.out.println(elem.getName() + " = " + elem.getValue());
NameValuePair[] params = elem.getParameters();
for (int i = 0; i < params.length; i++) {
System.out.println(" " + params[i]);
}
}

输出内容为：

c1 = a
path=/
domain=localhost
c2 = b
path=/
c3 = c
domain=localhost

1.1.4 HTTP实体

HTTP报文能够携带和请求或响应相关的内容实体。实体能够在一些请求和响应中找到，由于它们也是可选的。使用了实体的请求被称为封闭实体请求。

HTTP规范定义了两种封闭实体的方法：POST和PUT。

响应通常期望包括一个内容实体。

这个规则也有特例，比方HEAD方法的响应和204 No Content，304 Not Modified和205 Reset Content响应。

HttpClient依据其内容出自何处区分三种类型的实体：

  • streamed流式：内容从流中获得，或者在执行中产生。

    特别是这样的分类包括从HTTP响应中获取的实体。

    流式实体是不可反复生成的。

  • self-contained自我包括式：内容在内存中或通过独立的连接或其他实体中获得。自我包括式的实体是能够反复生成的。这样的类型的实体会经经常使用于封闭HTTP请求的实体。
  • wrapping包装式：内容从另外一个实体中获得。

当从一个HTTP响应中获取流式内容时。这个差别对于连接管理非常重要。对于由应用程序创建并且仅仅使用HttpClient发送的请求实体。流式和自我包括式的不同就不那么重要了。这样的情况下，建议考虑如流式这样的不能反复的实体，和能够反复的自我包括式实体。

1.1.4.1 反复实体

实体能够反复。意味着它的内容能够被多次读取。这就不过自我包括式的实体了（像ByteArrayEntity或StringEntity）。

1.1.4.2 使用HTTP实体

由于一个实体既能够代表二进制内容又能够代表字符内容。它也支持字符编码（支持后者也就是字符内容）。

实体是当使用封闭内容运行请求。或当请求已经成功运行。或当响应体结果发功到client时创建的。

要从实体中读取内容，能够通过HttpEntity#getContent()方法从输入流中获取，这会返回一个java.io.InputStream对象。或者提供一个输出流到HttpEntity#writeTo(OutputStream)方法中，这会一次返回全部写入到给定流中的内容。

当实体通过一个收到的报文获取时，HttpEntity#getContentType()方法和HttpEntity#getContentLength()方法能够用来读取通用的元数据，如Content-Type和Content-Length头部信息（假设它们是可用的）。由于头部信息Content-Type能够包括对文本MIME类型的字符编码。比方text/plain或text/html，HttpEntity#getContentEncoding()方法用来读取这个信息。

假设头部信息不可用，那么就返回长度-1，而对于内容类型返回NULL。

假设头部信息Content-Type是可用的，那么就会返回一个Header对象。

当为一个传出报文创建实体时，这个元数据不得不通过实体创建器来提供。

StringEntity myEntity = new StringEntity("important message",
"UTF-8");
System.out.println(myEntity.getContentType());
System.out.println(myEntity.getContentLength());
System.out.println(EntityUtils.getContentCharSet(myEntity));
System.out.println(EntityUtils.toString(myEntity));
System.out.println(EntityUtils.toByteArray(myEntity).length);

输出内容为

Content-Type: text/plain; charset=UTF-8
17
UTF-8
important message
17

1.1.5 确保低级别资源释放

当完毕一个响应实体，那么保证全部实体内容已经被全然消耗是非常重要的。所以连接能够安全的放回到连接池中，并且能够通过连接管理器对兴许的请求重用连接。处理这个操作的最方便的方法是调用HttpEntity#consumeContent()方法来消耗流中的随意可用内容。

HttpClient探測到内容流尾部已经到达后，会马上会自己主动释放低层连接，并放回到连接管理器。HttpEntity#consumeContent()方法调用多次也是安全的。

也可能会有特殊情况。当整个响应内容的一小部分须要获取，消耗剩余内容而损失性能。还有重用连接的代价太高，则能够只通过调用HttpUriRequest#abort()方法来中止请求。

HttpGet httpget = new HttpGet("http://localhost/");
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream instream = entity.getContent();
int byteOne = instream.read();
int byteTwo = instream.read();
// Do not need the rest
httpget.abort();
}

连接不会被重用，可是由它持有的全部级别的资源将会被正确释放。

1.1.6 消耗实体内容

推荐消耗实体内容的方式是使用它的HttpEntity#getContent()或HttpEntity#writeTo(OutputStream)方法。HttpClient也自带EntityUtils类，这会暴露出一些静态方法。这些方法能够更加easy地从实体中读取内容或信息。

取代直接读取java.io.InputStream。也能够使用这个类中的方法以字符串/字节数组的形式获取整个内容体。然而。EntityUtils的使用是强烈不鼓舞的，除非响应实体源自可靠的HTTPserver和已知的长度限制。

HttpGet httpget = new HttpGet("http://localhost/");
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
long len = entity.getContentLength();
if (len != -1 && len < 2048) {
System.out.println(EntityUtils.toString(entity));
} else {
// Stream content out
}
}

在一些情况下可能会不止一次的读取实体。此时实体内容必须以某种方式在内存或磁盘上被缓冲起来。最简单的方法是通过使用BufferedHttpEntity类来包装源实体完毕。这会引起源实体内容被读取到内存的缓冲区中。在其他全部方式中。实体包装器将会得到源实体。

HttpGet httpget = new HttpGet("http://localhost/");
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
if (entity != null) {
entity = new BufferedHttpEntity(entity);
}

1.1.7 生成实体内容

HttpClient提供一些类，它们能够用于生成通过HTTP连接获得内容的有效输出流。为了封闭实体从HTTP请求中获得的输出内容，那些类的实例能够和封闭如POST和PUT请求的实体相关联。

HttpClient为非常多公用的数据容器。比方字符串。字节数组，输入流和文件提供了一些类：StringEntity，ByteArrayEntity。InputStreamEntity和FileEntity。

File file = new File("somefile.txt");
FileEntity entity = new FileEntity(file, "text/plain; charset=\"UTF-8\"");
HttpPost httppost = new HttpPost("http://localhost/action.do");
httppost.setEntity(entity);

请注意InputStreamEntity是不可反复的。由于它只能从低层数据流中读取一次内容。通常来说，我们推荐实现一个定制的HttpEntity类，这是自我包括式的，用来取代使用通用的InputStreamEntity。FileEntity也是一个非常好的起点。

1.1.7.1 动态内容实体

通常来说，HTTP实体须要基于特定的运行上下文来动态地生成。通过使用EntityTemplate实体类和ContentProducer接口。HttpClient提供了动态实体的支持。内容生成器是依照需求生成它们内容的对象，将它们写入到一个输出流中。它们是每次被请求时来生成内容。所以用EntityTemplate创建的实体一般是自我包括并且能够反复的。

ContentProducer cp = new ContentProducer() {
public void writeTo(OutputStream outstream) throws IOException {
Writer writer = new OutputStreamWriter(outstream, "UTF-8");
writer.write("<response>");
writer.write(" <content>");
writer.write(" important stuff");
writer.write(" </content>");
writer.write("</response>");
writer.flush();
}
};
HttpEntity entity = new EntityTemplate(cp);
HttpPost httppost = new HttpPost("http://localhost/handler.do");
httppost.setEntity(entity);
1.1.7.2 HTML表单

很多应用程序须要频繁模拟提交一个HTML表单的过程。比方。为了来记录一个Web应用程序或提交输出数据。HttpClient提供了特殊的实体类UrlEncodedFormEntity来这个满足过程。

List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("param1", "value1"));
formparams.add(new BasicNameValuePair("param2", "value2"));
UrlEncodedFormEntity entity = new UrlEncodedFormEntity(formparams, "UTF-8");
HttpPost httppost = new HttpPost("http://localhost/handler.do");
httppost.setEntity(entity);

UrlEncodedFormEntity实例将会使用URL编码来编码參数。生成例如以下的内容：

param1=value1&param2=value2

1.1.7.3 内容分块

通常。我们推荐让HttpClient选择基于被传递的HTTP报文属性的最适合的编码转换。这是可能的，可是，设置HttpEntity#setChunked()方法为true是通知HttpClient分块编码的首选。请注意HttpClient将会使用标识作为提示。

当使用的HTTP协议版本号，如HTTP/1.0版本号。不支持分块编码时。这个值会被忽略。

StringEntity entity = new StringEntity("important message",
"text/plain; charset=\"UTF-8\"");
entity.setChunked(true);
HttpPost httppost = new HttpPost("http://localhost/acrtion.do");
httppost.setEntity(entity);

1.1.8 响应控制器

控制响应的最简便和最方便的方式是使用ResponseHandler接口。

这个放完全然减轻了用户关于连接管理的操心。当使用ResponseHandler时，HttpClient将会自己主动关注并保证释放连接到连接管理器中去，而无论请求运行是否成功或引发了异常。

HttpClient httpclient = new DefaultHttpClient();
HttpGet httpget = new HttpGet("http://localhost/");
ResponseHandler<byte[]> handler = new ResponseHandler<byte[]>() {
public byte[] handleResponse(
HttpResponse response) throws ClientProtocolException, IOException {
HttpEntity entity = response.getEntity();
if (entity != null) {
return EntityUtils.toByteArray(entity);
} else {
return null;
}
}
};
byte[] response = httpclient.execute(httpget, handler);

1.2 HTTP运行的环境

最初，HTTP是被设计成无状态的，面向请求-响应的协议。然而，真实的应用程序常常须要通过一些逻辑相关的请求-响应交换来持久状态信息。为了开启应用程序来维持一个过程状态，HttpClient同意HTTP请求在一个特定的运行环境中来运行，简称为HTTP上下文。假设同样的环境在连续请求之间重用。那么多种逻辑相关的请求能够參与到一个逻辑会话中。HTTP上下文功能和java.util.Map<String,Object>非常相似。它不过随意命名參数值的集合。应用程序能够在请求之前或在检查上下文运行完毕之后来填充上下文属性。

在HTTP请求运行的这一过程中，HttpClient加入了下列属性到运行上下文中：

  • 'http.connection'：HttpConnection实例代表了连接到目标server的真实连接。
  • 'http.target_host'：HttpHost实例代表了连接目标。

  • 'http.proxy_host'：假设使用了，HttpHost实例代表了代理连接。

  • 'http.request'：HttpRequest实例代表了真实的HTTP请求。

  • 'http.response'：HttpResponse实例代表了真实的HTTP响应。
  • 'http.request_sent'：java.lang.Boolean对象代表了暗示真实请求是否被全然传送到目标连接的标识。

比方，为了决定终于的重定向目标，在请求运行之后。能够检查http.target_host属性的值：

DefaultHttpClient httpclient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
HttpGet httpget = new HttpGet("http://www.google.com/");
HttpResponse response = httpclient.execute(httpget, localContext);
HttpHost target = (HttpHost) localContext.getAttribute(
ExecutionContext.HTTP_TARGET_HOST);
System.out.println("Final target: " + target);
HttpEntity entity = response.getEntity();
if (entity != null) {
entity.consumeContent();
}

输出内容为：

Final target: http://www.google.ch

1.3 异常处理

HttpClient可以抛出两种类型的异常：在I/O失败时，如套接字连接超时或被重置的java.io.IOException异常，还有标志HTTP请求失败的信号。如违反HTTP协议的HttpException异常。通常I/O错误被觉得是非致命的和可以恢复的。而HTTP协议错误则被觉得是致命的并且是不能自己主动恢复的。

1.3.1 HTTP运输安全

要理解HTTP协议并非对全部类型的应用程序都适合的。这一点非常重要。HTTP是一个简单的面向请求/响应的协议，最初被设计用来支持取回静态或动态生成的内容。

它从未向支持事务性操作方向发展。比方，假设成功收到和处理请求。HTTPserver将会考虑它的当中一部分是否完毕，生成一个响应并发送一个状态码到client。假设client由于读取超时，请求取消或系统崩溃导致接收响应实体失败时。server不会试图回滚事务。假设client决定又一次这个请求，那么server将不可避免地不止一次运行这个同样的事务。

在一些情况下，这会导致应用数据损坏或者不一致的应用程序状态。

虽然HTTP从来都没有被设计来支持事务性处理，但它也能被用作于一个传输协议对关键的任务应用提供被满足的确定状态。要保证HTTP传输层的安全，系统必须保证HTTP方法在应用层的幂等性。

1.3.2 幂等的方法

HTTP/1.1 明白地定义了幂等的方法，描写叙述例如以下

[方法也能够有“幂等”属性在那些（除了错误或过期问题）N的副作用>0的同样请求和独立的请求是同样的]

换句话说，应用程序应该保证准备着来处理多个同样方法运行的实现。这是能够达到的。比方，通过提供一个独立的事务ID和其他避免运行同样逻辑操作的方法。

请注意这个问题对于HttpClient是不详细的。基于应用的浏览器特别受和非幂等的HTTP方法相关的同样问题的限制。

HttpClient如果没有实体包括方法。比方GET和HEAD是幂等的。而实体包括方法。比方POST和PUT则不是。

1.3.3 异常自己主动恢复

默认情况下。HttpClient会试图自己主动从I/O异常中恢复。默认的自己主动恢复机制是受非常少一部分已知的异常是安全的这个限制。

  • HttpClient不会从随意逻辑或HTTP协议错误（那些是从HttpException类中派生出的）中恢复的。
  • HttpClient将会自己主动又一次运行那么如果是幂等的方法。
  • HttpClient将会自己主动又一次运行那些因为运输异常失败，而HTTP请求仍然被传送到目标server（也就是请求没有全然被送到server）失败的方法。

  • HttpClient将会自己主动又一次运行那些已经全然被送到server，可是server使用HTTP状态码（server只丢掉连接而不会发回不论什么东西）响应时失败的方法。

    在这样的情况下，如果请求没有被server处理，而应用程序的状态也没有改变。

    如果这个如果可能对于你应用程序的目标Webserver来说不对。那么就强烈建议提供一个自己定义的异常处理器。

1.3.4 请求重试处理

为了开启自己定义异常恢复机制。应该提供一个HttpRequestRetryHandler接口的实现。

DefaultHttpClient httpclient = new DefaultHttpClient();
HttpRequestRetryHandler myRetryHandler = new HttpRequestRetryHandler() {
public boolean retryRequest(IOException exception,
int executionCount,HttpContext context) {
if (executionCount >= 5) {
// 假设超过最大重试次数，那么就不要继续了
return false;
}
if (exception instanceof NoHttpResponseException) {
// 假设server丢掉了连接，那么就重试
return true;
}
if (exception instanceof SSLHandshakeException) {
// 不要重试SSL握手异常
return false;
}
HttpRequest request = (HttpRequest) context.getAttribute(
ExecutionContext.HTTP_REQUEST);
boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
if (idempotent) {
// 假设请求被觉得是幂等的。那么就重试
return true;
}
return false;
}
};
httpclient.setHttpRequestRetryHandler(myRetryHandler);

1.4 中止请求

在一些情况下，因为目标server的高负载或client有非常多活动的请求。那么HTTP请求运行会在预期的时间框内而失败。这时，就可能不得只是早地中止请求，解除封锁在I/O运行中的线程封锁。被HttpClient运行的HTTP请求能够在运行的随意阶段通过调用HttpUriRequest#abort()方法而中止。这种方法是线程安全的，并且能够从随意线程中调用。当一个HTTP请求被中止时，它的运行线程就封锁在I/O操作中了，并且保证通过抛出InterruptedIOException异常来解锁。

1.5 HTTP协议拦截器

HTTP协议拦截器是一个实现了特定HTPP协议方面的惯例。

通常协议拦截器希望作用于一个特定头部信息上，或者一族收到报文的相关头部信息。或使用一个特定的头部或一族相关的头部信息填充发出的报文。协议拦截器也能够操纵包括在报文中的内容实体，透明的内容压缩/解压就是一个非常好的演示样例。

通常情况下这是由包装器实体类使用了“装饰者”模式来装饰原始的实体完毕的。

一些协议拦截器能够从一个逻辑单元中来结合。

协议拦截器也能够通过共享信息来共同合作-比方处理状态-通过HTTP运行上下文。

协议拦截器能够使用HTTP内容来为一个或多个连续的请求存储一个处理状态。

通常拦截器运行的顺序不应该和它们基于的特定运行上下文状态有关。假设协议拦截器有相互依存关系，那么它们必须按特定顺序来运行，正如它们希望运行的顺序一样。它们应该在同样的序列中被加到协议处理器。

协议拦截器必须实现为线程安全的。和Servlet相似。协议拦截器不应该使用实例变量，除非訪问的那些变量是同步的。

这个演示样例给出了本地内容在连续的请求中怎么被用于持久一个处理状态的：

DefaultHttpClient httpclient = new DefaultHttpClient();
HttpContext localContext = new BasicHttpContext();
AtomicInteger count = new AtomicInteger(1);
localContext.setAttribute("count", count);
httpclient.addRequestInterceptor(new HttpRequestInterceptor() {
public void process(final HttpRequest request,
final HttpContext context) throws HttpException, IOException {
AtomicInteger count = (AtomicInteger) context.getAttribute("count");
request.addHeader("Count", Integer.toString(count.getAndIncrement()));
}
});
HttpGet httpget = new HttpGet("http://localhost/");
for (int i = 0; i < 10; i++) {
HttpResponse response = httpclient.execute(httpget, localContext);
HttpEntity entity = response.getEntity();
if (entity != null) {
entity.consumeContent();
}
}

1.6 HTTP參数

HttpParams接口代表了定义组件执行时行为的一个不变的值的集合。非常多情况下。HttpParams和HttpContext相似。二者之间的主要差别是它们在执行时使用的不同。这两个接口表示了对象的集合。它们被视作为訪问对象值的键的Map，可是服务于不同的目的：

  • HttpParams旨在包括简单对象：整型，浮点型。字符串，集合，还有运行时不变的对象。

  • HttpParams希望被用在“一次写入-多处准备”模式下。

    HttpContext旨在包括非常可能在HTTP报文处理这一过程中发生改变的复杂对象

  • HttpParams的目标是定义其他组件的行为。

    通常每个复杂的组件都有它自己的HttpParams对象。HttpContext的目标是来表示一个HTTP处理的运行状态。通常同样的运行上下文在非常多合作的对象中共享。

1.6.1 參数层次

在HTTP请求运行过程中。HttpRequest对象的HttpParams是和用于运行请求的HttpClient实例的HttpParams联系在一起的。这使得设置在HTTP请求级别的參数优先于设置在HTTPclient级别的HttpParams。

推荐的做法是设置普通參数对全部的在HTTPclient级别的HTTP请求共享。并且能够选择性重写详细在HTTP请求级别的參数。

DefaultHttpClient httpclient = new DefaultHttpClient();
httpclient.getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION,HttpVersion.HTTP_1_0);
httpclient.getParams().setParameter(CoreProtocolPNames.HTTP_CONTENT_CHARSET,"UTF-8");
HttpGet httpget = new HttpGet("http://www.google.com/");
httpget.getParams().setParameter(CoreProtocolPNames.PROTOCOL_VERSION,HttpVersion.HTTP_1_1);
httpget.getParams().setParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE,Boolean.FALSE);
httpclient.addRequestInterceptor(new HttpRequestInterceptor() {
public void process(final HttpRequest request,
final HttpContext context) throws HttpException, IOException {
System.out.println(request.getParams().getParameter(
CoreProtocolPNames.PROTOCOL_VERSION));
System.out.println(request.getParams().getParameter(
CoreProtocolPNames.HTTP_CONTENT_CHARSET));
System.out.println(request.getParams().getParameter(
CoreProtocolPNames.USE_EXPECT_CONTINUE));
System.out.println(request.getParams().getParameter(
CoreProtocolPNames.STRICT_TRANSFER_ENCODING));
}
});

输出内容为：

HTTP/1.1
UTF-8
false
null

1.6.2 HTTP參数bean

HttpParams接口同意在处理组件的配置上非常大的灵活性。非常重要的是，新的參数能够被引入而不会影响老版本号的二进制兼容性。

然而，和常规的Java bean相比，HttpParams也有一个缺点：HttpParams不能使用DI框架来组合。

为了缓解这个限制。HttpClient包括了一些bean类，它们能够用来按顺序使用标准的Java eban惯例初始化HttpParams对象。

HttpParams params = new BasicHttpParams();
HttpProtocolParamBean paramsBean = new HttpProtocolParamBean(params);
paramsBean.setVersion(HttpVersion.HTTP_1_1);
paramsBean.setContentCharset("UTF-8");
paramsBean.setUseExpectContinue(true);
System.out.println(params.getParameter(
CoreProtocolPNames.PROTOCOL_VERSION));
System.out.println(params.getParameter(
CoreProtocolPNames.HTTP_CONTENT_CHARSET));
System.out.println(params.getParameter(
CoreProtocolPNames.USE_EXPECT_CONTINUE));
System.out.println(params.getParameter(
CoreProtocolPNames.USER_AGENT));

输出内容为：

HTTP/1.1
UTF-8
false
null

1.7 HTTP请求运行參数

这些參数会影响到请求运行的过程：

  • 'http.protocol.version'：假设没有在请求对象中设置明白的版本号信息。它就定义了使用的HTTP协议版本号。

    这个參数期望得到一个ProtocolVersion类型的值。假设这个參数没有被设置，那么就使用HTTP/1.1。

  • 'http.protocol.element-charset'：定义了编码HTTP协议元素的字符集。

    这个參数期望得到一个java.lang.String类型的值。

    假设这个參数没有被设置，那么就使用US-ASCII。

  • 'http.protocol.eontent-charset'：定义了为每一个内容主体编码的默认字符集。

    这个參数期望得到一个java.lang.String类型的值。

    假设这个參数没有被设置。那么就使用ISO-8859-1。

  • 'http.useragent'：定义了头部信息User-Agent的内容。这个參数期望得到一个java.lang.String类型的值。

    假设这个參数没有被设置，那么HttpClient将会为它自己主动生成一个值。

  • 'http.protocol.strict-transfer-encoding'：定义了响应头部信息中是否含有一个非法的Transfer-Encoding。都要拒绝掉。
  • 'http.protocol.expect-continue'：为包括方法的实体激活Expect: 100-Continue握手。Expect: 100-Continue握手的目的是同意client使用请求体发送一个请求信息来决定源server是否希望在client发送请求体之前得到这个请求（基于请求头部信息）。

    Expect: 100-Continue握手的使用能够对须要目标server认证的包括请求的实体（比方POST和PUT）导致明显的性能改善。Expect: 100-Continue握手应该慎重使用。由于它和HTTPserver，不支持HTTP/1.1协议的代理使用会引起问题。这个參数期望得到一个java.lang.Boolean类型的值。假设这个參数没有被设置。那么HttpClient将会试图使用握手。

  • 'http.protocol.wait-for-continue'：定义了client应该等待100-Continue响应最大的毫秒级时间间隔。

    这个參数期望得到一个java.lang.Integer类型的值。

    假设这个參数没有被设置，那么HttpClient将会在恢复请求体传输之前为确认等待3秒。

 

posted @ 2017-04-29 17:11  yfceshi  阅读(219)  评论(0)  编辑  收藏  举报