HttpClient学习整理

HttpClient简介HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。HttpClient 已经应用在很多的项目中，比如 Apache Jakarta 上很著名的另外两个开源项目 Cactus 和 HTMLUnit 都使用了 HttpClient。更多信息请关注http://hc.apache.org/HttpClient 功能介绍以下列出的是 HttpClient 提供的主要的功能，要知道更多详细的功能可以参见 HttpClient 的主页。实现了所有 HTTP 的方法（GET,POST,PUT,HEAD 等）支持自动转向支持 HTTPS 协议支持代理服务器等应用HttpClient来对付各种顽固的WEB服务器转自：http://blog.csdn.net/ambitiontan/archive/2006/01/06/572171.aspx一般的情况下我们都是使用IE或者Navigator浏览器来访问一个WEB服务器，用来浏览页面查看信息或者提交一些数据等等。所访问的这些页面有的仅仅是一些普通的页面，有的需要用户登录后方可使用，或者需要认证以及是一些通过加密方式传输，例如HTTPS。目前我们使用的浏览器处理这些情况都不会构成问题。不过你可能在某些时候需要通过程序来访问这样的一些页面，比如从别人的网页中“偷”一些数据；利用某些站点提供的页面来完成某种功能，例如说我们想知道某个手机号码的归属地而我们自己又没有这样的数据，因此只好借助其他公司已有的网站来完成这个功能，这个时候我们需要向网页提交手机号码并从返回的页面中解析出我们想要的数据来。如果对方仅仅是一个很简单的页面，那我们的程序会很简单，本文也就没有必要大张旗鼓的在这里浪费口舌。但是考虑到一些服务授权的问题，很多公司提供的页面往往并不是可以通过一个简单的URL就可以访问的，而必须经过注册然后登录后方可使用提供服务的页面，这个时候就涉及到COOKIE问题的处理。我们知道目前流行的动态网页技术例如ASP、JSP无不是通过COOKIE来处理会话信息的。为了使我们的程序能使用别人所提供的服务页面，就要求程序首先登录后再访问服务页面，这过程就需要自行处理cookie，想想当你用java.net.HttpURLConnection来完成这些功能时是多么恐怖的事情啊！况且这仅仅是我们所说的顽固的WEB服务器中的一个很常见的“顽固”！再有如通过HTTP来上传文件呢？不需要头疼，这些问题有了“它”就很容易解决了！我们不可能列举所有可能的顽固，我们会针对几种最常见的问题进行处理。当然了，正如前面说到的，如果我们自己使用java.net.HttpURLConnection来搞定这些问题是很恐怖的事情，因此在开始之前我们先要介绍一下一个开放源码的项目，这个项目就是Apache开源组织中的httpclient，它隶属于Jakarta的commons项目，目前的版本是2.0RC2。commons下本来已经有一个net的子项目，但是又把httpclient单独提出来，可见http服务器的访问绝非易事。Commons-httpclient项目就是专门设计来简化HTTP客户端与服务器进行各种通讯编程。通过它可以让原来很头疼的事情现在轻松的解决，例如你不再管是HTTP或者HTTPS的通讯方式，告诉它你想使用HTTPS方式，剩下的事情交给httpclient替你完成。本文会针对我们在编写HTTP客户端程序时经常碰到的几个问题进行分别介绍如何使用httpclient来解决它们，为了让读者更快的熟悉这个项目我们最开始先给出一个简单的例子来读取一个网页的内容，然后循序渐进解决掉前进中的所有问题。1． 读取网页(HTTP/HTTPS)内容下面是我们给出的一个简单的例子用来访问某个页面复制代码/**  *最简单的HTTP客户端,用来演示通过GET或者POST方式访问某个页面  *@authorLiudong*/public class SimpleClient {public static void main(String[] args) throws IOException {  HttpClient client = new HttpClient();       // 设置代理服务器地址和端口            //client.getHostConfiguration().setProxy("proxy_host_addr",proxy_port);       // 使用 GET 方法 ，如果服务器需要通过 HTTPS 连接，那只需要将下面 URL 中的 http 换成 https          HttpMethod method=new GetMethod("http://java.sun.com");      //使用POST方法      //HttpMethod method = new PostMethod("http://java.sun.com");      client.executeMethod(method);      //打印服务器返回的状态      System.out.println(method.getStatusLine());      //打印返回的信息      System.out.println(method.getResponseBodyAsString());      //释放连接      method.releaseConnection();   }}复制代码在这个例子中首先创建一个HTTP客户端(HttpClient)的实例，然后选择提交的方法是GET或者POST，最后在HttpClient实例上执行提交的方法，最后从所选择的提交方法中读取服务器反馈回来的结果。这就是使用HttpClient的基本流程。其实用一行代码也就可以搞定整个请求的过程，非常的简单！2、使用POST方式提交数据(httpClient3)httpclient使用了单独的一个HttpMethod子类来处理文件的上传，这个类就是MultipartPostMethod，该类已经封装了文件上传的细节，我们要做的仅仅是告诉它我们要上传文件的全路径即可，下面这里将给出关于两种模拟上传方式的代码第一种：模拟上传url文件(该方式也适合做普通post请求):复制代码/**     * 上传url文件到指定URL     * @param fileUrl 上传图片url     * @param postUrl 上传路径及参数,注意有些中文参数需要使用预先编码 eg : URLEncoder.encode(appName, "UTF-8")     * @return     * @throws IOException     */    public static String doUploadFile(String postUrl) throws IOException {        if(StringUtils.isEmpty(postUrl))            return null;        String response = "";        PostMethod postMethod = new PostMethod(postUrl);        try {            HttpClient client = new HttpClient();            client.getHttpConnectionManager().getParams()                    .setConnectionTimeout(50000);// 设置连接时间            int status = client.executeMethod(postMethod);            if (status == HttpStatus.SC_OK) {                InputStream inputStream = postMethod.getResponseBodyAsStream();                BufferedReader br = new BufferedReader(new InputStreamReader(                        inputStream));                StringBuffer stringBuffer = new StringBuffer();                String str = "";                while ((str = br.readLine()) != null) {                    stringBuffer.append(str);                }                response = stringBuffer.toString();            } else {                response = "fail";            }        } catch (Exception e) {            e.printStackTrace();        } finally {            // 释放连接            postMethod.releaseConnection();        }        return response;    }复制代码第二种：模拟文件上传到指定位置复制代码/**     * 上传文件到指定URL     * @param file     * @param url     * @return     * @throws IOException     */    public static String doUploadFile(File file, String url) throws IOException {        String response = "";        if (!file.exists()) {            return "file not exists";        }        PostMethod postMethod = new PostMethod(url);        try {            //----------------------------------------------            // FilePart：用来上传文件的类,file即要上传的文件            FilePart fp = new FilePart("file", file);            Part[] parts = { fp };            // 对于MIME类型的请求，httpclient建议全用MulitPartRequestEntity进行包装            MultipartRequestEntity mre = new MultipartRequestEntity(parts,                    postMethod.getParams());            postMethod.setRequestEntity(mre);            //---------------------------------------------            HttpClient client = new HttpClient();            client.getHttpConnectionManager().getParams()                    .setConnectionTimeout(50000);// 由于要上传的文件可能比较大 , 因此在此设置最大的连接超时时间            int status = client.executeMethod(postMethod);            if (status == HttpStatus.SC_OK) {                InputStream inputStream = postMethod.getResponseBodyAsStream();                BufferedReader br = new BufferedReader(new InputStreamReader(                        inputStream));                StringBuffer stringBuffer = new StringBuffer();                String str = "";                while ((str = br.readLine()) != null) {                    stringBuffer.append(str);                }                response = stringBuffer.toString();            } else {                response = "fail";            }        } catch (Exception e) {            e.printStackTrace();        } finally {            // 释放连接            postMethod.releaseConnection();        }        return response;    }复制代码3． 处理页面重定向在JSP/Servlet编程中response.sendRedirect方法就是使用HTTP协议中的重定向机制。它与JSP中的<jsp:forward …>的区别在于后者是在服务器中实现页面的跳转，也就是说应用容器加载了所要跳转的页面的内容并返回给客户端；而前者是返回一个状态码，这些状态码的可能值见下表，然后客户端读取需要跳转到的页面的URL并重新加载新的页面。就是这样一个过程，所以我们编程的时候就要通过HttpMethod.getStatusCode()方法判断返回值是否为下表中的某个值来判断是否需要跳转。如果已经确认需要进行页面跳转了，那么可以通过读取HTTP头中的location属性来获取新的地址。下面的代码片段演示如何处理页面的重定向复制代码client.executeMethod(post);System.out.println(post.getStatusLine().toString());post.releaseConnection();// 检查是否重定向int statuscode = post.getStatusCode();if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY) || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) || (statuscode ==HttpStatus.SC_SEE_OTHER) || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {// 读取新的 URL 地址    Header header=post.getResponseHeader("location");   if (header!=null){      Stringnewuri=header.getValue();      if((newuri==null)||(newuri.equals("")))         newuri="/";         GetMethodredirect=newGetMethod(newuri);         client.executeMethod(redirect);         System.out.println("Redirect:"+redirect.getStatusLine().toString());         redirect.releaseConnection();   }else     System.out.println("Invalid redirect");}复制代码我们可以自行编写两个JSP页面，其中一个页面用response.sendRedirect方法重定向到另外一个页面用来测试上面的例子。4． 模拟登录开心网本小节应该说是HTTP客户端编程中最常碰见的问题，很多网站的内容都只是对注册用户可见的，这种情况下就必须要求使用正确的用户名和口令登录成功后，方可浏览到想要的页面。因为HTTP协议是无状态的，也就是连接的有效期只限于当前请求，请求内容结束后连接就关闭了。在这种情况下为了保存用户的登录信息必须使用到Cookie机制。以JSP/Servlet为例，当浏览器请求一个JSP或者是Servlet的页面时，应用服务器会返回一个参数，名为jsessionid（因不同应用服务器而异），值是一个较长的唯一字符串的Cookie，这个字符串值也就是当前访问该站点的会话标识。浏览器在每访问该站点的其他页面时候都要带上jsessionid这样的Cookie信息，应用服务器根据读取这个会话标识来获取对应的会话信息。对于需要用户登录的网站，一般在用户登录成功后会将用户资料保存在服务器的会话中，这样当访问到其他的页面时候，应用服务器根据浏览器送上的Cookie中读取当前请求对应的会话标识以获得对应的会话信息，然后就可以判断用户资料是否存在于会话信息中，如果存在则允许访问页面，否则跳转到登录页面中要求用户输入帐号和口令进行登录。这就是一般使用JSP开发网站在处理用户登录的比较通用的方法。这样一来，对于HTTP的客户端来讲，如果要访问一个受保护的页面时就必须模拟浏览器所做的工作，首先就是请求登录页面，然后读取Cookie值；再次请求登录页面并加入登录页所需的每个参数；最后就是请求最终所需的页面。当然在除第一次请求外其他的请求都需要附带上Cookie信息以便服务器能判断当前请求是否已经通过验证。说了这么多，可是如果你使用httpclient的话，你甚至连一行代码都无需增加，你只需要先传递登录信息执行登录过程，然后直接访问想要的页面，跟访问一个普通的页面没有任何区别，因为类HttpClient已经帮你做了所有该做的事情了，太棒了！下面的例子实现了模拟登陆开心网并向自己好友发送消息的功能。复制代码import java.io.BufferedReader;import java.io.IOException;import java.io.InputStream;import java.io.InputStreamReader;import org.apache.commons.httpclient.Cookie;import org.apache.commons.httpclient.Header;import org.apache.commons.httpclient.HttpClient;import org.apache.commons.httpclient.HttpStatus;import org.apache.commons.httpclient.NameValuePair;import org.apache.commons.httpclient.cookie.CookiePolicy;import org.apache.commons.httpclient.methods.GetMethod;import org.apache.commons.httpclient.methods.PostMethod;import org.apache.commons.httpclient.params.HttpClientParams;import org.apache.commons.httpclient.params.HttpMethodParams;class Login {    public static String loginurl = "https://security.kaixin001.com/login/login_post.php";    static Cookie[] cookies = {};    static HttpClient httpClient = new HttpClient();    static String email = "[e-mail]";//你的email    static String psw = "xxx";//你的密码    // 消息发送的action    String url = "http://www.kaixin001.com/home/";    public static void getUrlContent()            throws Exception {        HttpClientParams httparams = new HttpClientParams();        httparams.setSoTimeout(30000);        httpClient.setParams(httparams);        httpClient.getHostConfiguration().setHost("www.kaixin001.com", 80);        httpClient.getParams().setParameter(                HttpMethodParams.HTTP_CONTENT_CHARSET, "UTF-8");        PostMethod login = new PostMethod(loginurl);        login.addRequestHeader("Content-Type",                "application/x-www-form-urlencoded; charset=UTF-8");        NameValuePair Email = new NameValuePair("loginemail", email);// 邮箱        NameValuePair password = new NameValuePair("password", psw);// 密码        // NameValuePair code = new NameValuePair( "code"        // ,"????");//有时候需要验证码，暂时未解决        NameValuePair[] data = { Email, password };        login.setRequestBody(data);        httpClient.executeMethod(login);        int statuscode = login.getStatusCode();        System.out.println(statuscode + "-----------");        String result = login.getResponseBodyAsString();        System.out.println(result+"++++++++++++");        cookies = httpClient.getState().getCookies();        System.out.println("==========Cookies============");        int i = 0;        for (Cookie c : cookies) {            System.out.println(++i + ":   " + c);        }        httpClient.getState().addCookies(cookies);        // 当state为301或者302说明登陆页面跳转了，登陆成功了        if ((statuscode == HttpStatus.SC_MOVED_TEMPORARILY)                || (statuscode == HttpStatus.SC_MOVED_PERMANENTLY)                || (statuscode == HttpStatus.SC_SEE_OTHER)                || (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT)) {            // 读取新的 URL 地址            Header header = login.getResponseHeader("location");            // 释放连接            login.releaseConnection();            System.out.println("获取到跳转header>>>" + header);            if (header != null) {                String newuri = header.getValue();                if ((newuri == null) || (newuri.equals("")))                    newuri = "/";                GetMethod redirect = new GetMethod(newuri);                // ////////////                redirect.setRequestHeader("Cookie", cookies.toString());                httpClient.executeMethod(redirect);                System.out.println("Redirect:"                        + redirect.getStatusLine().toString());                redirect.releaseConnection();            } else                System.out.println("Invalid redirect");        } else {            // 用户名和密码没有被提交，当登陆多次后需要验证码的时候会出现这种未提交情况            System.out.println("用户没登陆");            System.exit(1);        }    }    public static void sendMsg() throws Exception {        // 登录后发消息        System.out.println("*************发消息***********");        String posturl = "http://www.kaixin001.com/msg/post.php";        PostMethod poster = new PostMethod(posturl);        poster.addRequestHeader("Content-Type",                "application/x-www-form-urlencoded; charset=UTF-8");        poster.setRequestHeader("Cookie", cookies.toString());        NameValuePair uids = new NameValuePair("uids", "89600585");// 发送的好友对象的id,此处换成你的好友id        NameValuePair content = new NameValuePair("content", "你好啊!");// 需要发送的信息的内容        NameValuePair liteeditor_0 = new NameValuePair("liteeditor_0", "你好啊!");// 需要发送的信息的内容        NameValuePair texttype = new NameValuePair("texttype", "plain");        NameValuePair send_separate = new NameValuePair("send_separate", "0");        NameValuePair service = new NameValuePair("service", "0");        NameValuePair[] msg = { uids, content, texttype, send_separate, service,liteeditor_0 };        poster.setRequestBody(msg);        httpClient.executeMethod(poster);        String result = poster.getResponseBodyAsString();        System.out.println(result+"++++++++++++");        //System.out.println(StreamOut(result, "iso8859-1"));        int statuscode = poster.getStatusCode();        System.out.println(statuscode + "-----------");        if(statuscode == 301 || statuscode == 302){            // 读取新的 URL 地址            Header header = poster.getResponseHeader("location");            System.out.println("获取到跳转header>>>" + header);            if (header != null) {                String newuri = header.getValue();                if ((newuri == null) || (newuri.equals("")))                    newuri = "/";                GetMethod redirect = new GetMethod(newuri);                // ////////////                redirect.setRequestHeader("Cookie", cookies.toString());                httpClient.executeMethod(redirect);                System.out.println("Redirect:"                        + redirect.getStatusLine().toString());                redirect.releaseConnection();            } else                System.out.println("Invalid redirect");        }            poster.releaseConnection();    }    public static String StreamOut(InputStream txtis, String code)            throws IOException {        BufferedReader br = new BufferedReader(new InputStreamReader(txtis,                code));        String tempbf;        StringBuffer html = new StringBuffer(100);        while ((tempbf = br.readLine()) != null) {            html.append(tempbf + "\n");        }        return html.toString();    }}复制代码5． 提交XML格式参数提交XML格式的参数很简单，仅仅是一个提交时候的ContentType问题，下面的例子演示从文件文件中读取XML信息并提交给服务器的过程，该过程可以用来测试Web服务。复制代码import java.io.File; import java.io.FileInputStream; import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.methods.EntityEnclosingMethod; import org.apache.commons.httpclient.methods.PostMethod;/**  *用来演示提交XML格式数据的例子*/public class PostXMLClient {   public static void main(String[] args) throws Exception {      File input = new File(“test.xml”);      PostMethod post = new PostMethod(“http://localhost:8080/httpclient/xml.jsp”);      // 设置请求的内容直接从文件中读取      post.setRequestBody( new FileInputStream(input));       if (input.length() < Integer.MAX_VALUE)         post.setRequestContentLength(input.length());      else         post.setRequestContentLength(EntityEnclosingMethod.CONTENT_LENGTH_CHUNKED);      // 指定请求内容的类型      post.setRequestHeader( "Content-type" , "text/xml; charset=GBK" );      HttpClient httpclient = new HttpClient();      int result = httpclient.executeMethod(post);      System.out.println( "Response status code: " + result);      System.out.println( "Response body: " );      System.out.println(post.getResponseBodyAsString());       post.releaseConnection();    } }复制代码6． 访问启用认证的页面我们经常会碰到这样的页面，当访问它的时候会弹出一个浏览器的对话框要求输入用户名和密码后方可，这种用户认证的方式不同于我们在前面介绍的基于表单的用户身份验证。这是HTTP的认证策略，httpclient支持三种认证方式包括：基本、摘要以及NTLM认证。其中基本认证最简单、通用但也最不安全；摘要认证是在HTTP 1.1中加入的认证方式，而NTLM则是微软公司定义的而不是通用的规范，最新版本的NTLM是比摘要认证还要安全的一种方式。下面例子是从httpclient的CVS服务器中下载的，它简单演示如何访问一个认证保护的页面：复制代码import org.apache.commons.httpclient.HttpClient; import org.apache.commons.httpclient.UsernamePasswordCredentials; import org.apache.commons.httpclient.methods.GetMethod; public class BasicAuthenticationExample {    public BasicAuthenticationExample() {    }   public static void main(String[] args) throws Exception {      HttpClient client = new HttpClient();      client.getState().setCredentials( "www.verisign.com" , "realm" , new UsernamePasswordCredentials( "username" , "password" ) );      GetMethod get = new GetMethod( "https://www.verisign.com/products/index.html" );      get.setDoAuthentication( true );      int status = client.executeMethod( get );      System.out.println(status+ "\n" + get.getResponseBodyAsString());      get.releaseConnection();   } }复制代码7． 多线程模式下使用多线程同时访问httpclient，例如同时从一个站点上下载多个文件。对于同一个HttpConnection同一个时间只能有一个线程访问，为了保证多线程工作环境下不产生冲突，httpclient使用了一个多线程连接管理器的类：MultiThreadedHttpConnectionManager，要使用这个类很简单，只需要在构造HttpClient实例的时候传入即可，代码如下：MultiThreadedHttpConnectionManager connectionManager = new MultiThreadedHttpConnectionManager();HttpClient client = new HttpClient(connectionManager);以后尽管访问client实例即可。httpClient完整封装HttpInvoke.java:封装了HttpClient调度的必要参数设置,以及post,get等常用方法复制代码import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.apache.commons.httpclient.*;import org.apache.commons.httpclient.auth.AuthScope;import org.apache.commons.httpclient.methods.PostMethod;import org.apache.commons.httpclient.methods.GetMethod;import java.util.Iterator;import java.util.Map;import java.net.SocketTimeoutException;import java.io.BufferedReader;import java.io.InputStreamReader;public class HttpInvoker {    private Log logger = LogFactory.getLog(HttpInvoker.class);    private static HttpInvoker httpInvoker = new HttpInvoker();    private HttpClient client = null;    private String charset = "gbk";    private int timeout = 10000;    private boolean useProxy = false;    private String proxyHost = null;    private int proxyPort;    private String proxyUsername = null;    private String proxyPassword = null;    private boolean initialized = false;    public static HttpInvoker getInstance() {        return httpInvoker;    }    private HttpInvoker() {        client = new HttpClient(new MultiThreadedHttpConnectionManager());        client.getParams().setParameter("http.protocol.content-charset", "gbk");        client.getParams().setContentCharset("gbk");        client.getParams().setSoTimeout(timeout);    }    public HttpInvoker(String charset, int timeout, boolean useProxy,                       String proxyHost, int proxyPort, String proxyUsername,                       String proxyPassword) {        client = new HttpClient(new MultiThreadedHttpConnectionManager());        if(charset != null && !charset.trim().equals("")) {            this.charset = charset;        }        if(timeout > 0) {            this.timeout = timeout;        }        client.getParams().setParameter("http.protocol.content-charset", charset);        client.getParams().setContentCharset(charset);        client.getParams().setSoTimeout(timeout);        if(useProxy && proxyHost != null &&                !proxyHost.trim().equals("") && proxyPort > 0) {            HostConfiguration hc = new HostConfiguration();            hc.setProxy(proxyHost, proxyPort);            client.setHostConfiguration(hc);            if (proxyUsername != null && !proxyUsername.trim().equals("") &&                    proxyPassword != null && !proxyPassword.trim().equals("")) {                client.getState().setProxyCredentials(AuthScope.ANY,                    new UsernamePasswordCredentials(proxyUsername, proxyPassword));            }        }        initialized = true;        logger.debug("HttpInvoker初始化完成");    }    public synchronized void init() {        if(charset != null && !charset.trim().equals("")) {            client.getParams().setParameter("http.protocol.content-charset", charset);            client.getParams().setContentCharset(charset);        }        if(timeout > 0) {            client.getParams().setSoTimeout(timeout);        }        if(useProxy && proxyHost != null &&                !proxyHost.trim().equals("") && proxyPort > 0) {            HostConfiguration hc = new HostConfiguration();            hc.setProxy(proxyHost, proxyPort);            client.setHostConfiguration(hc);            if (proxyUsername != null && !proxyUsername.trim().equals("") &&                    proxyPassword != null && !proxyPassword.trim().equals("")) {                client.getState().setProxyCredentials(AuthScope.ANY,                    new UsernamePasswordCredentials(proxyUsername, proxyPassword));            }        }        initialized = true;        logger.debug("HttpInvoker初始化完成");    }    public String invoke(String url) throws Exception {        return invoke(url, null, false);    }    public String invoke(String url, Map params, boolean isPost) throws Exception {        logger.debug("HTTP调用[" + (isPost?"POST":"GET") + "][" + url + "][" + params + "]");        HttpMethod httpMethod = null;        String result = "";        try {            if(isPost && params != null && params.size() > 0) {                Iterator paramKeys = params.keySet().iterator();                httpMethod = new PostMethod(url);                NameValuePair[] form = new NameValuePair[params.size()];                int formIndex = 0;                while(paramKeys.hasNext()) {                    String key = (String)paramKeys.next();                    Object value = params.get(key);                    if(value != null && value instanceof String && !value.equals("")) {                        form[formIndex] = new NameValuePair(key, (String)value);                        formIndex++;                    } else if(value != null && value instanceof String[] &&                            ((String[])value).length > 0) {                        NameValuePair[] tempForm =                                new NameValuePair[form.length + ((String[])value).length - 1];                        for(int i=0; i<formIndex; i++) {                            tempForm[i] = form[i];                        }                        form = tempForm;                        for(String v : (String[])value) {                            form[formIndex] = new NameValuePair(key, (String)v);                            formIndex++;                        }                    }                }                ((PostMethod)httpMethod).setRequestBody(form);            } else {                if(params != null && params.size() > 0) {                    Iterator paramKeys = params.keySet().iterator();                    StringBuffer getUrl = new StringBuffer(url.trim());                    if(url.trim().indexOf("?") > -1) {                        if(url.trim().indexOf("?") < url.trim().length()-1 &&                                url.trim().indexOf("&")  < url.trim().length()-1) {                            getUrl.append("&");                        }                    } else {                        getUrl.append("?");                    }                    while(paramKeys.hasNext()) {                        String key = (String)paramKeys.next();                        Object value = params.get(key);                        if(value != null && value instanceof String && !value.equals("")) {                            getUrl.append(key).append("=").append(value).append("&");                        } else if(value != null && value instanceof String[] &&                                ((String[])value).length > 0) {                            for(String v : (String[])value) {                                getUrl.append(key).append("=").append(v).append("&");                            }                        }                    }                    if(getUrl.lastIndexOf("&") == getUrl.length()-1) {                        httpMethod = new GetMethod(getUrl.substring(0, getUrl.length()-1));                    } else {                        httpMethod = new GetMethod(getUrl.toString());                    }                } else {                    httpMethod = new GetMethod(url);                }            }            client.executeMethod(httpMethod);//            result = httpMethod.getResponseBodyAsString();            BufferedReader reader = new BufferedReader(new InputStreamReader(                    httpMethod.getResponseBodyAsStream(),"ISO-8859-1"));            String line = null;            String html = null;            while((line = reader.readLine()) != null){                if(html == null) {                    html = "";                } else {                    html += "\r\n";                }                html += line;            }            if(html != null) {                result = new String(html.getBytes("ISO-8859-1"), charset);            }        } catch (SocketTimeoutException e) {            logger.error("连接超时[" + url + "]");            throw e;        } catch (java.net.ConnectException e) {            logger.error("连接失败[" + url + "]");            throw e;        } catch (Exception e) {            logger.error("连接时出现异常[" + url + "]");            throw e;        } finally {            if (httpMethod != null) {                try {                    httpMethod.releaseConnection();                } catch (Exception e) {                    logger.error("释放网络连接失败[" + url + "]");                    throw e;                }            }        }        return result;    }    public void setCharset(String charset) {        this.charset = charset;    }    public void setTimeout(int timeout) {        this.timeout = timeout;    }    public void setProxyHost(String proxyHost) {        this.proxyHost = proxyHost;    }    public void setProxyPort(int proxyPort) {        this.proxyPort = proxyPort;    }    public void setProxyUsername(String proxyUsername) {        this.proxyUsername = proxyUsername;    }    public void setProxyPassword(String proxyPassword) {        this.proxyPassword = proxyPassword;    }    public void setUseProxy(boolean useProxy) {        this.useProxy = useProxy;    }    public synchronized boolean isInitialized() {        return initialized;    }}复制代码http访问网络的代理ip和端口，还有使用用户及密码都可以在Spring容器中注入进来:复制代码<bean id="httpInvoker" class="HttpInvoker">        <constructor-arg type="java.lang.String" value="gbk" /><!--useProxy-->        <constructor-arg type="int" value="10000" /><!--useProxy-->        <constructor-arg type="boolean" value="true" /><!--useProxy-->        <!--代理地址 -->        <constructor-arg type="java.lang.String" value="192.168.1.1" />        <constructor-arg type="int" value="8080" />        <constructor-arg type="java.lang.String" value="" /><!--用户名-->        <constructor-arg type="java.lang.String" value="" /><!--密码--></bean>复制代码使用方式：postMap<String,String> params = new HashMap<String,String>();params.put("check", check);String result = httpInvoker.invoke( "someURL", params, true);使用方式：getString content  = httpInvoker.invoke(url);参考资料：httpclient首页：    http://jakarta.apache.org/commons/httpclient/关于NTLM是如何工作：  http://davenport.sourceforge.net/ntlm.html－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－HttpClient入门http://blog.csdn.net/ambitiontan/archive/2006/01/07/572644.aspxJakarta Commons HttpClient 学习笔记http://blog.csdn.net/cxl34/archive/2005/01/19/259051.aspxCookies,SSL，httpclient的多线程处理，HTTP方法http://blog.csdn.net/bjbs_270/archive/2004/11/05/168233.aspxHttpClient 学习整理

