HttpClient详细解释

前言

HttpClient相对传统JDK自带的URLConnection,，增长了易用性和灵活性，它不只使客户端发生HTTP请求变得容易，并且也方便了开发人员测试接口（基于HTTP协议），既提升了开发的效率，也提升了代码的健壮性。所以熟练掌握HTTPClient是很重要的必修课，掌握httpclient后，相信对于HTTP协议的了解会更加深刻。

1、简介

httpclient是Apache Jakarta common下的子项目，用来提供高效的、最新的、更能丰富的支持http协议的客户端编程工具包，而且它支持http协议最新的版本和建议。httpclient已经应用在不少项目中，好比Apache Jakarta上很著名的两个开源项目cactus和httplunit都使用了httpclient。

2、特效

1.基于标准、纯净的Java语言。实现了HTTP1.0和HTTP1.1

2.以可扩展的面向对象的结构实现了HTTP所有的方法（GET、POST、put、delete、head、options、trace）。

3.支持HTTPS协议。

4.经过HTTP代理创建透明的链接。

5.利用connect方法经过HTTP代理创建隧道的HTTPS链接。

6.basic，digest，htlmv1，htlmv2,htlm2 session,snpnego/kerberos认证方案。

7.插件式的自定义认证方案。

8.便携可靠的套接字工厂是它更容易的使用第三方解决方案。

9.链接管理器支持多线程应用。支持设置最大链接数，同事支持设置每一个主机的最大链接数，发现并关闭过时的链接。

10.自动处理Set-Cookie中的Cookie。

11.插件式的自定义Cookie策略。

12.request的输出流能够避免流中内容直接缓冲到socket服务器。

13.Response的输入流能够有效的从socket服务器直接读取相应内容。

14.在http1.0和http1.1中利用KeepAlive保持持久链接。

15.直接获取服务器发送的response code和 headers。

16.设置链接超时的能力。

17.实验性的支持http1.1 response caching。

18.源代码基于Apache License 可免费获取。

3、使用方法

使用HttpClient发送请求、接收响应很简单，通常须要以下几步便可。
一、建立httpclient对象。
二、建立请求方法的实例，并制定请求url。若是须要发送get请求，建立httpclient对象；若是须要发送post请求，建立httpPOST对象。
三、若是须要发送请求参数，可调用httpget、httpPost共同的setparams(HetpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。
四、调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。
五、调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可经过该对象获取服务器的响应内容。
六、释放链接。不管执行方法是否成功，都必须释放链接。
4、获取页面代码

package http.HttpClient;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

public class GetCode {
    public static void main(String[] args) throws ClientProtocolException, IOException {
        DefaultHttpClient httpclient = new DefaultHttpClient();
        HttpGet httpGet = new HttpGet("http://www.baidu.com");
        String body = "";
        HttpResponse response;
        HttpEntity entity;
        response = httpclient.execute(httpGet);
        entity = response.getEntity();
        body = EntityUtils.toString(entity);//这个就是页面源码了
        httpGet.abort();//中断请求,接下来能够开始另外一段请求
        System.out.println(body);
        //httpGet.releaseConnection();//释放请求.若是释放了至关于要清空session
        //如下是post方法
        HttpPost httpPost = new HttpPost("http://www.baidu.com");//必定要改为能够提交的地址,这里用百度代替
        List <NameValuePair> nvps = new ArrayList <NameValuePair>();
        nvps.add(new BasicNameValuePair("name", "1"));//名值对
        nvps.add(new BasicNameValuePair("account", "xxxx"));
        httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));
        response = httpclient.execute(httpPost);
        entity = response.getEntity();
        body = EntityUtils.toString(entity);
        System.out.println("Login form get: " + response.getStatusLine());//这个能够打印状态
        httpPost.abort();
        System.out.println(body);
        httpPost.releaseConnection();
    }
}

代码实例

package http.HttpClient;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;

/**
 * org.apache.http.impl.client.CloseableHttpClient连接池生成工具
 * @reference http://www.cnblogs.com/whatlonelytear/articles/4835538.html
 * @author King
 * @date 20170601
 */
public class HttpClientTool {

    // org.apache.http.impl.client.CloseableHttpClient
    private static CloseableHttpClient httpclient = null;

    // 这里就直接默认固定了,由于如下三个参数在新建的method中仍然能够从新配置并被覆盖.
    static final int connectionRequestTimeout = 5000;// ms毫秒,从池中获取连接超时时间
    static final int connectTimeout = 5000;// ms毫秒,创建连接超时时间
    static final int socketTimeout = 30000;// ms毫秒,读取超时时间

    // 总配置,主要涉及是如下两个参数,若是要做调整没有用到properties会比较后麻烦,但鉴于一经粘贴,随处可用的特色,就再也不作依赖性配置化处理了.
    // 并且这个参数同一家公司基本不会变更.
    static final int maxTotal = 500;// 最大总并发,很重要的参数
    static final int maxPerRoute = 100;// 每路并发,很重要的参数

