HttpClient 教程_httpclient将httpresponse写入outputstream

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握手的目的是允许客户端使用请求体发送一个请求信息来决定源服务器是否希望在客户端发送请求体之前得到这个请求（基于请求头部信息）。Expect: 100-Continue握手的使用可以对需要目标服务器认证的包含请求的实体（比如POST和PUT）导致明显的性能改善。Expect: 100-Continue握手应该谨慎使用，因为它和HTTP服务器，不支持HTTP/1.1协议的代理使用会引起问题。这个参数期望得到一个java.lang.Boolean类型的值。如果这个参数没有被设置，那么HttpClient将会试图使用握手。
• 'http.protocol.wait-for-continue'：定义了客户端应该等待100-Continue响应最大的毫秒级时间间隔。这个参数期望得到一个java.lang.Integer类型的值。如果这个参数没有被设置，那么HttpClient将会在恢复请求体传输之前为确认等待3秒。

HttpClient有一个对连接初始化和终止，还有在活动连接上I/O操作的完整控制。而连接操作的很多方面可以使用一些参数来控制。

2.1 连接参数

这些参数可以影响连接操作：

• 'http.socket.timeout'：定义了套接字的毫秒级超时时间（SO_TIMEOUT），这就是等待数据，换句话说，在两个连续的数据包之间最大的闲置时间。如果超时时间是0就解释为是一个无限大的超时时间。这个参数期望得到一个java.lang.Integer类型的值。如果这个参数没有被设置，那么读取操作就不会超时（无限大的超时时间）。
• 'http.tcp.nodelay'：决定了是否使用Nagle算法。Nagle算法视图通过最小化发送的分组数量来节省带宽。当应用程序希望降低网络延迟并提高性能时，它们可以关闭Nagle算法（也就是开启TCP_NODELAY）。数据将会更早发送，增加了带宽消耗的成文。这个参数期望得到一个java.lang.Boolean类型的值。如果这个参数没有被设置，那么TCP_NODELAY就会开启（无延迟）。
• 'http.socket.buffer-size'：决定了内部套接字缓冲使用的大小，来缓冲数据同时接收/传输HTTP报文。这个参数期望得到一个java.lang.Integer类型的值。如果这个参数没有被设置，那么HttpClient将会分配8192字节的套接字缓存。
• 'http.socket.linger'：使用指定的秒数拖延时间来设置SO_LINGER。最大的连接超时值是平台指定的。值0暗示了这个选项是关闭的。值-1暗示了使用了JRE默认的。这个设置仅仅影响套接字关闭操作。如果这个参数没有被设置，那么就假设值为-1（JRE默认）。
• 'http.connection.timeout'：决定了直到连接建立时的毫秒级超时时间。超时时间的值为0解释为一个无限大的时间。这个参数期望得到一个java.lang.Integer类型的值。如果这个参数没有被设置，连接操作将不会超时（无限大的超时时间）。
• 'http.connection.stalecheck'：决定了是否使用旧的连接检查。当在一个连接之上执行一个请求而服务器端的连接已经关闭时，关闭旧的连接检查可能导致在获得一个I/O错误风险时显著的性能提升（对于每一个请求，检查时间可以达到30毫秒）。这个参数期望得到一个java.lang.Boolean类型的值。出于性能的关键操作，检查应该被关闭。如果这个参数没有被设置，那么旧的连接将会在每个请求执行之前执行。
• 'http.connection.max-line-length'：决定了最大请求行长度的限制。如果设置为一个正数，任何HTTP请求行超过这个限制将会引发java.io.IOException异常。负数或零将会关闭这个检查。这个参数期望得到一个java.lang.Integer类型的值。如果这个参数没有被设置，那么就不强制进行限制了。
• 'http.connection.max-header-count'：决定了允许的最大HTTP头部信息数量。如果设置为一个正数，从数据流中获得的HTTP头部信息数量超过这个限制就会引发java.io.IOException异常。负数或零将会关闭这个检查。这个参数期望得到一个java.lang.Integer类型的值。如果这个参数没有被设置，那么就不
• 强制进行限制了。
• 'http.connection.max-status-line-garbage'：决定了在期望得到HTTP响应状态行之前可忽略请求行的最大数量。使用HTTP/1.1持久性连接，这个问题产生的破碎的脚本将会返回一个错误的Content-Length（有比指定的字节更多的发送）。不幸的是，在某些情况下，这个不能在错误响应后来侦测，只能在下一次之前。所以HttpClient必须以这种方式跳过那些多余的行。这个参数期望得到一个java.lang.Integer类型的值。0是不允许在状态行之前的所有垃圾/空行。使用java.lang.Integer#MAX_VALUE来设置不限制的数字。如果这个参数没有被设置那就假设是不限制的。

2.2 持久连接

从一个主机向另外一个建立连接的过程是相当复杂的，而且包含了两个终端之间的很多包的交换，它是相当费时的。连接握手的开销是很重要的，特别是对小量的HTTP报文。如果打开的连接可以被重用来执行多次请求，那么就可以达到很高的数据吞吐量。