使用httpclient必须知道的参数设置及代码写法、存在的风险

博客分类： java web

结论：
如果使用httpclient 3.1并发量比较大的项目，最好升级到httpclient4.2.3上，保证并发量大时能抗住。httpclient 4.3.3，目前还有一些bug；还是用4.2.x稳定版本吧。

以库存项目为例：
httpclient一天并发量在1500w左右，峰值一秒7万。

在之前使用过程中，一直存在大量的

org.apache.http.conn.ConnectionPoolTimeoutException: Timeout waiting for connection from pool
at org.apache.http.impl.conn.PoolingClientConnectionManager.leaseConnection(PoolingClientConnectionManager.java:232)
at org.apache.http.impl.conn.PoolingClientConnectionManager1.getConnection(PoolingClientConnectionManager.java:199)atorg.apache.http.impl.client.DefaultRequestDirector.execute(DefaultRequestDirector.java:456)另外通过jstack查看线程，会发现：“pool−21−thread−3”prio=10tid=0x00007f6b7c002800nid=0x40ffwaitingoncondition[0x00007f6b37020000]java.lang.Thread.State:TIMEDWAITING(parking)atsun.misc.Unsafe.park(NativeMethod)−parkingtowaitfor<0x00000000f97918b8>(ajava.util.concurrent.locks.AbstractQueuedSynchronizerConditionObject)
at java.util.concurrent.locks.LockSupport.parkUntil(LockSupport.java:239)
at java.util.concurrent.locks.AbstractQueuedSynchronizerConditionObject.awaitUntil(AbstractQueuedSynchronizer.java:2072)atorg.apache.http.pool.PoolEntryFuture.await(PoolEntryFuture.java:129)atorg.apache.http.pool.AbstractConnPool.getPoolEntryBlocking(AbstractConnPool.java:281)atorg.apache.http.pool.AbstractConnPool.access000(AbstractConnPool.java:62)
at org.apache.http.pool.AbstractConnPool2.getPoolEntry(AbstractConnPool.java:176)atorg.apache.http.pool.AbstractConnPool2.getPoolEntry(AbstractConnPool.java:172)
at org.apache.http.pool.PoolEntryFuture.get(PoolEntryFuture.java:100)
at org.apache.http.impl.conn.PoolingClientConnectionManager.leaseConnection(PoolingClientConnectionManager.java:212)

