android网络请求工具类

package com.example.util;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URI;
import java.net.URL;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
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 android.content.Context;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.util.Log;

/**
 * 网络连接辅助类
 *项目名称：xxxxxxxx
 * 
 * @author zhangjie
 * 
 */
public class HttpUtil {
	private static final String TAG = "HttpUtil";

	/** 连接超时 */
	private static final int TIME_OUT = 5 * 1000;

	/**
	 * 发送post请求
	 * 
	 * @param strUrl
	 *            网址路径
	 * @param map
	 *            请求的参数
	 * @return 返回请求的结果
	 */
	public static String executePost(String strUrl, Map<String, String> map) {
		String result = null;
		BufferedReader reader = null;
		try {
			HttpClient client = new DefaultHttpClient();
			// HttpPost连接对象
			HttpPost request = new HttpPost();
			request.setURI(new URI(strUrl));

			// 使用NameValuePair来保存要传递的Post参数
			List<NameValuePair> postParameters = new ArrayList<NameValuePair>();
			if (null != map) {
				for (Map.Entry<String, String> entry : map.entrySet()) {
					Log.i(TAG, entry.getKey() + "=>" + entry.getValue());
					postParameters.add(new BasicNameValuePair(entry.getKey(),
							entry.getValue()));
				}
			}
			// 设置字符集
			UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(
					postParameters, "utf-8");
			request.setEntity(formEntity);

			HttpResponse response = client.execute(request);
			// HttpStatus.SC_OK表示连接成功
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				Log.i(TAG, "连接成功，连接状态码为："
						+ response.getStatusLine().getStatusCode());
				reader = new BufferedReader(new InputStreamReader(response
						.getEntity().getContent()));

				StringBuffer strBuffer = new StringBuffer("");
				String line = null;
				while ((line = reader.readLine()) != null) {
					strBuffer.append(line);
				}
				result = strBuffer.toString();
				Log.i(TAG, result);
			} else {
				Log.i(TAG, "连接失败，连接状态码为："
						+ response.getStatusLine().getStatusCode());
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
					reader = null;
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		return result;
	}

	/**
	 * 发送post请求
	 * 
	 * @param urlAddress
	 *            请求的路径
	 * @param map
	 *            请求的参数
	 * @return 返回请求后的结果
	 * @throws AccessUrlException
	 */
	public static String executeHttpPost(Context context, String urlAddress,
			Map<String, String> map) throws AccessUrlException,
			AccessTimeOutException {
		try {
			initSSL();
		} catch (KeyManagementException e1) {
			e1.printStackTrace();
		} catch (NoSuchAlgorithmException e1) {
			e1.printStackTrace();
		}
		SharedPreferences sharedPreferences = context.getSharedPreferences(
				"YinYiTong", Context.MODE_PRIVATE);
		String result = null;
		URL url = null;
		HttpURLConnection connection = null;
		InputStreamReader in = null;

		try {
			url = new URL(urlAddress);

			connection = (HttpURLConnection) url.openConnection();
			connection.setConnectTimeout(TIME_OUT);
			connection.setDoInput(true);// 使用 URL连接进行输入
			connection.setDoOutput(true);// 使用 URL连接进行输出
			connection.setUseCaches(false);// 忽略缓存
			connection.setRequestMethod("POST");
			connection.setRequestProperty("Content-Type",
					"application/x-www-form-urlencoded");
			connection.setRequestProperty("Charset", "utf-8");

			// session id
			String sessionId = sharedPreferences.getString("sessionId", "");
			if (!(sessionId==null)) {
				connection.setRequestProperty("Cookie", sessionId);

			}

			StringBuilder params = new StringBuilder();
			// 设置参数
			if (null != map) {
				for (Map.Entry<String, String> entry : map.entrySet()) {
					Log.i(TAG, entry.getKey() + "=>" + entry.getValue());
					params.append(entry.getKey());
					params.append("=");
					params.append(URLEncoder.encode(entry.getValue(), "utf-8"));
					params.append("&");
				}
			}
			if (params.length() > 0)
				params.deleteCharAt(params.length() - 1);

			OutputStream outputStream = null;
			try {
				outputStream = connection.getOutputStream();
			} catch (Exception e) {
				Log.w(TAG, "访问服务器地址:" + urlAddress + "超时.");
				throw new AccessTimeOutException("访问服务器地址:" + urlAddress
						+ "超时.");
			}

			DataOutputStream dop = new DataOutputStream(outputStream);
			dop.write(params.toString().getBytes());
			dop.flush();
			dop.close();

			if (connection.getResponseCode() == HttpStatus.SC_OK) {
				Log.i(TAG, "connection status is 200");
				// 获取返回结果
				in = new InputStreamReader(connection.getInputStream());
				BufferedReader bufferedReader = new BufferedReader(in);
				StringBuffer strBuffer = new StringBuffer();
				String line = null;
				while ((line = bufferedReader.readLine()) != null) {
					strBuffer.append(line);
				}
				result = strBuffer.toString();
				Log.i(TAG, result);

				// session id不同，重新设置
				String session_value = connection.getHeaderField("Set-Cookie");
				if (!(session_value==null)) {
					String[] sessionIds = session_value.split(";");
					Log.i(TAG, "sessionId=" + sessionIds[0]);
					if (null != sessionIds[0]
							&& !sessionIds[0].equalsIgnoreCase(sessionId)) {
						Editor editor = sharedPreferences.edit();
						editor.putString("sessionId", sessionIds[0]);
						editor.commit();
					}
				}
			} else {
				Log.w(TAG, "访问服务器异常，状态码为:" + connection.getResponseCode());
				throw new AccessUrlException("访问服务器异常，状态码为:"
						+ connection.getResponseCode());
			}
		} catch (MalformedURLException e) {
			Log.e(TAG, "[executeHttpPost]：", e);
		} catch (ProtocolException e) {
			Log.e(TAG, "[executeHttpPost]：", e);
		} catch (UnsupportedEncodingException e) {
			Log.e(TAG, "[executeHttpPost]：", e);
		} catch (IOException e) {
			Log.e(TAG, "[executeHttpPost]：", e);
		} finally {
			if (connection != null) {
				connection.disconnect();
			}
			if (in != null) {
				try {
					in.close();
				} catch (IOException e) {
					Log.e(TAG, "[executeHttpPost]InputStreamReader关闭异常：", e);
				}
			}
		}
		return result;
	}

	/**
	 * 接受任何证书，不考虑证书发行者及所在主机情况
	 * 
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 */
	public static void initSSL() throws NoSuchAlgorithmException,
			KeyManagementException {
		// Create a trust manager that does not validate certificate chains
		TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() {
			public X509Certificate[] getAcceptedIssuers() {
				return null;
			}

			public void checkClientTrusted(X509Certificate[] certs,
					String authType) {
				// Trust always
			}

			public void checkServerTrusted(X509Certificate[] certs,
					String authType) {
				// Trust always
			}
		} };

		// Install the all-trusting trust manager
		SSLContext sc = SSLContext.getInstance("SSL");
		// Create empty HostnameVerifier
		HostnameVerifier hv = new HostnameVerifier() {
			public boolean verify(String arg0, SSLSession arg1) {
				return true;
			}
		};

		sc.init(null, trustAllCerts, new java.security.SecureRandom());
		HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
		HttpsURLConnection.setDefaultHostnameVerifier(hv);
	}

	/**
	 * 检查网络连接
	 * 
	 * @param context
	 * @return 有可用的接连返回true,否则返回false
	 */
	public static boolean hasNetwork(Context context) {
		ConnectivityManager con = (ConnectivityManager) context
				.getSystemService(Context.CONNECTIVITY_SERVICE);
		NetworkInfo workinfo = con.getActiveNetworkInfo();
		if (workinfo == null || !workinfo.isAvailable()) {
			Log.w(TAG, "当前无网络连接......");
			return false;
		}
		return true;
	}

	@SuppressWarnings("serial")
	public static class AccessUrlException extends Exception {
		public AccessUrlException() {
			super();
		}

		public AccessUrlException(String msg) {
			super(msg);
		}

		@Override
		public String toString() {
			return super.toString();
		}
	}

	@SuppressWarnings("serial")
	public static class AccessTimeOutException extends Exception {
		public AccessTimeOutException() {
			super();
		}

		public AccessTimeOutException(String msg) {
			super(msg);
		}

		@Override
		public String toString() {
			return super.toString();
		}
	}
}