HTTP/1.1强调HTTP连接默认情况可以被重用于多次请求。HTTP/1.0兼容的终端也可以使用相似的机制来明确地交流它们的偏好来保证连接处于活动状态，也使用它来处理多个请求。HTTP代理也可以保持空闲连接处于一段时间的活动状态，防止对相同目标主机的一个连接也许对随后的请求需要。保持连接活动的能力通常被称作持久性连接。HttpClient完全支持持久性连接。

2.3 HTTP连接路由

HttpClient能够直接或通过路由建立连接到目标主机，这会涉及多个中间连接，也被称为跳。HttpClient区分路由和普通连接，通道和分层。通道连接到目标主机的多个中间代理的使用也称作是代理链。

普通路由由连接到目标或仅第一次的代理来创建。通道路由通过代理链到目标连接到第一通道来建立。没有代理的路由不是通道的，分层路由通过已存在连接的分层协议来建立。协议仅仅可以在到目标的通道上或在没有代理的直接连接上分层。

2.3.1 路由计算

RouteInfo接口代表关于最终涉及一个或多个中间步骤或跳的目标主机路由的信息。HttpRoute是RouteInfo的具体实现，这是不能改变的（是不变的）。HttpTracker是可变的RouteInfo实现，由HttpClient在内部使用来跟踪到最大路由目标的剩余跳数。HttpTracker可以在成功执行向路由目标的下一跳之后更新。HttpRouteDirector是一个帮助类，可以用来计算路由中的下一跳。这个类由HttpClient在内部使用。

HttpRoutePlanner是一个代表计算到基于执行上下文到给定目标完整路由策略的接口。HttpClient附带两个默认的HttpRoutePlanner实现。ProxySelectorRoutePlanner是基于java.net.ProxySelector的。默认情况下，它会从系统属性中或从运行应用程序的浏览器中选取JVM的代理设置。DefaultHttpRoutePlanner实现既不使用任何Java系统属性，也不使用系统或浏览器的代理设置。它只基于HTTP如下面描述的参数计算路由。

2.3.2 安全HTTP连接

如果信息在两个不能由非认证的第三方进行读取或修改的终端之间传输，HTTP连接可以被认为是安全的。SSL/TLS协议是用来保证HTTP传输安全使用最广泛的技术。而其它加密技术也可以被使用。通常来说，HTTP传输是在SSL/TLS加密连接之上分层的。

2.4 HTTP路由参数

• 'http.route.default-proxy'：定义可以被不使用JRE设置的默认路由规划者使用的代理主机。这个参数期望得到一个HttpHost类型的值。如果这个参数没有被设置，那么就会尝试直接连接到目标。
• 'http.route.local-address'：定义一个本地地址由所有默认路由规划者来使用。有多个网络接口的机器中，这个参数可以被用于从连接源中选择网络接口。这个参数期望得到一个java.net.InetAddress类型的值。如果这个参数没有被设置，将会自动使用本地地址。
• 'http.route.forced-route'：定义一个由所有默认路由规划者使用的强制路由。代替了计算路由，给定的强制路由将会被返回，尽管它指向一个完全不同的目标主机。这个参数期望得到一个HttpRoute类型的值。如果这个参数没有被设置，那么就使用默认的规则建立连接到目标服务器。

2.5 套接字工厂

LayeredSocketFactory是SocketFactory接口的扩展。分层的套接字工厂可HTTP连接内部使用java.net.Socket对象来处理数据在线路上的传输。它们依赖SocketFactory接口来创建，初始化和连接套接字。这会使得HttpClient的用户可以提供在运行时指定套接字初始化代码的应用程序。PlainSocketFactory是创建和初始化普通的（不加密的）套接字的默认工厂。

创建套接字的过程和连接到主机的过程是不成对的，所以套接字在连接操作封锁时可以被关闭。

    PlainSocketFactory sf = PlainSocketFactory.getSocketFactory();
    Socket socket = sf.createSocket();
    HttpParams params = new BasicHttpParams();
    params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1000L);
    sf.connectSocket(socket, "locahost", 8080, null, -1, params);

2.5.1 安全套接字分层

LayeredSocketFactory是SocketFactory接口的扩展。分层的套接字工厂可以创建在已经存在的普通套接字之上的分层套接字。套接字分层主要通过代理来创建安全的套接字。HttpClient附带实现了SSL/TLS分层的SSLSocketFactory。请注意HttpClient不使用任何自定义加密功能。它完全依赖于标准的Java密码学（JCE）和安全套接字（JSEE）扩展。

2.5.2 SSL/TLS的定制