问题：
因为使用了连接池，但连接不够用，造成大量的等待；而且这种等待都有滚雪球的效应（和交易组最近使用的apache common dbcp存在的风险是类似的）。

解决方案
最终我们定了一些合理的参数值，目前来看还没有遇到问题。

思考
其实出问题的原因是我们对一些参数不了解，随意设置其值，不出现问题则好，出现问题很难排查到原因，因此我把使用httpclient必须设置的参数及代码写法及排查方法总结一下，供参考。

参数设置
1、httpclient 4.2.3
HttpParams params = new BasicHttpParams();
//设置连接超时时间
Integer CONNECTION_TIMEOUT = 2 * 1000; //设置请求超时2秒钟 根据业务调整
Integer SO_TIMEOUT = 2 * 1000; //设置等待数据超时时间2秒钟 根据业务调整
//定义了当从ClientConnectionManager中检索ManagedClientConnection实例时使用的毫秒级的超时时间
//这个参数期望得到一个java.lang.Long类型的值。如果这个参数没有被设置，默认等于CONNECTION_TIMEOUT，因此一定要设置
Long CONN_MANAGER_TIMEOUT = 500L; //该值就是连接不够用的时候等待超时时间，一定要设置，而且不能太大 ()

params.setIntParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, CONNECTION_TIMEOUT);
params.setIntParameter(CoreConnectionPNames.SO_TIMEOUT, SO_TIMEOUT);
params.setLongParameter(ClientPNames.CONN_MANAGER_TIMEOUT, CONN_MANAGER_TIMEOUT);
//在提交请求之前 测试连接是否可用
params.setBooleanParameter(CoreConnectionPNames.STALE_CONNECTION_CHECK, true);

