java 利用httpclient 3.1 和 httpclient4.1.2发送post请求

httpclient3和httpclient4都有连接池的概念，但两个版本的接口相差较大。

使用HttpClient发送请求、接收响应很简单，一般需要如下几步即可。

1. 创建HttpClient对象。
2. 创建请求方法的实例，并指定请求URL。如果需要发送GET请求，创建HttpGet对象；如果需要发送POST请求，创建HttpPost对象。
3. 如果需要发送请求参数，可调用HttpGet、HttpPost共同的setParams(HetpParams params)方法来添加请求参数；对于HttpPost对象而言，也可调用setEntity(HttpEntity entity)方法来设置请求参数。
4. 调用HttpClient对象的execute(HttpUriRequest request)发送请求，该方法返回一个HttpResponse。
5. 调用HttpResponse的getAllHeaders()、getHeaders(String name)等方法可获取服务器的响应头；调用HttpResponse的getEntity()方法可获取HttpEntity对象，该对象包装了服务器的响应内容。程序可通过该对象获取服务器的响应内容。
6. 释放连接。无论执行方法是否成功，都必须释放连接

httpclient3

MultiThreadedHttpConnectionManager 是HTTP
Client中用来复用连接的连接管理类,可以通过以下方法创建一个client实例

MultiThreadedHttpConnectionManager n =  new MultiThreadedHttpConnectionManager();
HttpClient client = new HttpClient(n);

以下是httpclient整体类

public class HttpClientUtils {
/**
* 日志处理类
*/
private static final Log logger = LogFactory.getLog(HttpClientUtils.class);

// 读取超时
private final static int SOCKET_TIMEOUT = 30000;
// 连接超时
private final static int CONNECTION_TIMEOUT = 30000;
// 每个HOST的最大连接数量(连接至目的主机的线程数)
private final static int MAX_CONN_PRE_HOST = 2;
// 连接池的最大连接数(相当于线程数)
private final static int MAX_CONN = 2;
// 连接池
private final static HttpConnectionManager httpConnectionManager;

HttpClient httpClient;

static {
httpConnectionManager = new MultiThreadedHttpConnectionManager();
HttpConnectionManagerParams params = httpConnectionManager.getParams();
params.setConnectionTimeout(CONNECTION_TIMEOUT);
params.setSoTimeout(SOCKET_TIMEOUT);
params.setDefaultMaxConnectionsPerHost(MAX_CONN_PRE_HOST);
params.setMaxTotalConnections(MAX_CONN);
httpClient = new HttpClient(httpConnectionManager);

 }

/**
* 发送主要方法,异常捕获
*
* @param post
* @param code
* @return
*/
public static String doHttpPostRequest(PostMethod post) {
String resultString = "";
try {
httpClient.executeMethod(post);
if (post.getStatusCode() == HttpStatus.SC_OK) {
resultString = post.getResponseBodyAsString();
}
} catch (HttpException e) {
logger.error("http请求超时", e);
} catch (IOException e) {
logger.error("IO超时", e);
} finally {
post.releaseConnection();
}
return resultString;
}

/**
* 设置一下返回错误的通用提示,可以自定义格式.
*
* @param reason
* @return
*/
public static String returnError(String reason) {
StringBuffer buffer = new StringBuffer();
buffer.append("<?xml version=\"1.0\" encoding=\"GBK\"?>");
buffer.append("<Response>");
buffer.append("<Success>false</Success>");
buffer.append("<reason>");
buffer.append(reason);
buffer.append("</reason>");
buffer.append("</Response>");
return buffer.toString();
}

public final static String REQUEST_HEADER = "x-forwarded-for";

/**
* 将客户IP写入请求头 这个设置可以伪装IP请求,注意使用
*
* @param client
* @param ip
* @return
*/
public static void resetRequestHeader(HttpClient client, String ip) {
List<Header> headers = new ArrayList<Header>();
headers.add(new Header(REQUEST_HEADER, ip));
client.getHostConfiguration().getParams().setParameter("http.default-headers", headers);
}
}

以下是测试程序