HttpClient使用SSLSocketFactory来创建SSL连接。SSLSocketFactory允许高度定制。它可以使用javax.net.ssl.SSLContext的实例作为参数，并使用它来创建定制SSL连接。

    TrustManager easyTrustManager = new X509TrustManager() {
    @Override
    public void checkClientTrusted(X509Certificate[] chain,
    String authType) throws CertificateException {
    // 哦，这很简单！
    }
    @Override
    public void checkServerTrusted(X509Certificate[] chain,
    String authType) throws CertificateException {
    //哦，这很简单！
    }
    @Override
    public X509Certificate[] getAcceptedIssuers() {
    return null;
    }
    };
    SSLContext sslcontext = SSLContext.getInstance("TLS");
    sslcontext.init(null, new TrustManager[] { easyTrustManager }, null);
    SSLSocketFactory sf = new SSLSocketFactory(sslcontext);
    SSLSocket socket = (SSLSocket) sf.createSocket();
    socket.setEnabledCipherSuites(new String[] { "SSL_RSA_WITH_RC4_128_MD5" });
    HttpParams params = new BasicHttpParams();
    params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 1000L);
    sf.connectSocket(socket, "locahost", 443, null, -1, params);

2.5.3 主机名验证

• StrictHostnameVerifier：严格的主机名验证在Sun Java 1.4，Sun Java 5和Sun Java 6中是相同的。而且也非常接近IE6。这个实现似乎是兼容RFC 2818处理通配符的。主机名必须匹配第一个CN或任意的subject-alt。在CN和其它任意的subject-alt中可能会出现通配符。
• BrowserCompatHostnameVerifier：主机名验证器和Curl和Firefox的工作方式是相同的。主机名必须匹配第一个CN或任意的subject-alt。在CN和其它任意的subject-alt中可能会出现通配符。BrowserCompatHostnameVerifier和StrictHostnameVerifier的唯一不同是使用BrowserCompatHostnameVerifier匹配所有子域的通配符（比如”*.foo.com”），包括”a.b.foo.com”。
• AllowAllHostnameVerifier：这个主机名验证器基本上是关闭主机名验证的。这个实现是一个空操作，而且不会抛出javax.net.ssl.SSLException异常。

每一个默认的HttpClient使用BrowserCompatHostnameVerifier的实现。如果需要的话，它可以指定不同的主机名验证器实现。

    SSLSocketFactory sf = new SSLSocketFactory(SSLContext.getInstance("TLS"));
    sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);

2.6 协议模式

Scheme类代表了一个协议模式，比如“http”或“https”同时包含一些协议属性，比如默认端口，用来为给定协议创建java.net.Socket实例的套接字工厂。SchemeRegistry类用来维持一组Scheme，当去通过请求URI建立连接时，HttpClient可以从中选择：

    Scheme http = new Scheme("http", PlainSocketFactory.getSocketFactory(), 80);
    SSLSocketFactory sf = new SSLSocketFactory(SSLContext.getInstance("TLS"));
    sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
    Scheme https = new Scheme("https", sf, 443);
    SchemeRegistry sr = new SchemeRegistry();
    sr.register(http);
    sr.register(https);

2.7 HttpClient代理配置

尽管HttpClient了解复杂的路由模式和代理链，它仅支持简单直接的或开箱的跳式代理连接。

告诉HttpClient通过代理去连接到目标主机的最简单方式是通过设置默认的代理参数：

    DefaultHttpClient httpclient = new DefaultHttpClient();
    HttpHost proxy = new HttpHost("someproxy", 8080);
    httpclient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);

也可以构建HttpClient使用标准的JRE代理选择器来获得代理信息：

    DefaultHttpClient httpclient = new DefaultHttpClient();
    ProxySelectorRoutePlanner routePlanner = new ProxySelectorRoutePlanner(
    httpclient.getConnectionManager().getSchemeRegistry(),
    ProxySelector.getDefault());
    httpclient.setRoutePlanner(routePlanner);

另外一种选择，可以提供一个定制的RoutePlanner实现来获得HTTP路由计算处理上的复杂的控制：

    DefaultHttpClient httpclient = new DefaultHttpClient();
    httpclient.setRoutePlanner(new HttpRoutePlanner() {
    public HttpRoute determineRoute(HttpHost target,
    HttpRequest request,
    HttpContext context) throws HttpException {
    return new HttpRoute(target, null, new HttpHost("someproxy", 8080),
    "https".equalsIgnoreCase(target.getSchemeName()));
    }
    });

2.8 HTTP连接管理器

2.8.1 连接操作器

连接操作是客户端的低层套接字或可以通过外部实体，通常称为连接操作的被操作的状态的连接。OperatedClientConnection接口扩展了HttpClientConnection接口而且定义了额外的控制连接套接字的方法。ClientConnectionOperator接口代表了创建实例和更新那些对象低层套接字的策略。实现类最有可能利用SocketFactory来创建java.net.Socket实例。ClientConnectionOperator接口可以让HttpClient的用户提供一个连接操作的定制策略和提供可选实现OperatedClientConnection接口的能力。

2.8.2 管理连接和连接管理器

HTTP连接是复杂的，有状态的，线程不安全的对象需要正确的管理以便正确地执行功能。HTTP连接在同一时间仅仅只能由一个执行线程来使用。HttpClient采用一个特殊实体来管理访问HTTP连接，这被称为HTTP连接管理器，代表了ClientConnectionManager接口。一个HTTP连接管理器的目的是作为工厂服务于新的HTTP连接，管理持久连接和同步访问持久连接来确保同一时间仅有一个线程可以访问一个连接。

