Java用HttpClient3发送http/https协议get/post请求，发送map，json，xml，txt数据

使用的是httpclient 3.1， 使用"httpclient"4的写法相对简单点，百度：httpclient https post

当不需要使用任何证书访问https网页时，只需配置信任任何证书 其中信任任何证书的类MySSLProtocolSocketFactory

www.jianshu.com/p/75d64e274…

主要代码： HttpClient client = new HttpClient();
Protocol myhttps = new Protocol("https", new MySSLProtocolSocketFactory(), 443);
Protocol.registerProtocol("https", myhttps); PostMethod method = new PostMethod(url);

HttpUtil Java代码 收藏代码 package com.urthinker.wxyh.util;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Map;

import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.URIException;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.httpclient.methods.RequestEntity;
import org.apache.commons.httpclient.methods.StringRequestEntity;
import org.apache.commons.httpclient.params.HttpMethodParams;
import org.apache.commons.httpclient.protocol.Protocol;
import org.apache.commons.httpclient.util.URIUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**

• HTTP工具类

• 发送http/https协议get/post请求，发送map，json，xml，txt数据

• @author happyqing 2016-5-20
  */
  public final class HttpUtil {
  private static Log log = LogFactory.getLog(HttpUtil.class);

    /** 
     * 执行一个http/https get请求，返回请求响应的文本数据 
     *  
     * @param url           请求的URL地址 
     * @param queryString   请求的查询参数,可以为null 
     * @param charset       字符集 
     * @param pretty        是否美化 
     * @return              返回请求响应的文本数据 
     */  
    public static String doGet(String url, String queryString, String charset, boolean pretty) {     
            StringBuffer response = new StringBuffer();  
            HttpClient client = new HttpClient();  
            if(url.startsWith("https")){  
                //https请求  
                Protocol myhttps = new Protocol("https", new MySSLProtocolSocketFactory(), 443);     
                Protocol.registerProtocol("https", myhttps);  
            }  
            HttpMethod method = new GetMethod(url);  
            try {  
                    if (StringUtils.isNotBlank(queryString))      
                        //对get请求参数编码，汉字编码后，就成为%式样的字符串  
                        method.setQueryString(URIUtil.encodeQuery(queryString));  
                    client.executeMethod(method);  
                    if (method.getStatusCode() == HttpStatus.SC_OK) {  
                        BufferedReader reader = new BufferedReader(new InputStreamReader(method.getResponseBodyAsStream(), charset));  
                        String line;  
                        while ((line = reader.readLine()) != null) {  
                            if (pretty)  
                                response.append(line).append(System.getProperty("line.separator"));  
                            else  
                                response.append(line);  
                        }  
                        reader.close();  
                    }  
            } catch (URIException e) {  
                log.error("执行Get请求时，编码查询字符串“" + queryString + "”发生异常！", e);  
            } catch (IOException e) {  
                log.error("执行Get请求" + url + "时，发生异常！", e);  
            } finally {  
                method.releaseConnection();  
            }  
            return response.toString();  
    }      
  
    /** 
     * 执行一个http/https post请求，返回请求响应的文本数据 
     *  
     * @param url       请求的URL地址 
     * @param params    请求的查询参数,可以为null 
     * @param charset   字符集 
     * @param pretty    是否美化 
     * @return          返回请求响应的文本数据 
     */  
    public static String doPost(String url, Map<String, String> params, String charset, boolean pretty) {  
            StringBuffer response = new StringBuffer();  
            HttpClient client = new HttpClient();  
            if(url.startsWith("https")){  
                //https请求  
                Protocol myhttps = new Protocol("https", new MySSLProtocolSocketFactory(), 443);  
                Protocol.registerProtocol("https", myhttps);  
            }  
            PostMethod method = new PostMethod(url);  
            //设置参数的字符集  
            method.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET,charset);  
            //设置post数据  
            if (params != null) {  
                //HttpMethodParams p = new HttpMethodParams();      
                for (Map.Entry<String, String> entry : params.entrySet()) {  
                    //p.setParameter(entry.getKey(), entry.getValue());     
                    method.setParameter(entry.getKey(), entry.getValue());  
                }  
                //method.setParams(p);  
            }  
            try {  
                    client.executeMethod(method);  
                    if (method.getStatusCode() == HttpStatus.SC_OK) {  
                        BufferedReader reader = new BufferedReader(new InputStreamReader(method.getResponseBodyAsStream(), charset));  
                        String line;  
                        while ((line = reader.readLine()) != null) {  
                            if (pretty)  
                                response.append(line).append(System.getProperty("line.separator"));  
                            else  
                                response.append(line);   
                        }  
                        reader.close();  
                    }  
            } catch (IOException e) {  
                log.error("执行Post请求" + url + "时，发生异常！", e);  
            } finally {  
                method.releaseConnection();  
            }  
            return response.toString();  
    }  
      
    /** 
     * 执行一个http/https post请求， 直接写数据 json,xml,txt 
     *  
     * @param url       请求的URL地址 
     * @param params    请求的查询参数,可以为null 
     * @param charset   字符集 
     * @param pretty    是否美化 
     * @return          返回请求响应的文本数据 
     */  
    public static String writePost(String url, String content, String charset, boolean pretty) {   
            StringBuffer response = new StringBuffer();  
            HttpClient client = new HttpClient();  
            if(url.startsWith("https")){  
                //https请求  
                Protocol myhttps = new Protocol("https", new MySSLProtocolSocketFactory(), 443);  
                Protocol.registerProtocol("https", myhttps);  
            }  
            PostMethod method = new PostMethod(url);  
            try {  
                    //设置请求头部类型参数  
                    //method.setRequestHeader("Content-Type","text/plain; charset=utf-8");//application/json,text/xml,text/plain  
                    //method.setRequestBody(content); //InputStream,NameValuePair[],String  
                    //RequestEntity是个接口，有很多实现类，发送不同类型的数据  
                    RequestEntity requestEntity = new StringRequestEntity(content,"text/plain",charset);//application/json,text/xml,text/plain  
                    method.setRequestEntity(requestEntity);  
                    client.executeMethod(method);  
                    if (method.getStatusCode() == HttpStatus.SC_OK) {    
                        BufferedReader reader = new BufferedReader(new InputStreamReader(method.getResponseBodyAsStream(), charset));  
                        String line;  
                        while ((line = reader.readLine()) != null) {  
                            if (pretty)  
                                response.append(line).append(System.getProperty("line.separator"));  
                            else  
                                response.append(line);  
                        }  
                        reader.close();  
                    }      
            } catch (Exception e) {  
                log.error("执行Post请求" + url + "时，发生异常！", e);  
            } finally {  
                method.releaseConnection();  
            }  
            return response.toString();  
    }  
  
    public static void main(String[] args) {  
        try {  
            String y = doGet("http://video.sina.com.cn/life/tips.html", null, "GBK", true);  
            System.out.println(y);  
  复制代码

// Map params = new HashMap();
// params.put("param1", "value1");
// params.put("json", "{"aa":"11"}");
// String j = doPost("http://localhost/uplat/manage/test.do?reqCode=add", params, "UTF-8", true);
// System.out.println(j);

        } catch (Exception e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
    }  
复制代码

}

