HttpClient服务端的请求

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpVersion;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
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.client.params.HttpClientParams;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.params.ConnManagerParams;
import org.apache.http.conn.params.ConnPerRouteBean;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;

/**
* 优化httpclient，解决线程安全，重复连接池等性能问题。
*
* */
public class HttpUtils {
private final static boolean DEBUG = false;

public final static String CHARSET = "UTF-8";

/**
* 这定义了通过网络与服务器建立连接的超时时间。 Httpclient包中通过一个异步线程去创建与服务器的socket连接
* ，这就是该socket连接的超时时间(毫秒)
*/
public final static int DEFAULT_SOCKET_TIMEOUT = 2000;
/** 这定义了Socket读数据的超时时间，即从服务器获取响应数据需要等待的时间(毫秒) */
public final static int WAIT_GETDATA_TIME = 4000;
/** 配置每台主机最多连接数 */
public final static int DEFAULT_HOST_CONNECTIONS = 50;
/** 和连接池中的最多连接总数 */
public final static int DEFAULT_MAX_CONNECTIONS = 50;
/** Socket 缓存大小 */
public final static int DEFAULT_SOCKET_BUFFER_SIZE = 8192;

/** 这定义了从ConnectionManager管理的连接池中取出连接的超时时间(毫秒) */
public final static int GET_CONNECT_TIME = 1000;
private static HttpClient httpClient = null;

private static synchronized HttpClient getHttpClient() {
if (httpClient == null) {
final HttpParams httpParams = new BasicHttpParams();

ConnManagerParams.setTimeout(httpParams, GET_CONNECT_TIME);
HttpConnectionParams.setConnectionTimeout(httpParams, DEFAULT_SOCKET_TIMEOUT);
HttpConnectionParams.setSoTimeout(httpParams, WAIT_GETDATA_TIME);
ConnManagerParams.setMaxConnectionsPerRoute(httpParams, new ConnPerRouteBean(DEFAULT_HOST_CONNECTIONS));
ConnManagerParams.setMaxTotalConnections(httpParams, DEFAULT_MAX_CONNECTIONS);

/** 以先发送部分请求（如：只发送请求头）进行试探，如果服务器愿意接收，则继续发送请求体 */
HttpProtocolParams.setUseExpectContinue(httpParams, true);
/**
* 即在有传输数据需求时，会首先检查连接池中是否有可供重用的连接，如果有，则会重用连接。
* 同时，为了确保该“被重用”的连接确实有效，会在重用之前对其进行有效性检查
*/
HttpConnectionParams.setStaleCheckingEnabled(httpParams, false);

HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
HttpProtocolParams.setContentCharset(httpParams, HTTP.UTF_8);

HttpClientParams.setRedirecting(httpParams, false);

// 设置代理
String userAgent = "Mozilla/5.0 (Windows; U; Windows NT 5.1; zh-CN; rv:1.9.2) Gecko/20100115 Firefox/3.6";
HttpProtocolParams.setUserAgent(httpParams, userAgent);

// disable Nagle algorithm
HttpConnectionParams.setTcpNoDelay(httpParams, true);

HttpConnectionParams.setSocketBufferSize(httpParams, DEFAULT_SOCKET_BUFFER_SIZE);

// 配置 http and https
SchemeRegistry schemeRegistry = new SchemeRegistry();
schemeRegistry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
schemeRegistry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));

ClientConnectionManager manager = new ThreadSafeClientConnManager(httpParams, schemeRegistry);
httpClient = new DefaultHttpClient(manager, httpParams);
}

return httpClient;
}

public static InputStream doHttpClientPost(String url, HashMap<String, String> params) {
if (DEBUG) {
System.out.println("doPost url is " + url);
}

HttpClient httpClient = getHttpClient();

HttpPost httpRequest = new HttpPost(url);

List<BasicNameValuePair> httpParams = new ArrayList<BasicNameValuePair>();
Iterator<Entry<String, String>> iter = params.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, String> entry = iter.next();
String key = entry.getKey();
String val = entry.getValue();
httpParams.add(new BasicNameValuePair(key, val));
}

InputStream inputStream = null;
String erroMsg = null;

try {
httpRequest.setEntity(new UrlEncodedFormEntity(httpParams, HTTP.UTF_8));
} catch (UnsupportedEncodingException e) {

}
HttpResponse httpResponse = null;
try {
httpResponse = httpClient.execute(httpRequest);
} catch (ClientProtocolException e) {
erroMsg = e.getMessage().toString();
e.printStackTrace();
} catch (IOException e) {
erroMsg = e.getMessage().toString();
e.printStackTrace();
}

