`
happyqing
  • 浏览: 3194393 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

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

javahttpclienthttpsgetpost 
阅读更多

 

使用的是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

httpclient 4 https请求
百度：httpclient https post

 

分享到：
| Websphere修改web.xml不生效的解决办法
评论
1 楼 heikehuan 2016-03-23  
非常感谢，找了半天，你的这个解决了我的问题
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java后端HttpClient Post提交文件流 及服务端接收文件流

    HttpClient Post提交多文件及多个普通参数,已经封装成工具类。 需传入 要请求的url 普通参数map 例 map.put("param1","张三"); 需要传入的文件流map 其中key为文件名 服务端接收无乱码。

    HttpClient工具类

    本文将详细介绍一个基于`HttpClient`的工具类，它能够帮助开发者轻松地发送GET和POST请求，并支持XML及JSON格式的数据传输。 #### 工具类概述 该工具类名为`HttpClientUtil`，位于包`com.taotao.utils`中。主要...

    HttpClientUtil工具类 里面包含GET POST 及返回值处理

    HttpClientUtil工具类是Java开发中一个非常实用的工具，它封装了Apache的HttpClient库，用于简化HTTP请求的发送，包括GET和POST方法。这个工具类的主要优点在于它可以帮助开发者快速地构建网络请求，无需深入了解...

    httpClient 调用远程接口 获取数据到本地文件夹

    HttpClient是Apache HTTP Components项目的一部分，它是一个强大的Java库，用于执行HTTP请求。在这个场景中，我们使用HttpClient来调用远程接口，从电信公司的网站获取可用的新手机号码信息，并将这些数据存储到本地...

    android之http协议编程）第三集hjava_http_post.zip

    本教程主要聚焦于HTTP POST方法的使用，这是HTTP协议中的一个核心概念，用于向服务器发送数据。POST请求常用于提交表单、上传文件或者在API接口中传递复杂的数据结构。 首先，我们需要了解HTTP协议的基本原理。HTTP...

    webservice调用实例，通过HttpClient调用

    同时，根据具体业务需求，可能还需要对返回的数据进行解析，例如使用JSON库（如Jackson或Gson）将响应转换为Java对象。 总之，通过HttpClient调用Web服务是一个涉及网络通信和HTTP协议理解的过程。在实际开发中，...

    Java Http工具类HttpClientUtil

    多年积累，功能比较强大，可设置路由连接数，时间，请求类型包括get,post, 参数包括urlcode,map,json,xml。注释很清楚。

    android使用JSON进行网络数据交换(服务端、客户端)的实现.rar

    总结，这个压缩包的实现可能涵盖了Android客户端使用Retrofit发送网络请求、解析JSON数据，以及服务器端处理JSON请求并返回的过程。在实际项目中，还需要考虑安全性、性能优化和错误处理等多方面因素。

    Java发送httpPost请求–传消息头，消息体的方法

    在Java编程中，发送HTTP POST请求是常见的网络通信任务，特别是在与远程服务器或API接口进行交互时。Apache HttpClient库提供了一种强大且灵活的方式来实现这一功能。本文将详细讲解如何利用HttpClient工具类发送带...

    Http请求接口方法封装及Demo

    4. **发送请求**：使用HttpClient库的API，构造一个POST请求，并设置请求头、URL和请求主体。 5. **处理响应**：发送请求后，客户端会接收到服务器的响应，包括状态码、响应头和响应体。根据状态码判断请求是否成功...

    http请求工具类

    3. **Header管理**：设置请求头，如`Content-Type`、`Authorization`等，这对于发送JSON或XML数据，或者进行身份验证至关重要。 4. **异步请求**：为了不阻塞UI线程，`HttpUtil`可能提供异步请求方法，如`asyncGet...

    Java灵活易用自封装http客户端

    这些库提供了丰富的功能，包括设置请求方法（GET、POST等）、添加请求头、发送和接收数据等。 对于自封装的HTTP客户端，我们可以创建一个通用的接口，例如名为`PureWaterInterfaces`，其中定义了发起HTTP请求的方法...

    Java调用第三方接口示范的实现

    `RestTemplate`同样支持GET和POST请求，以及处理不同类型的响应数据，如JSON、XML等。使用`RestTemplate`时，代码通常更加简洁，适合Spring环境。 在实际应用中，我们可能需要处理各种复杂情况，如超时、重试、错误...

    基于httpClient的文件编码导入系统

    HttpClient是Apache开源组织提供的一款强大的HTTP客户端库，它允许开发者在Java环境中发送HTTP请求并接收响应，广泛应用于数据交换、文件上传下载等场景。 首先，我们需要了解HttpClient的基本用法。HttpClient支持...

    RestUtil.zip

    本文将详细介绍如何使用`RestUtil.zip`中的工具类`RestUtil`来实现REST API的调用，包括POST和GET方法，并处理JSON或XML响应数据。`RestUtil`是一个简洁实用的工具，它整合了Maven项目，使得RESTful调用变得更加便捷...

    android调用struts2源码

    在Android应用开发中，有时需要与服务器进行交互，获取或发送数据。在这个场景下，`Struts2`作为一款流行的Java Web框架，被广泛用于构建服务端接口。本示例探讨的是如何在Android客户端调用Struts2源码来实现JSON...

    request处理

    POST请求的参数则放在请求体中，可以是URL编码的形式，也可以是JSON、XML等格式。 5. **处理请求的框架**：例如Spring MVC、Struts2、Express.js（Node.js）等，它们提供了一套结构化的框架来简化请求的处理。 6. ...

    享兼职移动APP-3期（AL028） 详细设计书8-通讯模块.doc

    - `doPost3()`：以JSON格式传递参数的POST请求。 - `doFile()`：文件上传方法，需要指定URL、文件路径和名称，以及回调函数。 **3. 项目中的调用** `HttpUtils`类中的方法被设计为静态，以便于直接调用，如`...

    享兼职移动APP-3期（AL028） AL028030200008 详细设计书8-通讯模块.doc

    - `doPost()`：POST请求，接收URL和Map参数，将参数放入请求体中。 - `doPost2()`：与`doPost()`类似，但额外接收一个session参数，将其设置在请求头中。 - `doPostWithJson()`：POST请求，支持JSON格式的参数。 ...

    Map2-9-10.rar_Android programing_android google map_android htt

    使用`new Request.Builder()`构建请求，指定URL、HTTP方法（GET、POST等）、请求头和请求体。调用OkHttpClient的`newCall(request).enqueue(callback)`方法发起异步请求，回调中处理响应。对于JSON数据，可以使用...

Magicbox
Global site tag (gtag.js) - Google Analytics