内部的HTTP连接管理器和OperatedClientConnection实例一起工作，但是它们为服务消耗器ManagedClientConnection提供实例。ManagedClientConnection扮演连接之上管理状态控制所有I/O操作的OperatedClientConnection实例的包装器。它也抽象套接字操作，提供打开和更新去创建路由套接字便利的方法。ManagedClientConnection实例了解产生它们到连接管理器的链接，而且基于这个事实，当不再被使用时，它们必须返回到管理器。ManagedClientConnection类也实现了ConnectionReleaseTrigger接口，可以被用来触发释放连接返回给管理器。一旦释放连接操作被触发了，被包装的连接从ManagedClientConnection包装器中脱离，OperatedClientConnection实例被返回给管理器。尽管服务消耗器仍然持有ManagedClientConnection实例的引用，它也不再去执行任何I/O操作或有意无意地改变的OperatedClientConnection状态。

这里有一个从连接管理器中获取连接的示例：

    HttpParams params = new BasicHttpParams();
    Scheme http = new Scheme("http", PlainSocketFactory.getSocketFactory(), 80);
    SchemeRegistry sr = new SchemeRegistry();
    sr.register(http);
    ClientConnectionManager connMrg = new SingleClientConnManager(params, sr);
    // 请求新连接。这可能是一个很长的过程。
    ClientConnectionRequest connRequest = connMrg.requestConnection(
    new HttpRoute(new HttpHost("localhost", 80)), null);
    // 等待连接10秒
    ManagedClientConnection conn = connRequest.getConnection(10, TimeUnit.SECONDS);
    try {
    // 用连接在做有用的事情。当完成时释放连接。
    conn.releaseConnection();
    } catch (IOException ex) {
    // 在I/O error之上终止连接。
    conn.abortConnection();
    throw ex;
    }

如果需要，连接请求可以通过调用来ClientConnectionRequest#abortRequest()方法过早地中断。这会解锁在ClientConnectionRequest#getConnection()方法中被阻止的线程。

一旦响应内容被完全消耗后，BasicManagedEntity包装器类可以用来保证自动释放低层的连接。HttpClient内部使用这个机制来实现透明地对所有从HttpClient#execute()方法中获得响应释放连接：

    ClientConnectionRequest connRequest = connMrg.requestConnection(
    new HttpRoute(new HttpHost("localhost", 80)), null);
    ManagedClientConnection conn = connRequest.getConnection(10, TimeUnit.SECONDS);
    try {
    BasicHttpRequest request = new BasicHttpRequest("GET", "/");
    conn.sendRequestHeader(request);
    HttpResponse response = conn.receiveResponseHeader();
    conn.receiveResponseEntity(response);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
    BasicManagedEntity managedEntity = new BasicManagedEntity(entity, conn, true);
    // 替换实体
    response.setEntity(managedEntity);
    }
    // 使用响应对象做有用的事情。当响应内容被消耗后这个连接将会自动释放。
    } catch (IOException ex) {
    //在I/O error之上终止连接。
    conn.abortConnection();
    throw ex;
    }

2.8.3 简单连接管理器

SingleClientConnManager是一个简单的连接管理器，在同一时间它仅仅维护一个连接。尽管这个类是线程安全的，但它应该被用于一个执行线程。SingleClientConnManager对于同一路由的后续请求会尽量重用连接。而如果持久连接的路由不匹配连接请求的话，它也会关闭存在的连接之后对给定路由再打开一个新的。如果连接已经被分配，将会抛出java.lang.IllegalStateException异常。

对于每个默认连接，HttpClient使用SingleClientConnManager。

2.8.4 连接池管理器

ThreadSafeClientConnManager是一个复杂的实现来管理客户端连接池，它也可以从多个执行线程中服务连接请求。对每个基本的路由，连接都是池管理的。对于路由的请求，管理器在池中有可用的持久性连接，将被从池中租赁连接服务，而不是创建一个新的连接。

ThreadSafeClientConnManager维护每个基本路由的最大连接限制。每个默认的实现对每个给定路由将会创建不超过两个的并发连接，而总共也不会超过20个连接。对于很多真实的应用程序，这个限制也证明很大的制约，特别是他们在服务中使用HTTP作为传输协议。连接限制，也可以使用HTTP参数来进行调整。