PoolingClientConnectionManager conMgr = new PoolingClientConnectionManager();
conMgr.setMaxTotal(200); //设置整个连接池最大连接数 根据自己的场景决定
//是路由的默认最大连接（该值默认为2），限制数量实际使用DefaultMaxPerRoute并非MaxTotal。
//设置过小无法支持大并发(ConnectionPoolTimeoutException: Timeout waiting for connection from pool)，路由是对maxTotal的细分。
conMgr.setDefaultMaxPerRoute(conMgr.getMaxTotal());//（目前只有一个路由，因此让他等于最大值）

//另外设置http client的重试次数，默认是3次；当前是禁用掉（如果项目量不到，这个默认即可）
httpClient.setHttpRequestRetryHandler(new DefaultHttpRequestRetryHandler(0, false));
此处解释下MaxtTotal和DefaultMaxPerRoute的区别：
1、MaxtTotal是整个池子的大小；
2、DefaultMaxPerRoute是根据连接到的主机对MaxTotal的一个细分；比如：
MaxtTotal=400 DefaultMaxPerRoute=200
而我只连接到http://sishuok.com时，到这个主机的并发最多只有200；而不是400；
而我连接到http://sishuok.com 和 http://qq.com时，到每个主机的并发最多只有200；即加起来是400（但不能超过400）；所以起作用的设置是DefaultMaxPerRoute。

