（4.1.28.3）第二种方法HttpClient.setCookieStore(mCookieStore)实现的HTTP工具类

项目中客户端与服务器端采用http请求进行交互，在这里我把http请求的工具类贴出来。

该工具类采用的是HttpClients框架，HTTP保存方式有两种选择 ：

1. 一种：整个应用 只创建 一个HttpClient对象，然后保存在整个程序中去。此情况无法创建多线程中应用。
2. 二种：随时创建HttpClient对象。系统自动保存Session就行。此情况可能对系统资源消耗利害，用完之后请随时销毁HttpClient，避免系统中存在很多HttpClient对象。

在这里我采用的是第二种。

包含两个java文件，第一个是主要的请求工具类文件，第二个主要是保存请求的session，下面见代码：

 package com.hlj.padtwo.util.util_public.httputil;



 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.URLEncoder;
 import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import javax.net.ssl.SSLHandshakeException;

 import org.apache.http.Header;
 import org.apache.http.HttpEntityEnclosingRequest;
 import org.apache.http.HttpHost;
 import org.apache.http.HttpRequest;
 import org.apache.http.HttpResponse;
 import org.apache.http.NameValuePair;
 import org.apache.http.NoHttpResponseException;
 import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.CookieStore;
 import org.apache.http.client.HttpRequestRetryHandler;
 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.params.ConnRouteParams;
 import org.apache.http.entity.mime.HttpMultipartMode;
 import org.apache.http.entity.mime.MultipartEntity;
 import org.apache.http.entity.mime.content.ContentBody;
 import org.apache.http.entity.mime.content.FileBody;
 import org.apache.http.entity.mime.content.StringBody;
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.params.BasicHttpParams;
 import org.apache.http.params.HttpConnectionParams;
 import org.apache.http.params.HttpParams;
 import org.apache.http.protocol.ExecutionContext;
 import org.apache.http.protocol.HTTP;
 import org.apache.http.protocol.HttpContext;
 import org.apache.http.util.EntityUtils;

 import android.app.Activity;
 import android.content.Context;
 import android.widget.Toast;

 import com.hlj.padtwo.util.application.MyApplication;


 /***
  * Http通信中的POST和GET请求方式的不同。GET把参数放在URL字符串后面，传递给服务器。
  * 而POST方法的参数是放在Http请求中，主要用于手机对Http访问提供公共的访问类对象。
  * @author hlj
  * @date
  * @versionn 1.0
  **/
 public class HttpClients {
     /** 执行downfile后，得到下载文件的大小 */
     private long contentLength;
     /** 返回连接失败信息 **/
     private String strResult = "服务器无法连接，请检查网络";

     /** http 请求头参数 **/
     private HttpParams httpParams;
     /** httpClient 对象 **/
     private DefaultHttpClient httpClient;


     /** 得到上下文 **/
     private Context context;
     private Activity activity = null;

     public HttpClients(Activity act) {
         this.context = act.getBaseContext();
         this.activity = act;
         getHttpClient();
     }

     /**
      * 提供GET形式的访问网络请求 doGet 参数示例： Map params=new HashMap();
      * params.put("usename","helijun"); params.put("password","123456");
      * httpClient.doGet(url,params)；
      *
      * @param url
      *            请求地址
      * @param params
      *            请求参数
      * @return 返回 String jsonResult;
      *
      * **/
     @SuppressWarnings("unchecked")
     public String doGet(String url, Map params) {
         /** 建立HTTPGet对象 **/
         String paramStr = "";
         if (params == null)
             params = new HashMap();
         /** 迭代请求参数集合 **/
         Iterator iter = params.entrySet().iterator();
         while (iter.hasNext()) {
             Map.Entry entry = (Map.Entry) iter.next();
             Object key = entry.getKey();
             String val = nullToString(entry.getValue());
             paramStr += paramStr = "&" + key + "=" + URLEncoder.encode(val);
         }
         if (!paramStr.equals("")) {
             paramStr = paramStr.replaceFirst("&", "?");
             url += paramStr;
         }
         return doGet(url);
     }

     /**
      * 提供GET形式的访问网络请求 doGet 参数示例： Map params=new HashMap();
      * params.put("usename","gongshuanglin"); params.put("password","123456");
      * httpClient.doGet(url,params)；
      *
      * @param url
      *            请求地址
      * @param params
      *            请求参数
      * @return 返回 String jsonResult;
      *
      */
     public String doGet(String url, List<NameValuePair> params) {
         /** 建立HTTPGet对象 **/
         String paramStr = "";
         if (params == null)
             params = new ArrayList<NameValuePair>();
         /** 迭代请求参数集合 **/

         for (NameValuePair obj : params) {
             paramStr += paramStr = "&" + obj.getName() + "="
                     + URLEncoder.encode(obj.getValue());
         }
         if (!paramStr.equals("")) {
             paramStr = paramStr.replaceFirst("&", "?");
             url += paramStr;
         }
         return doGet(url);
     }

     /**
      * 提供GET形式的访问网络请求 doGet 参数示例：
      *
      * @param url
      *            请求地址
      * @return 返回 String jsonResult;
      *
      */
     public String doGet(String url) {
         /** 创建HttpGet对象 **/
         HttpGet httpRequest = new HttpGet(url);
         httpRequest.setHeaders(this.getHeader());
         try {
             /** 保持会话Session **/
             /** 设置Cookie **/
             MyHttpCookies li = new MyHttpCookies(context);
             CookieStore cs = li.getuCookie();
             /** 第一次请求App保存的Cookie为空，所以什么也不做，只有当APP的Cookie不为空的时。把请请求的Cooke放进去 **/
             if (cs != null) {
                 httpClient.setCookieStore(li.getuCookie());
             }

             /** 保持会话Session end **/

             /* 发送请求并等待响应 */
             HttpResponse httpResponse = httpClient.execute(httpRequest);
             /* 若状态码为200 ok */
             if (httpResponse.getStatusLine().getStatusCode() == 200) {
                 /* 读返回数据 */
                 strResult = EntityUtils.toString(httpResponse.getEntity());

                 /** 执行成功之后得到 **/
                 /** 成功之后把返回成功的Cookis保存APP中 **/
                 // 请求成功之后，每次都设置Cookis。保证每次请求都是最新的Cookis
                 li.setuCookie(httpClient.getCookieStore());

             } else {
                 strResult = "Error Response: "
                         + httpResponse.getStatusLine().toString();
             }
         } catch (ClientProtocolException e) {
             strResult = nullToString(e.getMessage());
             e.printStackTrace();
         } catch (IOException e) {
             strResult = nullToString(e.getMessage());
             e.printStackTrace();
         } catch (Exception e) {
             strResult = nullToString(e.getMessage());
             e.printStackTrace();
         } finally {
             httpRequest.abort();
             this.shutDownClient();
         }
         return strResult;
     }

     /**
      * 提供Post形式的访问网络请求 Post 参数示例： doPost 参数示例 List<NameValuePair> paramlist =
      * new ArrayList<NameValuePair>(); paramlist(new BasicNameValuePair("email",
      * "[email protected]")); paramlist(new BasicNameValuePair("address", "123abc"));
      * httpClient.doPost(url,paramlist);
      *
      * @param url
      *            请求地址
      * @param params
      *            请求参数
      * @return 返回 String jsonResult;
      * **/

     public String doPost(String url, List<NameValuePair> params) {
         /* 建立HTTPPost对象 */

         HttpPost httpRequest = new HttpPost(url);
         // 设置请求Header信息、
         httpRequest.setHeaders(this.getHeader());
         try {
             /** 添加请求参数到请求对象 */
 //          boolean upFileFlag = false;// 是否有文件上传
 //          MultipartEntity mpEntity = new MultipartEntity(
 //                  HttpMultipartMode.BROWSER_COMPATIBLE);
 //          for (NameValuePair param : params) {
 //              ContentBody contentBody = null;
 //              File file = new File(param.getValue());
 //              if (file.isFile()) {
 //                  contentBody = new FileBody(file);
 //                  upFileFlag = true;
 //              } else {
 //                  contentBody = new StringBody(param.getValue(), Charset
 //                          .forName(HTTP.UTF_8));
 //              }
 //              mpEntity.addPart(param.getName(), contentBody);
 //          }
 //
 //          if (upFileFlag == true) {// 文件 上传
 //              httpRequest.setEntity(mpEntity);
 //          } else {
                 /** 添加请求参数到请求对象 */
                 httpRequest.setEntity(new UrlEncodedFormEntity(params,
                         HTTP.UTF_8));
 //          }

             /** 保持会话Session **/
             /** 设置Cookie **/
                 MyHttpCookies li = new MyHttpCookies(context);
             CookieStore cs = li.getuCookie();
             /** 第一次请求App保存的Cookie为空，所以什么也不做，只有当APP的Cookie不为空的时。把请请求的Cooke放进去 **/
             if (cs != null) {
                 httpClient.setCookieStore(li.getuCookie());
             }

             /** 保持会话Session end **/

             /** 发送请求并等待响应 */

             HttpResponse httpResponse = httpClient.execute(httpRequest);

             /** 若状态码为200 ok */
             if (httpResponse.getStatusLine().getStatusCode() == 200) {
                 /* 读返回数据 */
                 strResult = EntityUtils.toString(httpResponse.getEntity());

                 /** 执行成功之后得到 **/
                 /** 成功之后把返回成功的Cookis保存APP中 **/
                 // 请求成功之后，每次都设置Cookis。保证每次请求都是最新的Cookis
                 li.setuCookie(httpClient.getCookieStore());

                 /** 设置Cookie end **/
             } else {
                 strResult = "Error Response: "
                         + httpResponse.getStatusLine().toString();
             }
         } catch (ClientProtocolException e) {
             strResult = "";
 //          strResult = e.getMessage().toString();
             e.printStackTrace();
         } catch (IOException e) {
             strResult = "";
 //          strResult = e.getMessage().toString();
             e.printStackTrace();
         } catch (Exception e) {
             strResult = "";
 //          strResult = e.getMessage().toString();
             e.printStackTrace();
         } finally {
             httpRequest.abort();
             this.shutDownClient();
         }
         return strResult;
     }

     /** 得到 apache http HttpClient对象 **/
     public DefaultHttpClient getHttpClient() {

         /** 创建 HttpParams 以用来设置 HTTP 参数 **/

         httpParams = new BasicHttpParams();

         /** 设置连接超时和 Socket 超时，以及 Socket 缓存大小 **/

         HttpConnectionParams.setConnectionTimeout(httpParams, 20 * 1000);

         HttpConnectionParams.setSoTimeout(httpParams, 20 * 1000);

         HttpConnectionParams.setSocketBufferSize(httpParams, 8192);

         HttpClientParams.setRedirecting(httpParams, true);

         /**
          * 创建一个 HttpClient 实例 //增加自动选择网络，自适应cmwap、CMNET、wifi或3G
          */
         MyHttpCookies li = new MyHttpCookies(context);
         String proxyStr = li.getHttpProxyStr();
         if (proxyStr != null && proxyStr.trim().length() > 0) {
             HttpHost proxy = new HttpHost(proxyStr, 80);
             httpClient.getParams().setParameter(ConnRouteParams.DEFAULT_PROXY,
                     proxy);
         }
         /** 注意 HttpClient httpClient = new HttpClient(); 是Commons HttpClient **/

         httpClient = new DefaultHttpClient(httpParams);
         httpClient.setHttpRequestRetryHandler(requestRetryHandler);

         return httpClient;

     }

     /** 得到设备信息、系统版本、驱动类型 **/
     private Header[] getHeader() {
         /** 请求头信息 end **/
         MyHttpCookies li = new MyHttpCookies(context);
         return li.getHttpHeader();
     }

     /** 销毁HTTPCLient **/
     public void shutDownClient() {
         httpClient.getConnectionManager().shutdown();
     }

 //  /**
 //   * 提供GET形式的访问网络请求 doGet 参数示例：
 //   *
 //   * @param url
 //   *            请求地址
 //   * @return 返回 String jsonResult;
 //   *
 //   */
 //  public InputStream doDownFile(String url) {
 //      /** 创建HttpGet对象 **/
 //      HttpGet httpRequest = new HttpGet(url);
 //      httpRequest.setHeaders(this.getHeader());
 //      try {
 //          /** 保持会话Session **/
 //          /** 设置Cookie **/
 //          MyHttpCookies li = new MyHttpCookies(context);
 //          CookieStore cs = li.getuCookie();
 //          /** 第一次请求App保存的Cookie为空，所以什么也不做，只有当APP的Cookie不为空的时。把请请求的Cooke放进去 **/
 //          if (cs != null) {
 //              httpClient.setCookieStore(li.getuCookie());
 //          }
 //          /** 保持会话Session end **/
 //          /* 发送请求并等待响应 */
 //          HttpResponse httpResponse = httpClient.execute(httpRequest);
 //          /* 若状态码为200 ok */
 //          if (httpResponse.getStatusLine().getStatusCode() == 200) {
 //              /** 执行成功之后得到 **/
 //              /** 成功之后把返回成功的Cookis保存APP中 **/
 //              // 请求成功之后，每次都设置Cookis。保证每次请求都是最新的Cookis
 //              li.setuCookie(httpClient.getCookieStore());
 //              this.contentLength = httpResponse.getEntity()
 //                      .getContentLength();
 //              /* 读返回数据 */
 //              return httpResponse.getEntity().getContent();
 //          } else {
 //              strResult = "Error Response: "
 //                      + httpResponse.getStatusLine().toString();
 //          }
 //      } catch (ClientProtocolException e) {
 //          strResult = e.getMessage().toString();
 //          e.printStackTrace();
 //      } catch (IOException e) {
 //          strResult = e.getMessage().toString();
 //          e.printStackTrace();
 //      } catch (Exception e) {
 //          strResult = e.getMessage().toString();
 //          e.printStackTrace();
 //      } finally {
 //          // httpRequest.abort();
 //          // this.shutDownClient();
 //      }
 //      this.contentLength = 0;
 //      return null;
 //  }

     /**
      * 异常自动恢复处理, 使用HttpRequestRetryHandler接口实现请求的异常恢复
      */
     private static HttpRequestRetryHandler requestRetryHandler = new HttpRequestRetryHandler() {
         // 自定义的恢复策略
         public boolean retryRequest(IOException exception, int executionCount,
                 HttpContext context) {
             // 设置恢复策略，在发生异常时候将自动重试N次
             if (executionCount >= 3) {
                 // 如果超过最大重试次数，那么就不要继续了
                 return false;
             }
             if (exception instanceof NoHttpResponseException) {
                 // 如果服务器丢掉了连接，那么就重试
                 return true;
             }
             if (exception instanceof SSLHandshakeException) {
                 // 不要重试SSL握手异常
                 return false;
             }
             HttpRequest request = (HttpRequest) context
                     .getAttribute(ExecutionContext.HTTP_REQUEST);
             boolean idempotent = (request instanceof HttpEntityEnclosingRequest);
             if (!idempotent) {
                 // 如果请求被认为是幂等的，那么就重试
                 return true;
             }
             return false;
         }
     };

     public long getContentLength() {
         return contentLength;
     }

     /**
      * 假如obj对象 是null返回""
      * @param obj
      * @return
      */
     public static String nullToString(Object obj){
         if(obj==null){
             return "";
         }
         return obj.toString();
     }
 }

 

 package com.hlj.padtwo.util.util_public.httputil;



 import org.apache.http.Header;
 import org.apache.http.client.CookieStore;
 import org.apache.http.message.BasicHeader;

 import android.content.Context;
 import android.database.Cursor;
 import android.net.Uri;
 import android.net.wifi.WifiManager;

 /**
  * http请求的缓存和一些公用的参数
  * @author helijun
  *
  */
 public class MyHttpCookies {
     /** 每页数据显示最大数 */
     private static int pageSize = 10;
     /** 当前会话后的cokie信息 */
     private static CookieStore uCookie = null;
     /** 公用的HTTP提示头信息 */
     private static Header[] httpHeader;
     /** HTTP连接的网络节点 */
     private static String httpProxyStr;
     /**http请求的公用url部分**/
     public static String baseurl = "http://192.168.50.56:5056/River";
     /**上下文对象**/
     Context context;

     public MyHttpCookies(Context context){
         this.context = context;
         /** y设置请求头 **/
         /** y设置请求头 **/
         Header[] header = {
                 new BasicHeader("PagingRows", String.valueOf(pageSize)) };
         httpHeader = header;
     }

     /**
      * 增加自动选择网络，自适应cmwap、CMNET、wifi或3G
      */
     @SuppressWarnings("static-access")
     public void initHTTPProxy() {
         WifiManager wifiManager = (WifiManager) (context.getSystemService(context.WIFI_SERVICE));
         if (!wifiManager.isWifiEnabled()) {
             Uri uri = Uri.parse("content://telephony/carriers/preferapn"); // 获取当前正在使用的APN接入点
             Cursor mCursor =context. getContentResolver().query(uri, null, null, null,
                     null);
             if (mCursor != null) {
                 mCursor.moveToNext(); // 游标移至第一条记录，当然也只有一条
                 httpProxyStr = mCursor.getString(mCursor
                         .getColumnIndex("proxy"));
             }
         } else {
             httpProxyStr = null;
         }
     }

     public int getPageSize() {
         return pageSize;
     }

     public void setPageSize(int pageSize) {
         this.pageSize = pageSize;
     }

     public CookieStore getuCookie() {
         return uCookie;
     }

     public void setuCookie(CookieStore uCookie) {
         this.uCookie = uCookie;
     }


     public Header[] getHttpHeader() {
         return httpHeader;
     }

     public String getHttpProxyStr() {
         return httpProxyStr;
     }
 }