这个示例展示了连接池参数是如何来调整的：

    HttpParams params = new BasicHttpParams();
    // 增加最大连接到200
    ConnManagerParams.setMaxTotalConnections(params, 200);
    // 增加每个路由的默认最大连接到20
    ConnPerRouteBean connPerRoute = new ConnPerRouteBean(20);
    // 对localhost:80增加最大连接到50
    HttpHost localhost = new HttpHost("locahost", 80);
    connPerRoute.setMaxForRoute(new HttpRoute(localhost), 50);
    ConnManagerParams.setMaxConnectionsPerRoute(params, connPerRoute);
    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(
    new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    schemeRegistry.register(
    new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
    ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
    HttpClient httpClient = new DefaultHttpClient(cm, params);

2.8.5 连接管理器关闭

当一个HttpClient实例不再需要时，而且即将走出使用范围，那么关闭连接管理器来保证由管理器保持活动的所有连接被关闭，由连接分配的系统资源被释放是很重要的。

    DefaultHttpClient httpclient = new DefaultHttpClient();
    HttpGet httpget = new HttpGet("http://www.google.com/");
    HttpResponse response = httpclient.execute(httpget);
    HttpEntity entity = response.getEntity();
    System.out.println(response.getStatusLine());
    if (entity != null) {
    entity.consumeContent();
    }
    httpclient.getConnectionManager().shutdown();

2.9 连接管理参数

• 'http.conn-manager.timeout'：定义了当从ClientConnectionManager中检索ManagedClientConnection实例时使用的毫秒级的超时时间。这个参数期望得到一个java.lang.Long类型的值。如果这个参数没有被设置，连接请求就不会超时（无限大的超时时间）。
• 'http.conn-manager.max-per-route'：定义了每个路由连接的最大数量。这个限制由客户端连接管理器来解释，而且应用于独立的管理器实例。这个参数期望得到一个ConnPerRoute类型的值。
• 'http.conn-manager.max-total'：定义了总共连接的最大数目。这个限制由客户端连接管理器来解释，而且应用于独立的管理器实例。这个参数期望得到一个java.lang.Integer类型的值。

2.10 多线程执行请求

当配备连接池管理器时，比如ThreadSafeClientConnManager，HttpClient可以同时被用来执行多个请求，使用多线程执行。

ThreadSafeClientConnManager将会分配基于它的配置的连接。如果对于给定路由的所有连接都被租出了，那么连接的请求将会阻塞，直到一个连接被释放回连接池。它可以通过设置'http.conn-manager.timeout'为一个正数来保证连接管理器不会在连接请求执行时无限期的被阻塞。如果连接请求不能在给定的时间周期内被响应，将会抛出ConnectionPoolTimeoutException异常。

    HttpParams params = new BasicHttpParams();
    SchemeRegistry schemeRegistry = new SchemeRegistry();
    schemeRegistry.register(
    new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
    ClientConnectionManager cm = new ThreadSafeClientConnManager(params, schemeRegistry);
    HttpClient httpClient = new DefaultHttpClient(cm, params);
    // 执行GET方法的URI
    String[] urisToGet = {
    "http://www.domain1.com/",
    "http://www.domain2.com/",
    "http://www.domain3.com/",
    "http://www.domain4.com/"
    };
    // 为每个URI创建一个线程
    GetThread[] threads = new GetThread[urisToGet.length];
    for (int i = 0; i < threads.length; i++) {
    HttpGet httpget = new HttpGet(urisToGet[i]);
    threads[i] = new GetThread(httpClient, httpget);
    }
 

    // 开始执行线程
    for (int j = 0; j < threads.length; j++) {
    threads[j].start();
    }
    // 合并线程
    for (int j = 0; j < threads.length; j++) {
    threads[j].join();
    }
     
    static class GetThread extends Thread {
    private final HttpClient httpClient;
    private final HttpContext context;
    private final HttpGet httpget;
    public GetThread(HttpClient httpClient, HttpGet httpget) {
    this.httpClient = httpClient;
    this.context = new BasicHttpContext();
    this.httpget = httpget;
    }
    @Override
    public void run() {
    try {
    HttpResponse response = this.httpClient.execute(this.httpget, this.context);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
    // 对实体做些有用的事情...
    // 保证连接能释放回管理器
    entity.consumeContent();
    }
    } catch (Exception ex) {
    this.httpget.abort();
    }
    }
    }

2.11 连接收回策略

一个经典的阻塞I/O模型的主要缺点是网络套接字仅当I/O操作阻塞时才可以响应I/O事件。当一个连接被释放返回管理器时，它可以被保持活动状态而却不能监控套接字的状态和响应任何I/O事件。如果连接在服务器端关闭，那么客户端连接也不能去侦测连接状态中的变化和关闭本端的套接字去作出适当响应。

HttpClient通过测试连接是否是过时的来尝试去减轻这个问题，这已经不再有效了，因为它已经在服务器端关闭了，之前使用执行HTTP请求的连接。过时的连接检查也并不是100%的稳定，反而对每次请求执行还要增加10到30毫秒的开销。唯一可行的而不涉及到每个对空闲连接的套接字模型线程解决方案，是使用专用的监控线程来收回因为长时间不活动而被认为是过期的连接。监控线程可以周期地调用ClientConnectionManager#closeExpiredConnections()方法来关闭所有过期的连接，从连接池中收回关闭的连接。它也可以选择性调用ClientConnectionManager#closeIdleConnections()方法来关闭所有已经空闲超过给定时间周期的连接。

    public static class IdleConnectionMonitorThread extends Thread {
    private final ClientConnectionManager connMgr;
    private volatile boolean shutdown;
    public IdleConnectionMonitorThread(ClientConnectionManager connMgr) {
    super();
    this.connMgr = connMgr;
    }
    @Override
    public void run() {
    try {
    while (!shutdown) {
    synchronized (this) {
    wait(5000);
    // 关闭过期连接
    connMgr.closeExpiredConnections();
    // 可选地，关闭空闲超过30秒的连接
    connMgr.closeIdleConnections(30, TimeUnit.SECONDS);
    }
    }
    } catch (InterruptedException ex) {
    // 终止
    }
    }
    public void shutdown() {
    shutdown = true;
    synchronized (this) {
    notifyAll();
    }
    }
    }

2.12 连接保持活动的策略

HTTP规范没有确定一个持久连接可能或应该保持活动多长时间。一些HTTP服务器使用非标准的头部信息Keep-Alive来告诉客户端它们想在服务器端保持连接活动的周期秒数。如果这个信息可用，HttClient就会利用这个它。如果头部信息Keep-Alive在响应中不存在，HttpClient假设连接无限期的保持活动。然而许多现实中的HTTP服务器配置了在特定不活动周期之后丢掉持久连接来保存系统资源，往往这是不通知客户端的。如果默认的策略证明是过于乐观的，那么就会有人想提供一个定制的保持活动策略。

DefaultHttpClient httpclient = new DefaultHttpClient();
httpclient.setKeepAliveStrategy(new ConnectionKeepAliveStrategy() {
public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
// 兑现'keep-alive'头部信息
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")) {
try {
return Long.parseLong(value) * 1000;
} catch(NumberFormatException ignore) {
}
}
}
HttpHost target = (HttpHost) context.getAttribute(
ExecutionContext.HTTP_TARGET_HOST);
if ("www.naughty-server.com".equalsIgnoreCase(target.getHostName())) {
// 只保持活动5秒
return 5 * 1000;
} else {
// 否则保持活动30秒
return 30 * 1000;
}
}
});　