MySSLProtocolSocketFactory Java代码 收藏代码 import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.UnknownHostException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.SocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.commons.httpclient.ConnectTimeoutException;
import org.apache.commons.httpclient.params.HttpConnectionParams;
import org.apache.commons.httpclient.protocol.ProtocolSocketFactory;

/**

• author by lpp

• created at 2010-7-26 上午09:29:33 */
  public class MySSLProtocolSocketFactory implements ProtocolSocketFactory {

  private SSLContext sslcontext = null;

  private SSLContext createSSLContext() {
  SSLContext sslcontext = null;
  try {
  // sslcontext = SSLContext.getInstance("SSL");
  sslcontext = SSLContext.getInstance("TLS");
  sslcontext.init(null,
  new TrustManager[] { new TrustAnyTrustManager() },
  new java.security.SecureRandom());
  } catch (NoSuchAlgorithmException e) {
  e.printStackTrace();
  } catch (KeyManagementException e) {
  e.printStackTrace();
  }
  return sslcontext;
  }

  private SSLContext getSSLContext() {
  if (this.sslcontext == null) {
  this.sslcontext = createSSLContext();
  }
  return this.sslcontext;
  }

  public Socket createSocket(Socket socket, String host, int port, boolean autoClose)
  throws IOException, UnknownHostException {
  return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
  }

  public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
  return getSSLContext().getSocketFactory().createSocket(host, port);
  }

  public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort)
  throws IOException, UnknownHostException {
  return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
  }

  public Socket createSocket(String host, int port, InetAddress localAddress,
  int localPort, HttpConnectionParams params) throws IOException,
  UnknownHostException, ConnectTimeoutException {
  if (params == null) {
  throw new IllegalArgumentException("Parameters may not be null");
  }
  int timeout = params.getConnectionTimeout();
  SocketFactory socketfactory = getSSLContext().getSocketFactory();
  if (timeout == 0) {
  return socketfactory.createSocket(host, port, localAddress, localPort);
  } else {
  Socket socket = socketfactory.createSocket();
  SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);
  SocketAddress remoteaddr = new InetSocketAddress(host, port);
  socket.bind(localaddr);
  socket.connect(remoteaddr, timeout);
  return socket;
  }
  }

  // 自定义私有类
  private static class TrustAnyTrustManager implements X509TrustManager {

   public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
   }  
  
   public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
   }  
  
   public X509Certificate[] getAcceptedIssuers() {  
       return new X509Certificate[] {};  
   }  
  复制代码

  }

}