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

小灰灰 2022-04-12 12:07 498阅读 0赞

使用的是httpclient 3.1，

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

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

其中信任任何证书的类MySSLProtocolSocketFactory

主要代码：

HttpClient client = new HttpClient();     
Protocol myhttps = new Protocol("https", new MySSLProtocolSocketFactory(), 443);    
Protocol.registerProtocol("https", myhttps);  
PostMethod method = new PostMethod(url);

HttpUtil

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

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[] {};
    		}
    	}
    
    }

参考：

httpclient 3 https请求  
[http://hougbin.iteye.com/blog/1196063][http_hougbin.iteye.com_blog_1196063]

httpclient 4 https请求  
百度：httpclient https post

[http_hougbin.iteye.com_blog_1196063]: http://hougbin.iteye.com/blog/1196063