int statusCode = httpResponse.getStatusLine().getStatusCode();
if (statusCode == 200) {
try {
inputStream = httpResponse.getEntity().getContent();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} else {
erroMsg = "Error Response: " + httpResponse.getStatusLine().toString();
}

if (erroMsg != null) {
System.out.println("doPost error, error message is " + erroMsg);
}

return inputStream;
}

public static InputStream doHttpsClientPost(String url, String params) {
if (DEBUG) {
System.out.println("doPost url is " + url);
}

HttpClient httpClient = getHttpClient();

HttpPost httpRequest = new HttpPost(url);

InputStream inputStream = null;
String erroMsg = null;

try {
HttpEntity entity = new StringEntity(params,"utf-8");

httpRequest.setEntity(entity);
} catch (UnsupportedEncodingException e) {

}
HttpResponse httpResponse = null;
try {
httpResponse = httpClient.execute(httpRequest);
} catch (ClientProtocolException e) {
erroMsg = e.getMessage().toString();
e.printStackTrace();
} catch (IOException e) {
erroMsg = e.getMessage().toString();
e.printStackTrace();
}

int statusCode = httpResponse.getStatusLine().getStatusCode();
if (statusCode == 200) {
try {
inputStream = httpResponse.getEntity().getContent();
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} else {
erroMsg = "Error Response: " + httpResponse.getStatusLine().toString();
}

if (erroMsg != null) {
System.out.println("doPost error, error message is " + erroMsg);
}

return inputStream;
}

public static InputStream doHttpClientGet(String url, HashMap<String, String> params) {
HttpClient httpClient = getHttpClient();

if (DEBUG) {
System.out.println("doGet the url before encode is " + url);
}

if (params != null) {
String paramStr = "";
try {
Iterator<Entry<String, String>> iter = params.entrySet().iterator();
while (iter.hasNext()) {
Map.Entry<String, String> entry = iter.next();
String key = entry.getKey();
key = URLEncoder.encode(key, "UTF-8");
String val = entry.getValue();
val = URLEncoder.encode(val, "UTF-8");
paramStr += paramStr = "&" + key + "=" + val;
}
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}

if (!paramStr.equals("")) {
paramStr = paramStr.replaceFirst("&", "?");
url += paramStr;
}
}

if (DEBUG) {
System.out.println("doGet the url after encode is " + url);
}

HttpGet httpRequest = null;
try {
httpRequest = new HttpGet(url);
} catch (IllegalArgumentException e) {
System.out.println("uri argument error");
return null;
}

InputStream inputStream = null;

HttpResponse httpResponse = null;
try {
httpResponse = httpClient.execute(httpRequest);

} catch (IllegalStateException e) {
e.printStackTrace();
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (SocketTimeoutException e) {
e.printStackTrace();
} catch (ConnectTimeoutException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}

if (httpResponse == null) {
System.out.println("no response from server");
return null;
}

if (httpResponse.getStatusLine().getStatusCode() == 200) {
HttpEntity httpEntity = httpResponse.getEntity();
try {
inputStream = httpEntity.getContent();
} catch (IllegalStateException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
System.out.println("Error Response: " + httpResponse.getStatusLine().toString());
}
return inputStream;
}

// 未经优化的原声方法
public static String doHttpURLConnection(String myurl) throws IOException {
InputStream is = null;
// Only display the first 1000 characters of the retrieved
// web page content.
int len = 1000;

try {
URL url = new URL(myurl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setReadTimeout(10000 /* milliseconds */);
conn.setConnectTimeout(15000 /* milliseconds */);
conn.setRequestMethod("GET");
conn.setDoInput(true);
// Starts the query
conn.connect();
int response = conn.getResponseCode();
if (DEBUG) {
System.out.println("The response is: " + response);
}
is = conn.getInputStream();

// Convert the InputStream into a string
String contentAsString = readIt(is, len);
return contentAsString;

// Makes sure that the InputStream is closed after the app is
// finished using it.
} finally {
if (is != null) {
is.close();
}
}
}

// Reads an InputStream and converts it to a String.
public static String readIt(InputStream stream, int len) throws IOException, UnsupportedEncodingException {
if (stream == null)
return null;
Reader reader = null;
reader = new InputStreamReader(stream, "UTF-8");
char[] buffer = new char[len];
reader.read(buffer);
return new String(buffer);
}

}