2、httpclient 3.1
HttpConnectionManagerParams params = new HttpConnectionManagerParams();
params.setConnectionTimeout(2000);
params.setSoTimeout(2000);
// 最大连接数
params.setMaxTotalConnections(500);
params.setDefaultMaxConnectionsPerHost(500);
params.setStaleCheckingEnabled(true);
connectionManager.setParams(params);

HttpClientParams httpClientParams = new HttpClientParams();
// 设置httpClient的连接超时，对连接管理器设置的连接超时是无用的
httpClientParams.setConnectionManagerTimeout(5000); //等价于4.2.3中的CONN_MANAGER_TIMEOUT
httpClient = new HttpClient(connectionManager);
httpClient.setParams(httpClientParams);

//另外设置http client的重试次数，默认是3次；当前是禁用掉（如果项目量不到，这个默认即可）
httpClientParams.setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(0, false));

参数类似 就不多解释了；

代码写法
1、httpclient 4.2.3
HttpResponse response = null;
HttpEntity entity = null;
try {
HttpGet get = new HttpGet();
String url = “http://hc.apache.org/“;
get.setURI(new URI(url));
response = getHttpClient().execute(get);
/ /处理响应
} catch (Exception e) {
//处理异常
} finally {
if(response != null) {
EntityUtils.consume(response.getEntity()); //会自动释放连接
}
//如下方法也是可以的，但是存在一些风险；不要用
//InputStream is = response.getEntity().getContent();
//is.close();
}

