全面解析Apache HttpClient，涵盖特性、使用方法及实例，包括GET、POST请求、文件上传、SSL连接等，提供高效、灵活的HTTP客户端编程工具包。
目录
最简单post请求, 源自 http://my.oschina.net/xinxingegeya/blog/282683
可知模拟登录可以如下: 源自 http://bbs.csdn.net/topics/390195343\
我项目中用到的HttpClientUtil (2016/12/17)
轻松把玩HttpClient之封装HttpClient工具类
HttpMime实现http请求—post以及get请求、文件下载等
HttpClient相比传统JDK自带的URLConnection，增加了易用性和灵活性，它不仅使客户端发送Http请求变得容易，而且也方便开发人员测试接口（基于Http协议的），提高了开发的效率，也方便提高代码的健壮性。因此熟练掌握HttpClient是很重要的必修内容，掌握HttpClient后，相信对于Http协议的了解会更加深入。
org.apache.commons.httpclient.HttpClient与org.apache.http.client.HttpClient的区别
Commons的HttpClient项目现在是生命的尽头，不再被开发, 已被Apache HttpComponents项目HttpClient和HttpCore 模组取代，提供更好的性能和更大的灵活性。
一、简介
HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。HttpClient已经应用在很多的项目中，比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient。
下载地址: http://hc.apache.org/downloads.cgi
二、特性
1. 基于标准、纯净的java语言。实现了Http1.0和Http1.1
2. 以可扩展的面向对象的结构实现了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）。
3. 支持HTTPS协议。
4. 通过Http代理建立透明的连接。
5. 利用CONNECT方法通过Http代理建立隧道的https连接。
6. Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos认证方案。
7. 插件式的自定义认证方案。
8. 便携可靠的套接字工厂使它更容易的使用第三方解决方案。
9. 连接管理器支持多线程应用。支持设置最大连接数，同时支持设置每个主机的最大连接数，发现并关闭过期的连接。
10. 自动处理Set-Cookie中的Cookie。
11. 插件式的自定义Cookie策略。
12. Request的输出流可以避免流中内容直接缓冲到socket服务器。
13. Response的输入流可以有效的从socket服务器直接读取相应内容。
14. 在http1.0和http1.1中利用KeepAlive保持持久连接。
15. 直接获取服务器发送的response code和 headers。
16. 设置连接超时的能力。
17. 实验性的支持http1.1 response caching。
18. 源代码基于Apache License 可免费获取。
三、使用方法
使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可。
1. 创建HttpClient对象。
2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HttpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。
4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。
5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
6. 释放连接。无论执行方法是否成功，都必须释放连接
commons-cli-1.2.jar
commons-codec-1.9.jar
commons-logging-1.2.jar
fluent-hc-4.5.1.jar
httpclient-4.5.1.jar
httpclient-cache-4.5.1.jar
httpclient-win-4.5.1.jar
httpcore-4.4.3.jar
httpcore-ab-4.4.3.jar
httpcore-nio-4.4.3.jar
httpmime-4.5.1.jar
jna-4.1.0.jar
jna-platform-4.1.0.jar 最简单post请求, 源自 http://my.oschina.net/xinxingegeya/blog/282683
package a;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
public class First {
public static void main(String[] args) throws Exception{
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("account", ""));
formparams.add(new BasicNameValuePair("password", ""));
HttpEntity reqEntity = new UrlEncodedFormEntity(formparams, "utf-8");
RequestConfig requestConfig = RequestConfig.custom()
.setConnectTimeout(5000)//一、连接超时：connectionTimeout-->指的是连接一个url的连接等待时间
.setSocketTimeout(5000)// 二、读取数据超时：SocketTimeout-->指的是连接上一个url，获取response的返回等待时间
.setConnectionRequestTimeout(5000)
.build();
HttpClient client = new DefaultHttpClient();
HttpPost post = new HttpPost("http://cnivi.com.cn/login");
post.setEntity(reqEntity);
post.setConfig(requestConfig);
HttpResponse response = client.execute(post);
if (response.getStatusLine().getStatusCode() == 200) {
HttpEntity resEntity = response.getEntity();
String message = EntityUtils.toString(resEntity, "utf-8");
System.out.println(message);
} else {
System.out.println("请求失败");
}
}
} 四、实例
主文件
package com.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.util.ArrayList;
import java.util.List;
import javax.net.ssl.SSLContext;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.http.client.config.RequestConfig;
import org.junit.Test;
public class HttpClientTest {
//方法见下........
} HttpClientUtils工具类
package com.bobo.code.web.controller.technology.httpcomponents;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpUriRequest;
import org.apache.http.client.methods.RequestBuilder;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import java.io.IOException;
import java.util.*;
public class HttpClientUtils {
private static PoolingHttpClientConnectionManager connectionManager = null;
private static HttpClientBuilder httpBuilder = null;
private static RequestConfig requestConfig = null;
private static int MAXCONNECTION = 10;
private static int DEFAULTMAXCONNECTION = 5;
private static String IP = "cnivi.com.cn";
private static int PORT = 80;
static {
//设置http的状态参数
requestConfig = RequestConfig.custom()
.setSocketTimeout(5000)
.setConnectTimeout(5000)
.setConnectionRequestTimeout(5000)
.build();
HttpHost target = new HttpHost(IP, PORT);
connectionManager = new PoolingHttpClientConnectionManager();
connectionManager.setMaxTotal(MAXCONNECTION);//客户端总并行链接最大数
connectionManager.setDefaultMaxPerRoute(DEFAULTMAXCONNECTION);//每个主机的最大并行链接数
connectionManager.setMaxPerRoute(new HttpRoute(target), 20);
httpBuilder = HttpClients.custom();
httpBuilder.setConnectionManager(connectionManager);
}
public static CloseableHttpClient getConnection() {
CloseableHttpClient httpClient = httpBuilder.build();
return httpClient;
}
public static HttpUriRequest getRequestMethod(Map<String, String> map, String url, String method) {
List<NameValuePair> params = new ArrayList<NameValuePair>();
Set<Map.Entry<String, String>> entrySet = map.entrySet();
for (Map.Entry<String, String> e : entrySet) {
String name = e.getKey();
String value = e.getValue();
NameValuePair pair = new BasicNameValuePair(name, value);
params.add(pair);
}
HttpUriRequest reqMethod = null;
if ("post".equals(method)) {
reqMethod = RequestBuilder.post().setUri(url)
.addParameters(params.toArray(new BasicNameValuePair[params.size()]))
.setConfig(requestConfig).build();
} else if ("get".equals(method)) {
reqMethod = RequestBuilder.get().setUri(url)
.addParameters(params.toArray(new BasicNameValuePair[params.size()]))
.setConfig(requestConfig).build();
}
return reqMethod;
}
public static void main(String args[]) throws IOException {
Map<String, String> map = new HashMap<String, String>();
map.put("account", "");
map.put("password", "");
HttpClient client = getConnection();
HttpUriRequest post = getRequestMethod(map, "http://cnivi.com.cn/login", "post");
HttpResponse response = client.execute(post);
if (response.getStatusLine().getStatusCode() == 200) {
HttpEntity entity = response.getEntity();
String message = EntityUtils.toString(entity, "utf-8");
System.out.println(message);
} else {
System.out.println("请求失败");
}
}
} get方式
/**
* 发送 get请求
*/
public void get() {
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
// 创建httpget.
HttpGet httpget = new HttpGet("http://www.baidu.com/");
System.out.println("executing request " + httpget.getURI());
// 执行get请求.
CloseableHttpResponse response = httpclient.execute(httpget);
try {
// 获取响应实体
HttpEntity entity = response.getEntity();
System.out.println("--------------------------------------");
// 打印响应状态
System.out.println(response.getStatusLine());
if (entity != null) {
// 打印响应内容长度
System.out.println("Response content length: " + entity.getContentLength());
// 打印响应内容
System.out.println("Response content: " + EntityUtils.toString(entity));
}
System.out.println("------------------------------------");
} finally {
response.close();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭连接,释放资源
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} post方式
/**
* 发送 post请求访问本地应用并根据传递参数不同返回不同结果
*/
public void post() {
// 创建默认的httpClient实例.
CloseableHttpClient httpclient = HttpClients.createDefault();
// 创建httppost
HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");
// 创建参数队列
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("type", "house"));
UrlEncodedFormEntity uefEntity;
try {
uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");
httppost.setEntity(uefEntity);
System.out.println("executing request " + httppost.getURI());
CloseableHttpResponse response = httpclient.execute(httppost);
try {
HttpEntity entity = response.getEntity();
if (entity != null) {
System.out.println("--------------------------------------");
System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));
System.out.println("--------------------------------------");
}
} finally {
response.close();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭连接,释放资源
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} post方式乱码补充
如果有乱码,可以偿试使用 StringEntity 来替换HttpEntity:
StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二个参数，设置后才会对，内容进行编码
content.setContentType("application/soap+xml; charset=UTF-8");
content.setContentEncoding("UTF-8");
httppost.setEntity(content);
具体SOAP协议代码如下:
package com.isoftstone.core.service.impl;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Scanner;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.EntityBuilder;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;
import org.jdom.Document;
import org.jdom.Element;
import com.isoftstone.core.common.constant.RequestConstants;
import com.isoftstone.core.common.tools.XmlTool;
import com.isoftstone.core.service.intf.ServiceOfStringPara;
/**
*
*
*/
public class DeloittePricingSingleCarImpl implements ServiceOfStringPara {
private String serviceUrl = "http://10.30.0.35:7001/ZSInsUW/Auto/PricingService";
private static Logger log = Logger.getLogger(DeloittePricingSingleCarImpl.class.getName());
public String invoke(String sRequest) {
StringBuffer soapRequestData = new StringBuffer();
soapRequestData.append("<soapenv:Envelope");
soapRequestData.append(" xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" ");
soapRequestData.append(" xmlns:prov=\"http://provider.webservice.zsins.dtt.com/\">");
soapRequestData.append(" <soapenv:Header/> ");
soapRequestData.append("<soapenv:Body>");
soapRequestData.append("<prov:executePrvPricing>");
soapRequestData.append("<arg0>");
soapRequestData.append("<![CDATA[" + sRequest + "]]>");
soapRequestData.append("</arg0>");
soapRequestData.append("</prov:executePrvPricing>");
soapRequestData.append(" </soapenv:Body>");
soapRequestData.append("</soapenv:Envelope>");
HttpClient httpclient = HttpClients.createDefault();
HttpPost httppost = new HttpPost(serviceUrl);
StringEntity content =new StringEntity(soapRequestData.toString(), Charset.forName("UTF-8"));// 第二个参数，设置后才会对，内容进行编码
content.setContentType("application/soap+xml; charset=UTF-8");
content.setContentEncoding("UTF-8");
httppost.setEntity(content);
//用下面的服务器端以UTF-8接收到的报文会乱码,原因未知
// HttpEntity reqEntity = EntityBuilder.create().setContentType(
// ContentType.TEXT_PLAIN) // .TEXT_PLAIN
// .setText(soapRequestData.toString()).build();
// httppost.setEntity(reqEntity);
// httppost.addHeader("Content-Type",
// "application/soap+xml; charset=utf-8");
HttpResponse response = null;
Document doc = null;
String returnXml = null;
String sentity = null;
try {
response = httpclient.execute(httppost);
HttpEntity resEntity = response.getEntity();
if (resEntity != null) {
sentity = EntityUtils.toString(resEntity, "UTF-8");
doc = XmlTool.getDocument(sentity, RequestConstants.ENCODE);
System.out.println(doc.toString());
Element eRoot = doc.getRootElement();
Element body = eRoot.getChild("Body", eRoot.getNamespace());
Element resp = (Element) body.getChildren().get(0);
Element returnele = resp.getChild("return");
returnXml = returnele.getText().toString();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
log.info("发送给系统的请求报文：\n" + soapRequestData.toString());
log.info("系统返回的响应报文：\n" + sentity);
log.info("返回给核心的的报文:\n" + returnXml);
}
return returnXml;
}
public String getServiceUrl() {
return serviceUrl;
}
public void setServiceUrl(String serviceUrl) {
this.serviceUrl = serviceUrl;
}
public static void main(String[] args) throws Exception{
File file = new File("D:/test.txt");
System.out.println(file.exists());
String temp2 = null;
StringBuilder sb2 = new StringBuilder();
InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"GBK");
BufferedReader br = new BufferedReader(isr);
temp2 = br.readLine();
while( temp2 != null ){
sb2.append(temp2);
temp2 = br.readLine();
}
String sss = sb2.toString();
// System.out.println(sss.toString());
new DeloittePricingSingleCarImpl().invoke(sss);
}
}
post提交表单
/**
* post方式提交表单（模拟用户登录请求）
*/
public void postForm() {
// 创建默认的httpClient实例.
CloseableHttpClient httpclient = HttpClients.createDefault();
// 创建httppost
HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceJ.action");
// 创建参数队列
List<NameValuePair> formparams = new ArrayList<NameValuePair>();
formparams.add(new BasicNameValuePair("username", "admin"));
formparams.add(new BasicNameValuePair("password", "123456"));
UrlEncodedFormEntity uefEntity;
try {
uefEntity = new UrlEncodedFormEntity(formparams, "UTF-8");
httppost.setEntity(uefEntity);
System.out.println("executing request " + httppost.getURI());
CloseableHttpResponse response = httpclient.execute(httppost);
try {
HttpEntity entity = response.getEntity();
if (entity != null) {
System.out.println("--------------------------------------");
System.out.println("Response content: " + EntityUtils.toString(entity, "UTF-8"));
System.out.println("--------------------------------------");
}
} finally {
response.close();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭连接,释放资源
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} 文件上传
/**
* 上传文件
*/
public void upload() {
CloseableHttpClient httpclient = HttpClients.createDefault();
try {
HttpPost httppost = new HttpPost("http://localhost:8080/myDemo/Ajax/serivceFile.action");
FileBody bin = new FileBody(new File("F:\\image\\sendpix0.jpg"));
StringBody comment = new StringBody("A binary file of some kind", ContentType.TEXT_PLAIN);
HttpEntity reqEntity = MultipartEntityBuilder.create().addPart("bin", bin).addPart("comment", comment).build();
httppost.setEntity(reqEntity);
System.out.println("executing request " + httppost.getRequestLine());
CloseableHttpResponse response = httpclient.execute(httppost);
try {
System.out.println("----------------------------------------");
System.out.println(response.getStatusLine());
HttpEntity resEntity = response.getEntity();
if (resEntity != null) {
System.out.println("Response content length: " + resEntity.getContentLength());
}
EntityUtils.consume(resEntity);
} finally {
response.close();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} ssl连接
/**
* HttpClient连接SSL
*/
public void ssl() {
CloseableHttpClient httpclient = null;
try {
KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
FileInputStream instream = new FileInputStream(new File("d:\\tomcat.keystore"));
try {
// 加载keyStore d:\\tomcat.keystore
trustStore.load(instream, "123456".toCharArray());
} catch (CertificateException e) {
e.printStackTrace();
} finally {
try {
instream.close();
} catch (Exception ignore) {
}
}
// 相信自己的CA和所有自签名的证书
SSLContext sslcontext = SSLContexts.custom().loadTrustMaterial(trustStore, new TrustSelfSignedStrategy()).build();
// 只允许使用TLSv1协议
SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslcontext, new String[] { "TLSv1" }, null,
SSLConnectionSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
httpclient = HttpClients.custom().setSSLSocketFactory(sslsf).build();
// 创建http请求(get方式)
HttpGet httpget = new HttpGet("https://localhost:8443/myDemo/Ajax/serivceJ.action");
System.out.println("executing request" + httpget.getRequestLine());
CloseableHttpResponse response = httpclient.execute(httpget);
try {
HttpEntity entity = response.getEntity();
System.out.println("----------------------------------------");
System.out.println(response.getStatusLine());
if (entity != null) {
System.out.println("Response content length: " + entity.getContentLength());
System.out.println(EntityUtils.toString(entity));
EntityUtils.consume(entity);
}
} finally {
response.close();
}
} catch (ParseException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (KeyManagementException e) {
e.printStackTrace();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (KeyStoreException e) {
e.printStackTrace();
} finally {
if (httpclient != null) {
try {
httpclient.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} 关于RequestConfig的配置:
源自:
http://segmentfault.com/a/1190000000587944
http://blog.csdn.net/walkerjong/article/details/51710945
public void requestConfig(){
// 新建一个RequestConfig：
RequestConfig defaultRequestConfig = RequestConfig.custom()
//一、连接目标服务器超时时间：ConnectionTimeout-->指的是连接一个url的连接等待时间
.setConnectTimeout(5000)
//二、读取目标服务器数据超时时间：SocketTimeout-->指的是连接上一个url，获取response的返回等待时间
.setSocketTimeout(5000)
//三、从连接池获取连接的超时时间:ConnectionRequestTimeout
.setConnectionRequestTimeout(5000)
.build();
// 这个超时可以设置为客户端级别,作为所有请求的默认值：
CloseableHttpClient httpclient = HttpClients.custom()
.setDefaultRequestConfig(defaultRequestConfig)
.build();
// httpclient.execute(httppost);的时候可以让httppost直接享受到httpclient中的默认配置.
// Request不会继承客户端级别的请求配置，所以在自定义Request的时候，需要将客户端的默认配置拷贝过去：
HttpGet httpget = new HttpGet("http://www.apache.org/");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig)
.setProxy(new HttpHost("myotherproxy", 8080))
.build();
httpget.setConfig(requestConfig);
// httpget可以单独地使用新copy的requestConfig请求配置,不会对别的request请求产生影响
} httpGet或httpPost 的abort()和releaseConnection()差异
//httpPost.abort();//中断请求,接下来可以开始另一段请求,所以个人理应,用这个应该可以在session中虚拟登录
//httpPost.releaseConnection();//释放请求.如果释放了相当于要清空session 可知模拟登录可以如下: 源自 http://bbs.csdn.net/topics/390195343\
package com.bms.core;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import com.bms.util.CommonUtil;
public class Test2 {
/**
* @param args
* @throws IOException
* @throws ClientProtocolException
*/
public static void main(String[] args) throws ClientProtocolException, IOException {
DefaultHttpClient httpclient = new DefaultHttpClient();
HttpGet httpGet = new HttpGet("http://www.baidu.com");
String body = "";
HttpResponse response;
HttpEntity entity;
response = httpclient.execute(httpGet);
entity = response.getEntity();
body = EntityUtils.toString(entity);//这个就是页面源码了
httpGet.abort();//中断请求,接下来可以开始另一段请求
System.out.println(body);
//httpGet.releaseConnection();//释放请求.如果释放了相当于要清空session
//以下是post方法
HttpPost httpPost = new HttpPost("http://www.baidu.com");//一定要改成可以提交的地址,这里用百度代替
List <NameValuePair> nvps = new ArrayList <NameValuePair>();
nvps.add(new BasicNameValuePair("name", "1"));//名值对
nvps.add(new BasicNameValuePair("account", "xxxx"));
httpPost.setEntity(new UrlEncodedFormEntity(nvps, Consts.UTF_8));
response = httpclient.execute(httpPost);
entity = response.getEntity();
body = EntityUtils.toString(entity);
System.out.println("Login form get: " + response.getStatusLine());//这个可以打印状态
httpPost.abort();
System.out.println(body);
httpPost.releaseConnection();
}
} 源自 http://blog.csdn.net/wangpeng047/article/details/19624529#reply
其它相关资料: 非CloseableHttpClient HTTPClient模块的HttpGet和HttpPost
我项目中用到的HttpClientUtil (2016/12/17)
package com.isoftstone.pcis.isc.util;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpRequest;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;
import com.isoftstone.pcis.isc.util.ProperUtil;
public class HttpClientUtil {
private static CloseableHttpClient httpclient = null;
static final int maxTotal=Integer.valueOf(ProperUtil.get("maxTotal")).intValue();//总最大连接数
static final int defaultMaxPerRoute=Integer.valueOf(ProperUtil.get("corePoolSize")).intValue();//每条线路最大连接数 = 本系统核心线程数 , 这样永远不会超过最大连接
public static CloseableHttpClient getHttpClient() {
if (null == httpclient) {
synchronized (HttpClientUtil.class) {
if (null == httpclient) {
httpclient = getNewHttpClient();
}
}
}
return httpclient;
}
private static CloseableHttpClient getNewHttpClient() {
// 设置连接池
ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
// 配置最大连接数
cm.setMaxTotal(maxTotal);
// 配置每条线路的最大连接数
cm.setDefaultMaxPerRoute(defaultMaxPerRoute);
// 请求重试处理
HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {
@Override
public boolean retryRequest(IOException exception,
int executionCount, HttpContext context) {
if (executionCount >= 2) {// 如果已经重试了2次，就放弃
return false;
}
if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接，那么就重试
return true;
}
if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
return false;
}
if (exception instanceof InterruptedIOException) {// 超时
return false;
}
if (exception instanceof UnknownHostException) {// 目标服务器不可达
return false;
}
if (exception instanceof ConnectTimeoutException) {// 连接被拒绝
return false;
}
if (exception instanceof SSLException) {// SSL握手异常
return false;
}
HttpClientContext clientContext = HttpClientContext.adapt(context);
HttpRequest request = clientContext.getRequest();
if (!(request instanceof HttpEntityEnclosingRequest)) {
return true;
}
return false;
}
};
CloseableHttpClient newHttpclient=null;
newHttpclient = HttpClients.custom()
.setConnectionManager(cm)
// .setDefaultRequestConfig(requestConfig)
.setRetryHandler(httpRequestRetryHandler)
.build();
return newHttpclient;
}
} 我自己整理的HttpClientTool
package com.isoftstone.core.util;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.protocol.HttpContext;
/**
* org.apache.http.impl.client.CloseableHttpClient链接池生成工具
* @reference http://www.cnblogs.com/whatlonelytear/articles/4835538.html
* @author King
* @date 20170601
*/
public class HttpClientTool {
// org.apache.http.impl.client.CloseableHttpClient
private static CloseableHttpClient httpclient = null;
// 这里就直接默认固定了,因为以下三个参数在新建的method中仍然可以重新配置并被覆盖.
static final int connectionRequestTimeout = 5000;// ms毫秒,从池中获取链接超时时间
static final int connectTimeout = 5000;// ms毫秒,建立链接超时时间
static final int socketTimeout = 30000;// ms毫秒,读取超时时间
// 总配置,主要涉及是以下两个参数,如果要作调整没有用到properties会比较后麻烦,但鉴于一经粘贴,随处可用的特点,就不再做依赖性配置化处理了.
// 而且这个参数同一家公司基本不会变动.
static final int maxTotal = 500;// 最大总并发,很重要的参数
static final int maxPerRoute = 100;// 每路并发,很重要的参数
// 正常情况这里应该配成MAP或LIST
// 细化配置参数,用来对每路参数做精细化处理,可以管控各ip的流量,比如默认配置请求baidu:80端口最大100个并发链接,
static final String detailHostName = "http://www.baidu.com";// 每个细化配置之ip(不重要,在特殊场景很有用)
static final int detailPort = 80;// 每个细化配置之port(不重要,在特殊场景很有用)
static final int detailMaxPerRoute = 100;// 每个细化配置之最大并发数(不重要,在特殊场景很有用)
public static CloseableHttpClient getHttpClient() {
if (null == httpclient) {
synchronized (HttpClientTool.class) {
if (null == httpclient) {
httpclient = init();
}
}
}
return httpclient;
}
/**
* 链接池初始化 这里最重要的一点理解就是. 让CloseableHttpClient 一直活在池的世界里, 但是HttpPost却一直用完就消掉.
* 这样可以让链接一直保持着.
*
* @return
*/
private static CloseableHttpClient init() {
CloseableHttpClient newHttpclient = null;
// 设置连接池
ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
Registry<ConnectionSocketFactory> registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", plainsf).register("https", sslsf).build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(registry);
// 将最大连接数增加
cm.setMaxTotal(maxTotal);
// 将每个路由基础的连接增加
cm.setDefaultMaxPerRoute(maxPerRoute);
// 细化配置开始,其实这里用Map或List的for循环来配置每个链接,在特殊场景很有用.
// 将每个路由基础的连接做特殊化配置,一般用不着
HttpHost httpHost = new HttpHost(detailHostName, detailPort);
// 将目标主机的最大连接数增加
cm.setMaxPerRoute(new HttpRoute(httpHost), detailMaxPerRoute);
// cm.setMaxPerRoute(new HttpRoute(httpHost2),
// detailMaxPerRoute2);//可以有细化配置2
// cm.setMaxPerRoute(new HttpRoute(httpHost3),
// detailMaxPerRoute3);//可以有细化配置3
// 细化配置结束
// 请求重试处理
HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {
@Override
public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
if (executionCount >= 2) {// 如果已经重试了2次，就放弃
return false;
}
if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接，那么就重试
return true;
}
if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
return false;
}
if (exception instanceof InterruptedIOException) {// 超时
return false;
}
if (exception instanceof UnknownHostException) {// 目标服务器不可达
return false;
}
if (exception instanceof ConnectTimeoutException) {// 连接被拒绝
return false;
}
if (exception instanceof SSLException) {// SSL握手异常
return false;
}
HttpClientContext clientContext = HttpClientContext.adapt(context);
HttpRequest request = clientContext.getRequest();
// 如果请求是幂等的，就再次尝试
if (!(request instanceof HttpEntityEnclosingRequest)) {
return true;
}
return false;
}
};
// 配置请求的超时设置
RequestConfig requestConfig = RequestConfig.custom().setConnectionRequestTimeout(connectionRequestTimeout).setConnectTimeout(connectTimeout).setSocketTimeout(socketTimeout).build();
newHttpclient = HttpClients.custom().setConnectionManager(cm).setDefaultRequestConfig(requestConfig).setRetryHandler(httpRequestRetryHandler).build();
return newHttpclient;
}
} package com.alqsoft.utils;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.cookie.Cookie;
import org.apache.http.cookie.CookieOrigin;
import org.apache.http.cookie.CookieSpec;
import org.apache.http.cookie.CookieSpecProvider;
import org.apache.http.cookie.MalformedCookieException;
import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.cookie.BestMatchSpecFactory;
import org.apache.http.impl.cookie.BrowserCompatSpec;
import org.apache.http.impl.cookie.BrowserCompatSpecFactory;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HttpContext;
import org.apache.http.util.EntityUtils;
public class HttpClientObject {
private static Log logger = LogFactory.getLog(HttpClientObject.class);
private CloseableHttpClient httpClient = null;
private HttpResponse response;
private HttpPost httpPost = null;
private HttpGet httpGet = null;
private String paramKey = "";
private String paramValue = "";
private String responseString;
public void setParamKey(String paramKey) {
this.paramKey = paramKey;
}
public void setParamValue(String paramValue) {
this.paramValue = paramValue;
}
public String getResponseString() {
return responseString;
}
public HttpClientObject() {
this.getHttpClient();
}
private List<NameValuePair> getRequestBody() {
NameValuePair pair1 = new BasicNameValuePair(paramKey, paramValue);
List<NameValuePair> pairList = new ArrayList<NameValuePair>();
pairList.add(pair1);
return pairList;
}
public void submit() {
try {
if (httpPost != null) {
response = httpClient.execute(httpPost);
httpPost = null;
}
if (httpGet != null) {
response = httpClient.execute(httpGet);
httpGet = null;
}
this.response();
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
private void response() {
String result = "";
BufferedReader in = null;
try {
HttpEntity httpEntity = response.getEntity();
responseString = EntityUtils.toString(httpEntity);
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (in != null) {
in.close();
}
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
public void setPost(String httpUrl) {
try {
HttpEntity requestHttpEntity = new UrlEncodedFormEntity(this.getRequestBody());
httpPost = new HttpPost(httpUrl);
httpPost.addHeader("Content-Type", "”application/json;charset=UTF-8");
httpPost.setEntity(requestHttpEntity);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (ParseException e) {
e.printStackTrace();
}
}
public void setGet(String httpUrl) {
httpGet = new HttpGet(httpUrl);
httpGet.addHeader("Content-Type", "text/html;charset=UTF-8");
}
private void getHttpClient() {
BasicCookieStore cookieStore = new BasicCookieStore();
CookieSpecProvider easySpecProvider = new CookieSpecProvider() {
public CookieSpec create(HttpContext context) {
return new BrowserCompatSpec() {
@Override
public void validate(Cookie cookie, CookieOrigin origin)
throws MalformedCookieException {
// Oh, I am easy
}
};
}
};
Registry<CookieSpecProvider> r = RegistryBuilder.<CookieSpecProvider>create()
.register(CookieSpecs.BEST_MATCH, new BestMatchSpecFactory())
.register(CookieSpecs.BROWSER_COMPATIBILITY, new BrowserCompatSpecFactory())
.register("easy", easySpecProvider).build();
RequestConfig requestConfig = RequestConfig.custom().setCookieSpec("easy")
.setSocketTimeout(20000).setConnectTimeout(20000).build();
httpClient = HttpClients.custom().setDefaultCookieSpecRegistry(r)
.setDefaultRequestConfig(requestConfig).setDefaultCookieStore(cookieStore).build();
}
/**
* httpclient发送http get请求；
*
* @return
* @throws URISyntaxException
* @throws IOException
* @throws ClientProtocolException
*/
public static String sendGet(String uriPath, List<NameValuePair> ns)
throws URISyntaxException, ClientProtocolException, IOException {
CloseableHttpClient httpclient = HttpClients.createDefault();
URIBuilder uri = new URIBuilder();
uri.setPath(uriPath);
uri.addParameters(ns);
URI u = uri.build();
HttpGet httpget = new HttpGet(u);
CloseableHttpResponse response = httpclient.execute(httpget);
return EntityUtils.toString(response.getEntity());
}
/**
* httpclient发送http post请求；
*
* @return
* @throws URISyntaxException
* @throws IOException
* @throws ClientProtocolException
*/
public static String sendPost(String uriPath, List<NameValuePair> ns)
throws URISyntaxException, ClientProtocolException, IOException {
CloseableHttpClient httpclient = HttpClients.createDefault();
URIBuilder uri = new URIBuilder();
uri.setPath(uriPath);
uri.addParameters(ns);
URI u = uri.build();
HttpPost httpPost = new HttpPost(u);
CloseableHttpResponse response = httpclient.execute(httpPost);
return EntityUtils.toString(response.getEntity());
}
}
使用方法如下：
String signUrl= ”路径“；
try{
List<NameValuePair> nameValuePairs=new ArrayList<NameValuePair>();
nameValuePairs.add(new BasicNameValuePair("phone",phone));
nameValuePairs.add(new BasicNameValuePair("xytId",String.valueOf(xytId)));
nameValuePairs.add(new BasicNameValuePair("balance",balance));
String result=HttpClientObject.sendPost(signUrl,nameValuePairs);
logger.info("result: = "+result);
JSONObject jsonObject=JSON.parseObject(result);
Integer code=Integer.valueOf(jsonObject.getString("code"));
if(code.equals(0)){
code1=0L;
}else if(code.equals(1)){
code1=1L;
}else if(code.equals(3)){
code1=3L;
}
}catch(Exception e){
e.printStackTrace();
}HttpClientUtil gitHub地址
基本封装HttpClient工具类
github地址 https://github.com/Arronlong/httpclientutil csdn 地址
轻松把玩HttpClient之封装HttpClient工具类
(一)（现有网上分享中的最强大的工具类）
搜了一下网络上别人封装的HttpClient，大部分特别简单，有一些看起来比较高级，但是用起来都不怎么好用。
调用关系不清楚，结构有点混乱。所以也就萌生了自己封装HttpClient工具类的想法。
要做就做最好的，本工具类支持插件式配置Header、插件式配置httpclient对象，
这样就可以方便地自定义header信息、配置ssl、配置proxy等。是不是觉得说的有点悬乎了，那就先看看调用吧：...(二)，插件式配置HttpClient对象
上一篇文章中，简单分享一下封装HttpClient工具类的思路及部分代码，本文将分享如何实现插件式配置HttpClient对象。
如果你看过我前面的几篇关于HttpClient的文章或者官网示例，应该都知道HttpClient对象在创建时，都可以设置各种参数，
但是却没有简单的进行封装，比如对我来说比较重要的3个：
代理、ssl（包含绕过证书验证和自定义证书验证）、超时。还需要自己写。
所以这里我就简单封...(三)，插件式配置Header
上篇文章介绍了插件式配置HttpClient，本文将介绍插件式配置Header。为什么要配置header在前面已经提到了，还里再简单说一下，
要使用HttpClient模拟请求，去访问各种接口或者网站资源，都有可能有各种限制，
比如说java客户端模拟访问csdn博客，就必须设置User-Agent，否则就报错了。
还有各种其他情况，必须的设置一些特定的Header，才能请求成功，或者才能不出问题。好了...(四)，单线程调用及多线程批量调用测试
本文主要来分享一下该工具类的测试结果。工具类的整体源码不再单独分享，源码基本上都已经在文章中了。
开始我们的测试。单线程调用测试：
public static void testOne() throws HttpProcessException{
System.out.println("--------简单方式调用（默认post）--------");
String url = "http://...(五)，携带Cookie的请求maven坐标
如果看到过我前些天写过的《轻松把玩HttpClient之模拟post请求示例》这篇文章，你再看本文就是小菜一碟了，如果你顺便懂一些NIO，基本上是毫无压力了。
因为HttpAsyncClient相对于HttpClient，就多了一个NIO，这也是为什么支持异步的原因。
不过我有一个疑问，虽说NIO是同步非阻塞IO，但是HttpAsyncClient提供了回调的机制，
这点儿跟netty很像，所以可以模拟...(六)，封装输入参数，简化工具类
最近更新了一下HttpClientUtil工具类代码，主要是添加了一个参数HttpContext，这个是用来干嘛的呢？
其实是用来保存和传递Cookie所需要的。因为我们有很多时候都需要登录，然后才能请求一些想要的数据。
而在这以前使用HttpClientUtil工具类，还不能办到。现在更新了以后，终于可以了。
先说一下思路：本次的demo，就是获取csdn中的c币，要想获取c币，必须先登...(七)，新增验证码识别功能
这个HttpClientUtil工具类分享在GitHub上已经半年多的时间了，并且得到了不小的关注，有25颗star，被fork了38次。
有了大家的鼓励，工具类一直也在完善中。最近比较忙，两个多月前的修改在今天刚修改测试完成，今天再次分享给大家。
验证码识别这项技术并不是本工具类的功能，而是通过一个开源的api来识别验证码的。
这里做了一个简单的封装，主要是用来解决登陆时的验证码的问题。...(八)，优化启用Http连接池策略
写了HttpClient工具类后，有人一直在问我怎么启用http连接池，其实我没考虑过这个问题难过。
不过闲暇的时候，突然间想起了这个问题，就想把这个问题搞一搞。
(九)，添加多文件上传功能
在Git上有人给我提Issue，说怎么上传文件，其实我一开始就想上这个功能，不过这半年比较忙，所以一直耽搁了。
这次正好没什么任务了，赶紧完成这个功能。毕竟作为一款工具类，有基本的请求和下载功能，就差上...
之设置代理，可以访问FaceBook
前面的文章介绍了一些HttpClient的简单示例，本文继续采用示例的方式来演示HttpClient的功能。
在项目中我们可能会遇到这样的情况：为了保证系统的安全性，只允许使用特定的代理才可以访问，
而与这些系统使用HttpClient进行交互时，只能为其配置代理。
这里我们使用gogent代理访问脸书来模拟这种情况。现在在浏览器上访问是可以访问的：...
之配置ssl，采用设置信任自签名证书实现https
在上篇文章《HttpClient配置ssl实现https简单示例——绕过证书验证》中简单分享了一下如何绕过证书验证。
如果你想用httpclient访问一个网站，但是对方的证书没有通过ca认证或者其他问题导致证书不被信任，
比如12306的证书就是这样的。所以对于这样的情况，你只能是选择绕过证书验证的方案了。
但是，如果是自己用jdk或者其他工具生成的证书，还是希望用其他方式认证自签名的证书，这篇文...
之配置ssl，采用绕过证书验证实现https
上篇文章说道httpclient不能直接访问https的资源，这次就来模拟一下环境，然后配置https测试一下。
在前面的文章中，分享了一篇自己生成并在tomcat中配置ssl的文章《Tomcat配置SSL》，大家可以据此来在本地配置https。
我已经配置好了，效果是这样滴：
可以看到已经信任该证书（显示浅绿色小锁），浏览器可以正常访问。现在我们用代码测试一下：
之模拟post请求示例
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。
许多需要后台模拟请求的系统或者框架都用的是httpclient。所以作为一个java开发人员，有必要学一学。
本文提供了一个简单的demo，供初学者参考。
简单的利用UrlConnection，后台模拟http请求
这两天在整理看httpclient，然后想自己用UrlConnection后台模拟实现Http请求，于是一个简单的小例子就新鲜出炉了（支持代理哦）：
public class SimpleHttpTest {
public static String send(String urlStr, Map map,String encoding){
String body="";
Strin...
Maven坐标：
<!-- https://mvnrepository.com/artifact/com.arronlong/httpclientutil -->
<dependency>
<groupId>com.arronlong</groupId>
<artifactId>httpclientutil</artifactId>
<version>1.0.4</version>
</dependency>简单Demo
在test包里还有各种测试demo，各测试类的源码在src/test/java/com/httpclient/test包路径下。
public static void main(String[] args) throws HttpProcessException, FileNotFoundException {
String url = "https://github.com/Arronlong/httpclientutil";
//最简单的使用：
String html = HttpClientUtil.get(HttpConfig.custom().url(url));
System.out.println(html);
//---------------------------------
// 【详细说明】
//--------------------------------
//插件式配置Header（各种header信息、自定义header）
Header[] headers = HttpHeader.custom()
.userAgent("javacl")
.other("customer", "自定义")
.build();
//插件式配置生成HttpClient时所需参数（超时、连接池、ssl、重试）
HCB hcb = HCB.custom()
.timeout(1000) //超时
.pool(100, 10) //启用连接池，每个路由最大创建10个链接，总连接数限制为100个
.sslpv(SSLProtocolVersion.TLSv1_2) //设置ssl版本号，默认SSLv3，也可以调用sslpv("TLSv1.2")
.ssl() //https，支持自定义ssl证书路径和密码，ssl(String keyStorePath, String keyStorepass)
.retry(5) //重试5次
;
HttpClient client = hcb.build();
Map<String, Object> map = new HashMap<String, Object>();
map.put("key1", "value1");
map.put("key2", "value2");
//插件式配置请求参数（网址、请求参数、编码、client）
HttpConfig config = HttpConfig.custom()
.headers(headers) //设置headers，不需要时则无需设置
.url(url) //设置请求的url
.map(map) //设置请求参数，没有则无需设置
.encoding("utf-8") //设置请求和返回编码，默认就是Charset.defaultCharset()
.client(client) //如果只是简单使用，无需设置，会自动获取默认的一个client对象
//.inenc("utf-8") //设置请求编码，如果请求返回一直，不需要再单独设置
//.inenc("utf-8") //设置返回编码，如果请求返回一直，不需要再单独设置
//.json("json字符串") //json方式请求的话，就不用设置map方法，当然二者可以共用。
//.context(HttpCookies.custom().getContext()) //设置cookie，用于完成携带cookie的操作
//.out(new FileOutputStream("保存地址")) //下载的话，设置这个方法,否则不要设置
//.files(new String[]{"d:/1.txt","d:/2.txt"}) //上传的话，传递文件路径，一般还需map配置，设置服务器保存路径
;
//使用方式：
String result1 = HttpClientUtil.get(config); //get请求
String result2 = HttpClientUtil.post(config); //post请求
System.out.println(result1);
System.out.println(result2);
//HttpClientUtil.down(config); //下载，需要调用config.out(fileOutputStream对象)
//HttpClientUtil.upload(config); //上传，需要调用config.files(文件路径数组)
//如果指向看是否访问正常
//String result3 = HttpClientUtil.head(config); // 返回Http协议号+状态码
//int statusCode = HttpClientUtil.status(config);//返回状态码
//[新增方法]sendAndGetResp，可以返回原生的HttpResponse对象，
//同时返回常用的几类对象：result、header、StatusLine、StatusCode
HttpResult respResult = HttpClientUtil.sendAndGetResp(config);
System.out.println("返回结果：\n"+respResult.getResult());
System.out.println("返回resp-header："+respResult.getRespHeaders());//可以遍历
System.out.println("返回具体resp-header："+respResult.getHeaders("Date"));
System.out.println("返回StatusLine对象："+respResult.getStatusLine());
System.out.println("返回StatusCode："+respResult.getStatusCode());
System.out.println("返回HttpResponse对象）（可自行处理）："+respResult.getResp());
}
HttpMime实现http请求—post以及get请求、文件下载等
摘要
非web项目实现文件下载，使用apache的httpmime工具进行相关的http请求操作。
正题
需求：实现非web项目进行文件下载或者http请求。
1、添加相关pom依赖
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpmime</artifactId>
<version>4.5.5</version>
</dependency>2、请求相关工具代码
说明：
1、本代码中采用的是日志是logback，json相关解析等采用的是fastjson，直接拷贝代码会有错误，所以需要引入相关依赖，由于和本文章内容关系不大，所以前排依赖中没有给出，本文最后会给出，或者不采用日志以及采用别的也行
2、有些请求函数中包含token，这是因为笔者的需求需要token认证，所以去掉或者保留看读者需要
3、url为完整的接口访问路径，例：http://localhost:8080/index
4、请求中的参数采用map传入，即 参数名-参数值 键值对
5、最后一个函数downFileByGet为文件下载函数
package com.lanxuewei.utils.file.deepwise;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.CharsetUtils;
import org.apache.http.util.EntityUtils;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSON;
import com.lanxuewei.utils.io.IOUtils;
/**
* @author lanxuewei Create in 2018/9/19 16:54
* Description: 本地http请求帮助类
*/
public class HttpClientHelper {
private static final Logger logger = LoggerFactory.getLogger(HttpClientHelper.class);
/**
* http post请求，json格式传输参数
*
* @param map 参数对
* @param url url地址
* @return
* @throws IOException
*/
public String postWithHttp(Map<String, Object> map, String url) {
CloseableHttpClient client = HttpClients.createDefault();
HttpPost httpPost = new HttpPost(url);
// 设置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
.setConnectionRequestTimeout(5000)
.setSocketTimeout(5000).build();
httpPost.setConfig(requestConfig);
StringEntity stringEntity = new StringEntity(JSON.toJSONString(map), "UTF-8");
stringEntity.setContentEncoding("UTF-8");
stringEntity.setContentType("application/json");
httpPost.setEntity(stringEntity);
CloseableHttpResponse response = null;
try {
response = client.execute(httpPost);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HttpEntity resEntity = response.getEntity();
return EntityUtils.toString(resEntity);
}
} catch (IOException e) {
logger.error("", e);
}
return "";
}
/**
* 表单提交 post请求
*
* @param map 参数对
* @param url url
* @param token token
* @return 响应流
* @throws IOException
*/
public String postFormWithHttp(Map<String, Object> map, String url, String token) {
CloseableHttpClient client = HttpClients.createDefault();
HttpPost httpPost = new HttpPost(url);
// 设置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
.setConnectionRequestTimeout(5000)
.setSocketTimeout(5000).build();
httpPost.setConfig(requestConfig);
httpPost.setHeader("token", token);
ContentType contentType = ContentType.create("text/plain", Consts.UTF_8);
MultipartEntityBuilder builder = MultipartEntityBuilder.create().setMode(HttpMultipartMode.BROWSER_COMPATIBLE);
for (Map.Entry<String, Object> entry : map.entrySet()) {
builder.addPart(entry.getKey(), new StringBody(entry.getValue().toString(), contentType));
}
HttpEntity httpEntity = null;
try {
httpEntity = builder.setCharset(CharsetUtils.get("UTF-8")).build();
} catch (UnsupportedEncodingException e) {
logger.error("", e);
}
httpPost.setEntity(httpEntity);
return execute(client, httpPost);
}
/**
* get请求
*
* @param map 参数对
* @param url url
* @param token token
* @return 响应流
* @throws IOException
*/
public String getWithHttp(Map<String, Object> map, String url, String token) {
CloseableHttpClient client = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(url);
// 设置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
.setConnectionRequestTimeout(5000)
.setSocketTimeout(5000).build();
httpGet.setConfig(requestConfig);
httpGet.setHeader("token", token);
return execute(client, httpGet);
}
/**
* 执行请求并响应
*
* @param client client
* @param httpPost httpPost
* @return 结果流字符串
*/
private String execute(CloseableHttpClient client, HttpRequestBase httpPost) {
if (client == null || httpPost == null) {
return "";
}
CloseableHttpResponse response = null;
try {
response = client.execute(httpPost);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HttpEntity resEntity = response.getEntity();
return EntityUtils.toString(resEntity);
}
} catch (Exception e) {
logger.error("", e);
} finally {
IOUtils.safeClose(response);
}
return "";
}
/**
* 文件下载
*
* @param url url
* @param token token
* @return 响应流
* @throws IOException
*/
public boolean downFileByGet(String url, String token, File targetFile) {
CloseableHttpClient client = HttpClients.createDefault();
HttpGet httpGet = new HttpGet(url);
// 设置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
.setConnectionRequestTimeout(5000)
.setSocketTimeout(5000).build();
httpGet.setConfig(requestConfig);
httpGet.setHeader("token", token);
CloseableHttpResponse response = null;
try {
response = client.execute(httpGet);
} catch (IOException e) {
logger.error("", e);
}
assert response != null;
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
try {
// org.apache.commons.io.IOUtils.copy(response.getEntity().getContent(), new FileOutputStream(targetFile));
response.getEntity().writeTo(new FileOutputStream(targetFile)); // 写入文件
} catch (IOException e) {
logger.error("", e);
}
}
return true;
}
}3、 logback相关依赖
补充：之前由于没有手动设置超时时间，所以如果请求长时间无响应的话会导致一直等待阻塞问题出现，所以补充超时设置代码，以上代码已补充，下面也贴出手动设置超时代码块，代码如下：
// 设置超时时间
RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000)
.setConnectionRequestTimeout(5000)
.setSocketTimeout(5000).build();
httpPost.setConfig(requestConfig);
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