    // 正常状况这里应该配成MAP或LIST
    // 细化配置参数,用来对每路参数作精细化处理,能够管控各ip的流量,好比默认配置请求baidu:80端口最大100个并发连接,
    static final String detailHostName = "http://www.baidu.com";// 每一个细化配置之ip(不重要,在特殊场景颇有用)
    static final int detailPort = 80;// 每一个细化配置之port(不重要,在特殊场景颇有用)
    static final int detailMaxPerRoute = 100;// 每一个细化配置之最大并发数(不重要,在特殊场景颇有用)

    public static CloseableHttpClient getHttpClient() {
        if (null == httpclient) {
            synchronized (HttpClientTool.class) {
                if (null == httpclient) {
                    httpclient = init();
                }
            }
        }
        return httpclient;
    }

    /**
     * 连接池初始化 这里最重要的一点理解就是. 让CloseableHttpClient 一直活在池的世界里, 可是HttpPost却一直用完就消掉.
     * 这样可让连接一直保持着.
     *
     * @return
     */
    private static CloseableHttpClient init() {
        CloseableHttpClient newHttpclient = null;

        // 设置链接池
        ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
        LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
        Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();
        PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
        // 将最大链接数增长
        cm.setMaxTotal(maxTotal);
        // 将每一个路由基础的链接增长
        cm.setDefaultMaxPerRoute(maxPerRoute);

        // 细化配置开始,其实这里用Map或List的for循环来配置每一个连接,在特殊场景颇有用.
        // 将每一个路由基础的链接作特殊化配置,通常用不着
        HttpHost httpHost = new HttpHost(detailHostName, detailPort);
        // 将目标主机的最大链接数增长
        cm.setMaxPerRoute(new HttpRoute(httpHost), detailMaxPerRoute);
        // cm.setMaxPerRoute(new HttpRoute(httpHost2),
        // detailMaxPerRoute2);//能够有细化配置2
        // cm.setMaxPerRoute(new HttpRoute(httpHost3),
        // detailMaxPerRoute3);//能够有细化配置3
        // 细化配置结束

        // 请求重试处理
        HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {
            public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                if (executionCount >= 2) {// 若是已经重试了2次，就放弃
                    return false;
                }
                if (exception instanceof NoHttpResponseException) {// 若是服务器丢掉了链接，那么就重试
                    return true;
                }
                if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
                    return false;
                }
                if (exception instanceof InterruptedIOException) {// 超时
                    return false;
                }
                if (exception instanceof UnknownHostException) {// 目标服务器不可达
                    return false;
                }
                if (exception instanceof ConnectTimeoutException) {// 链接被拒绝
                    return false;
                }
                if (exception instanceof SSLException) {// SSL握手异常
                    return false;
                }

                HttpClientContext clientContext = HttpClientContext.adapt(context);
                HttpRequest request = clientContext.getRequest();
                // 若是请求是幂等的，就再次尝试
                if (!(request instanceof HttpEntityEnclosingRequest)) {
                    return true;
                }
                return false;
            }
        };

        // 配置请求的超时设置
        RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();
        newHttpclient = HttpClients.custom().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).setRetryHandler(httpRequestRetryHandler).build();
        return newHttpclient;
    }
}
httpclient实例
import java.io.IOException;
import java.net.UnknownHostException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileOutputStream;

import org.apache.http.HttpEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.message.AbstractHttpMessage;

public class Simplest {
    private void Get() {
        CloseableHttpClient httpclient = HttpClients.createDefault();
        try {
            String HostName = "http://www.baidu.com";
            HttpGet httpget = new HttpGet(HostName);
            System.out.println(httpget.getURI());
            //HttpGet httpget = new HttpGet("http://www.lietu.com");
            CloseableHttpResponse response = httpclient.execute(httpget);
            System.out.println("Successful!");
            System.out.println(response.getProtocolVersion());  //Protocol Version
            System.out.println(response.getStatusLine().getStatusCode());   //Status Code
            System.out.println(response.getStatusLine().getReasonPhrase());
            System.out.println(response.getStatusLine().toString());

            //get entity
            HttpEntity entity = response.getEntity();
            if (entity != null) {
                InputStream input = entity.getContent();
                String filename = HostName.substring(HostName.lastIndexOf('/')+1);
                System.out.println("The filename is: " + filename);
                OutputStream output = new FileOutputStream(filename);

                int tempByte=-1;
                while ((tempByte=input.read())>0) {
                    output.write(tempByte);
                }

                if (input != null) {
                    input.close();
                }

                if (output != null) {
                    output.close();
                }
            }
        } catch(UnknownHostException e) {
            System.out.println("No such a host!");
        } catch(IOException e) {
            e.printStackTrace();
        } 
    }

    public static void main(String[] args) {
        Simplest a = new Simplest();
        a.Get();
        System.out.println("This is a test");
    }
}