2、httpclient 3.1
PostMethod postMethod = new PostMethod(yxUrl);
try {
httpClient.executeMethod(postMethod);
} catch (Exception e) {
//处理异常
} finally {
if(postMethod != null) { //不要忘记释放，尽量通过该方法实现，
postMethod.releaseConnection();
//存在风险，不要用
//postMethod.setParameter(“Connection”, “close”);
//InputStream is = postMethod.getResponseBodyAsStream();
//is.clsoe();也会关闭并释放连接的
}
}

存在的风险
1、httpclient 4.2.3 在释放连接时
if (managedConn.isOpen() && !managedConn.isMarkedReusable()) { //如果连接打开的且不可重用（not keepalive） close socket
try {
managedConn.shutdown();
} catch (IOException iox) {
if (this.log.isDebugEnabled()) {
this.log.debug(“I/O exception shutting down released connection”, iox);
}
}
}
// Only reusable connections can be kept alive
if (managedConn.isMarkedReusable()) {
entry.updateExpiry(keepalive, tunit != null ? tunit : TimeUnit.MILLISECONDS);
if (this.log.isDebugEnabled()) {
String s;
if (keepalive > 0) {
s = “for ” + keepalive + ” ” + tunit;
} else {
s = “indefinitely”;
}
this.log.debug(“Connection ” + format(entry) + ” can be kept alive ” + s);
}
}
无风险