public class HttpClientTest {

/**
* 组装参数,这里用Map,一键一值比较通用,可以当做共用方法
* @param params
* @return
*/
private NameValuePair[] buildNameValuePairs(Map<String, String> params) {
Object[] keys = params.keySet().toArray();
NameValuePair[] pairs = new NameValuePair[keys.length];

for (int i = 0; i < keys.length; i++) {
String key = (String) keys[i];
pairs[i] = new NameValuePair(key, params.get(key));
}

return pairs;
}

/**
* 执行一个HTTP POST请求，返回请求响应的HTML
*
* @param url
*            请求的URL地址
* @param params
*            请求的查询参数,可以为null
* @return 返回请求响应的string
*/
public String doPost(String url, Map<String, String> params){
String response = "";
if (null == url || "".equals(url.trim())) {
return HttpClientUtil.returnError("推送地址错误[url=" + url + "]");
}
if (null == code || "".equals(code.trim())) {
return HttpClientUtil.returnError("编码错误[code=" + code + "]");
}

if (null == params || params.size() == 0) {
return HttpClientUtil.returnError("无传递参数[params.size = 0]");
}
PostMethod postMethod = new PostMethod(url);
postMethod.getParams().setParameter(HttpMethodParams.HTTP_CONTENT_CHARSET, "utf-8");
//设置失败重复提交次数
postMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER, new DefaultHttpMethodRetryHandler(5, true));

postMethod.setRequestBody(buildNameValuePairs(params));
response = HttpClientUtils.doHttpPostRequest(postMethod);
return response;
}

public static void main(String[] args) {
String url = "http://localhost/serlvet";
String xml = "xxxxxxxxxxxxxxxxxxxxxxx";
HashMap<String, String> params = new HashMap<String, String>();
params.put("aaaa", xml);
params.put("bbbb", "bbbxxxx");
String r = new HttpClientTest().doPost(url,params);
System.out.println(r);

}

}

httpclient4.1.2

public class HttpClientUtils2 implements Runnable{
private static final Log logger = LogFactory.getLog(HttpClientUtils2.class);
private static ThreadSafeClientConnManager cm = null;
static {
int maxTotal = 20;
int defaultMaxConnection = 50;
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
cm = new ThreadSafeClientConnManager(schemeRegistry);
try {
cm.setMaxTotal(maxTotal);
// 每条通道的并发连接数设置（连接池）
cm.setDefaultMaxPerRoute(defaultMaxConnection);
} catch (NumberFormatException e) {
e.printStackTrace();
}
}

public static HttpClient getHttpClient() {
HttpParams params = new BasicHttpParams();
params.setParameter(CoreProtocolPNames.PROTOCOL_VERSION, HttpVersion.HTTP_1_1);
params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000); // 3000ms
params.setParameter(CoreConnectionPNames.SO_TIMEOUT, 30000); // 3000ms
return new DefaultHttpClient(cm, params);
}

public static void release() {
if (cm != null) {
cm.shutdown();
}
}

public static void doHttpPostRequest(String url) {
InputStream in = null;
HttpResponse response;

HttpClient client = getHttpClient();
try {
response = client.execute(post);
if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
HttpEntity entity = response.getEntity();
long l = entity.getContentLength();
//将返回转换成string（方法1）
in = entity.getContent();
int count = 0;
while (count == 0) {
count = Integer.parseInt(""+entity.getContentLength());//in.available();
}
byte[] bytes = new byte[count];
int readCount = 0; // 已经成功读取的字节的个数
while (readCount <= count) {
if(readCount == count)break;
readCount += in.read(bytes, readCount, count - readCount);
}
//将返回转换成string（方法2）
//System.out.println(EntityUtils.toString(entity));
}
if (in != null) {
//关闭连接，否则连接池消耗完
in.close();
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

测试程序

public class HttpClient2Test {

/**
* 执行一个HTTP POST请求，返回请求响应的HTML
*
* @param url
*            请求的URL地址
* @param params
*            请求的查询参数,可以为null
* @return 返回请求响应的string
*/
public String doPost(String url, Map<String, String> params){
String response = "";
HttpPost post = new HttpPost(url);
// 设置post编码
post.getParams().setParameter("http.protocol.content-charset", HTTP.UTF_8);
post.getParams().setParameter(HTTP.CONTENT_ENCODING, HTTP.UTF_8);
post.getParams().setParameter(HTTP.CHARSET_PARAM, HTTP.UTF_8);
post.getParams().setParameter(HTTP.DEFAULT_PROTOCOL_CHARSET, HTTP.UTF_8);
try {
post.setEntity(new UrlEncodedFormEntity(params, HTTP.UTF_8));
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
response = HttpClientUtils2.doHttpPostRequest(postMethod);
return response;
}

public static void main(String[] args) {
String url = "http://localhost/serlvet";
String xml = "xxxxxxxxxxxxxxxxxxxxxxx";
// 设置参数
List<NameValuePair> params = new ArrayList<NameValuePair>();
params.add(new BasicNameValuePair("abc", "xml"));
String r = new HttpClientTest().doPost(url,params);
System.out.println(r);

}

}