第三章 HTTP状态管理

    BasicClientCookie netscapeCookie = new BasicClientCookie("name", "value");
    netscapeCookie.setVersion(0);
    netscapeCookie.setDomain(".mycompany.com");
    netscapeCookie.setPath("/");

    BasicClientCookie stdCookie = new BasicClientCookie("name", "value");
    stdCookie.setVersion(1);
    stdCookie.setDomain(".mycompany.com");
    stdCookie.setPath("/");
    stdCookie.setSecure(true);
    // 精确设置由服务器发送的属性
    stdCookie.setAttribute(ClientCookie.VERSION_ATTR, "1");
    stdCookie.setAttribute(ClientCookie.DOMAIN_ATTR, ".mycompany.com");

    BasicClientCookie2 stdCookie = new BasicClientCookie2("name", "value");
    stdCookie.setVersion(1);
    stdCookie.setDomain(".mycompany.com");
    stdCookie.setPorts(new int[] {80,8080});
    stdCookie.setPath("/");
    stdCookie.setSecure(true);
    // 精确设置由服务器发送的属性
    stdCookie.setAttribute(ClientCookie.VERSION_ATTR, "1");
    stdCookie.setAttribute(ClientCookie.DOMAIN_ATTR, ".mycompany.com");
    stdCookie.setAttribute(ClientCookie.PORT_ATTR, "80,8080");

    HttpClient httpclient = new DefaultHttpClient();
    // 对每个默认的强制严格cookie策略
    httpclient.getParams().setParameter(
    ClientPNames.COOKIE_POLICY, CookiePolicy.RFC_2965);
    HttpGet httpget = new HttpGet("http://www.broken-server.com/");
    // 对这个请求覆盖默认策略
    httpget.getParams().setParameter(
    ClientPNames.COOKIE_POLICY, CookiePolicy.BROWSER_COMPATIBILITY);

    CookieSpecFactory csf = new CookieSpecFactory() {
    public CookieSpec newInstance(HttpParams params) {
    return new BrowserCompatSpec() {
    @Override
    public void validate(Cookie cookie, CookieOrigin origin)
    throws MalformedCookieException {
    // 这相当简单
    }
    };
    }
    };
    DefaultHttpClient httpclient = new DefaultHttpClient();
    httpclient.getCookieSpecs().register("easy", csf);
    httpclient.getParams().setParameter(
    ClientPNames.COOKIE_POLICY, "easy");

    DefaultHttpClient httpclient = new DefaultHttpClient();
    // 创建一个本地的cookie store实例
    CookieStore cookieStore = new MyCookieStore();
    // 如果需要填充cookie
    BasicClientCookie cookie = new BasicClientCookie("name", "value");
    cookie.setVersion(0);
    cookie.setDomain(".mycompany.com");
    cookie.setPath("/");
    cookieStore.addCookie(cookie);
    // 设置存储
    httpclient.setCookieStore(cookieStore);

    HttpClient httpclient = new DefaultHttpClient();
    HttpContext localContext = new BasicHttpContext();
    HttpGet httpget = new HttpGet("http://localhost:8080/");
    HttpResponse response = httpclient.execute(httpget, localContext);
    CookieOrigin cookieOrigin = (CookieOrigin) localContext.getAttribute(
    ClientContext.COOKIE_ORIGIN);
    System.out.println("Cookie origin: " + cookieOrigin);
    CookieSpec cookieSpec = (CookieSpec) localContext.getAttribute(
    ClientContext.COOKIE_SPEC);
    System.out.println("Cookie spec used: " + cookieSpec);

    HttpClient httpclient = new DefaultHttpClient();
    // 创建cookie store的本地实例
    CookieStore cookieStore = new BasicCookieStore();
    // 创建本地的HTTP内容
    HttpContext localContext = new BasicHttpContext();
    // 绑定定制的cookie store到本地内容中
    localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
    HttpGet httpget = new HttpGet("http://www.google.com/");
    // 作为参数传递本地内容
    HttpResponse response = httpclient.execute(httpget, localContext)

    UsernamePasswordCredentials creds = new UsernamePasswordCredentials("user", "pwd");
    System.out.println(creds.getUserPrincipal().getName());
    System.out.println(creds.getPassword());

    user
    pwd

    NTCredentials creds = new NTCredentials("user", "pwd", "workstation", "domain");
    System.out.println(creds.getUserPrincipal().getName());
    System.out.println(creds.getPassword());

    DOMAIN/user
    pwd

    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
    new AuthScope("somehost", AuthScope.ANY_PORT),
    new UsernamePasswordCredentials("u1", "p1"));
    credsProvider.setCredentials(
    new AuthScope("somehost", 8080),
    new UsernamePasswordCredentials("u2", "p2"));
    credsProvider.setCredentials(
    new AuthScope("otherhost", 8080, AuthScope.ANY_REALM, "ntlm"),
    new UsernamePasswordCredentials("u3", "p3"));
    System.out.println(credsProvider.getCredentials(
    new AuthScope("somehost", 80, "realm", "basic")));
    System.out.println(credsProvider.getCredentials(
    new AuthScope("somehost", 8080, "realm", "basic")));
    System.out.println(credsProvider.getCredentials(
    new AuthScope("otherhost", 8080, "realm", "basic")));
    System.out.println(credsProvider.getCredentials(
    new AuthScope("otherhost", 8080, null, "ntlm")));

    [principal: u1]
    [principal: u2]
    null
    [principal: u3]

    HttpClient httpclient = new DefaultHttpClient();
    HttpContext localContext = new BasicHttpContext();
    HttpGet httpget = new HttpGet("http://localhost:8080/");
    HttpResponse response = httpclient.execute(httpget, localContext);
    AuthState proxyAuthState = (AuthState) localContext.getAttribute(
    ClientContext.PROXY_AUTH_STATE);
    System.out.println("Proxy auth scope: " + proxyAuthState.getAuthScope());
    System.out.println("Proxy auth scheme: " + proxyAuthState.getAuthScheme());
    System.out.println("Proxy auth credentials: " + proxyAuthState.getCredentials());
    AuthState targetAuthState = (AuthState) localContext.getAttribute(
    ClientContext.TARGET_AUTH_STATE);
    System.out.println("Target auth scope: " + targetAuthState.getAuthScope());
    System.out.println("Target auth scheme: " + targetAuthState.getAuthScheme());
    System.out.println("Target auth credentials: " + targetAuthState.getCredentials());

    HttpRequestInterceptor preemptiveAuth = new HttpRequestInterceptor() {
    public void process(final HttpRequest request,
    final HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(
    ClientContext.TARGET_AUTH_STATE);
    CredentialsProvider credsProvider = (CredentialsProvider) context.getAttribute(ClientContext.CREDS_PROVIDER);
    HttpHost targetHost = (HttpHost) context.getAttribute(
    ExecutionContext.HTTP_TARGET_HOST);
    // 如果没有初始化auth模式
    if (authState.getAuthScheme() == null) {
    AuthScope authScope = new AuthScope(
    targetHost.getHostName(),
    targetHost.getPort());
    // 获得匹配目标主机的凭据
    Credentials creds = credsProvider.getCredentials(authScope);
    // 如果发现了，抢先生成BasicScheme
    if (creds != null) {
    authState.setAuthScheme(new BasicScheme());
    authState.setCredentials(creds);
    }
    }
    }
    };
    DefaultHttpClient httpclient = new DefaultHttpClient();
    // 作为第一个拦截器加入到协议链中
    httpclient.addRequestInterceptor(preemptiveAuth, 0);

    DefaultHttpClient httpclient = new DefaultHttpClient();
    NTCredentials creds = new NTCredentials("user", "pwd", "myworkstation", "microsoft.com");
    httpclient.getCredentialsProvider().setCredentials(AuthScope.ANY, creds);
    HttpHost target = new HttpHost("www.microsoft.com", 80, "http");
    // 保证相同的内容来用于执行逻辑相关的请求
    HttpContext localContext = new BasicHttpContext();
    // 首先执行简便的方法。这会触发NTLM认证
    HttpGet httpget = new HttpGet("/ntlm-protected/info");
    HttpResponse response1 = httpclient.execute(target, httpget, localContext);
    HttpEntity entity1 = response1.getEntity();
    if (entity1 != null) {
    entity1.consumeContent();
    }
    //之后使用相同的内容（和连接）执行开销大的方法。
    HttpPost httppost = new HttpPost("/ntlm-protected/form");
    httppost.setEntity(new StringEntity("lots and lots of data"));
    HttpResponse response2 = httpclient.execute(target, httppost, localContext);
    HttpEntity entity2 = response2.getEntity();
    if (entity2 != null) {
    entity2.consumeContent();
    }

    DefaultHttpClient httpclient = new DefaultHttpClient();
    httpclient.setKeepAliveStrategy(new DefaultConnectionKeepAliveStrategy() {
    @Override
    public long getKeepAliveDuration(HttpResponse response,
    HttpContext context) {
    long keepAlive = super.getKeepAliveDuration(response, context);
    if (keepAlive == -1) {
    // 如果keep-alive值没有由服务器明确设置，那么保持连接持续5秒。
    keepAlive = 5000;
    }
    return keepAlive;
    }
    });

    DefaultHttpClient httpclient = new DefaultHttpClient();
    httpclient.removeRequestInterceptorByClass(RequestUserAgent.class);
    httpclient.addRequestInterceptor(new HttpRequestInterceptor() {
    public void process(
    HttpRequest request, HttpContext context)
    throws HttpException, IOException {
    request.setHeader(HTTP.USER_AGENT, "My-own-client");
    }
    });

    HttpClient httpclient = new DefaultHttpClient();
    // 做些有用的事
    httpclient.getConnectionManager().shutdown();

    DefaultHttpClient httpclient = new DefaultHttpClient();
    HttpContext localContext = new BasicHttpContext();
    HttpGet httpget = new HttpGet("http://localhost:8080/");
    HttpResponse response = httpclient.execute(httpget, localContext);
    HttpHost target = (HttpHost) localContext.getAttribute(
    ExecutionContext.HTTP_TARGET_HOST);
    HttpUriRequest req = (HttpUriRequest) localContext.getAttribute(
    ExecutionContext.HTTP_REQUEST);
    System.out.println("Target host: " + target);
    System.out.println("Final request URI: " + req.getURI());
    System.out.println("Final request method: " + req.getMethod());

    class MyLineParser extends BasicLineParser {
    @Override
    public Header parseHeader(
    final CharArrayBuffer buffer) throws ParseException {
    try {
    return super.parseHeader(buffer);
    } catch (ParseException ex) {
    // 压制ParseException异常
    return new BasicHeader("invalid", buffer.toString());
    }
    }
    }

    class MyClientConnection extends DefaultClientConnection {
    @Override
    protected HttpMessageParser createResponseParser(
    final SessionInputBuffer buffer,
    final HttpResponseFactory responseFactory,
    final HttpParams params) {
    return new DefaultResponseParser(buffer,
    new MyLineParser(),responseFactory,params);
    }
    }

    class MyClientConnectionOperator extends
    DefaultClientConnectionOperator {
    public MyClientConnectionOperator(
    final SchemeRegistry sr) {
    super(sr);
    }
    @Override
    public OperatedClientConnection createConnection() {
    return new MyClientConnection();
    }
    }

    class MyClientConnManager extends SingleClientConnManager {
    public MyClientConnManager(
    final HttpParams params,
    final SchemeRegistry sr) {
    super(params, sr);
    }
    @Override
    protected ClientConnectionOperator createConnectionOperator(
    final SchemeRegistry sr) {
    return new MyClientConnectionOperator(sr);
    }
    }

    DefaultHttpClient httpclient = new DefaultHttpClient();
    httpclient.setUserTokenHandler(new UserTokenHandler() {
    public Object getUserToken(HttpContext context) {
    return context.getAttribute("my-token");
    }
    });

    DefaultHttpClient httpclient = new DefaultHttpClient();
    HttpContext localContext = new BasicHttpContext();
    HttpGet httpget = new HttpGet("http://localhost:8080/");
    HttpResponse response = httpclient.execute(httpget, localContext);
    HttpEntity entity = response.getEntity();
    if (entity != null) {
    entity.consumeContent();
    }
    Object userToken = localContext.getAttribute(ClientContext.USER_TOKEN);
    System.out.println(userToken);

    DefaultHttpClient httpclient = new DefaultHttpClient();
    HttpContext localContext1 = new BasicHttpContext();
    HttpGet httpget1 = new HttpGet("http://localhost:8080/");
    HttpResponse response1 = httpclient.execute(httpget1, localContext1);
    HttpEntity entity1 = response1.getEntity();
    if (entity1 != null) {
    entity1.consumeContent();
    }
    Principal principal = (Principal) localContext1.getAttribute(
    ClientContext.USER_TOKEN);
    HttpContext localContext2 = new BasicHttpContext();
    localContext2.setAttribute(ClientContext.USER_TOKEN, principal);
    HttpGet httpget2 = new HttpGet("http://localhost:8080/");
    HttpResponse response2 = httpclient.execute(httpget2, localContext2);
    HttpEntity entity2 = response2.getEntity();
    if (entity2 != null) {
    entity2.consumeContent();
    }