2、httpclient 3.1
1、如果走http1.1协议：如果proxy-connection/connection请求头设置为close；那么会关闭socket； 或者这两个头不等于close 也会自动关；
2、如果是keep-alive ，不会关闭；
3、如果协议小于等于http1.0协议没有问题；调用releaseConnection时会close socket；
4、其他情况不会close；

也就是说如果走http1.1且没有设置相关参数；那么socket其实是没有关闭的；可能造成很多TIME_WAIT；因此如果是走短连接建议设置postMethod.setParameter(“Connection”, “close”)。

其他注意事项：
1、使用keep-alive一定要设置Content-Length头（否则也不是长连接）。

2、在使用httpclient3.1时（4.2.3没问题）；尽量不要调用 byte[] getResponseBody() ：因为如果Content-Length没设置或者传输的数据大于1M，会有大量如下日志
LOG.warn(“Going to buffer response body of large or unknown size. ”
+”Using getResponseBodyAsStream instead is recommended.”);

如果大于1M可以设置该参数；但是-1的话就没办法了，就不要调用 byte[] getResponseBody()
httpClientParams.setLongParameter(HttpMethodParams.BUFFER_WARN_TRIGGER_LIMIT, 2L * 1024 * 1024);

3、锁
httpclient 3.1 使用synchronized+wait+notifyAll，存在两个问题，量大synchronized慢和notifyAll可能造成线程饥饿；httpclient 4.2.3 使用 ReentrantLock（默认非公平） + Condition（每个线程一个）。

这里有个测试：http://java.dzone.com/articles/synchronized-vs-lock ，在我本机（jdk1.6.0_43 ）测试结果明细锁的优势比较大
1x synchronized {} with 32 threads took 2.621 seconds
1x Lock.lock()/unlock() with 32 threads took 1.951 seconds
1x AtomicInteger with 32 threads took 4.113 seconds
1x synchronized {} with 64 threads took 2.621 seconds
1x Lock.lock()/unlock() with 64 threads took 1.983 seconds

这也是为什么在库存项目中使用httpclient 3.1 依然有大量的wait，而httpclient4.2.3 一个没有的问题所在