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[] {};  
   }  
  複製程式碼

  }

}