HttpClient封装

package com.exmyth.net;

public interface KeyLoadListener {
    public void onSuccess(byte[] key);

//    public void onFailure(int statusCode, String content);
}

package com.exmyth.net;


public abstract class LoadDataHandler {
    /**
     * 加载数据时调用
     */
    public void onStart() {};

    /**
     * 加载数据调用,得到缓存数据
     * 
     * @param data
     */
//    protected void onLoadCaches(String data) {};

    /**
     * 当调用服务器接口成功获取数据时,调用这个方法
     * 
     * @param data
     */
    public abstract void onSuccess(String data);

    /**
     * 当调用服务器接口获取数据失败时,调用这个方法
     * 
     * @param statusCode
     *            出错原因
     * @param message
     *            出错原因描述
     */
    public void onFailure(int statusCode, String message) {
    };

    /**
     * 加载完成时调用
     */
    public void onFinish() {
        
    }

    protected void onSuccess(byte[] content) {

        this.onSuccess(new String(content));
    }

    protected void onFailure(int statusCode, byte[] content) {
        this.onFailure(statusCode,new String(content));
    }
}

package com.exmyth.net;
import org.apache.http.Header;

import com.loopj.android.http.AsyncHttpResponseHandler;
  
public class WPHttpResponseHandler extends AsyncHttpResponseHandler {  
    private LoadDataHandler mHandler;  
  
    public WPHttpResponseHandler(LoadDataHandler mHandler) {  
        this.mHandler = mHandler;  
    }  
    @Override  
    public void onStart() {  
        super.onStart();
        mHandler.onStart();  
    }  
    
    @Override
    public void onFailure(int statusCode, Header[] headers, byte[] content, Throwable error) {
        // TODO Auto-generated method stub
        super.onFailure(statusCode, headers, content, error);
//        if (content != null && 0 < content.length ) { 
            mHandler.onFailure(statusCode, content);  
//        }
    }
    
    @Override  
    public void onFinish() {
        super.onFinish();  
        mHandler.onFinish();  
    }
    
    @Override
    public void onSuccess(int statusCode, Header[] headers, byte[] content) {
        super.onSuccess(statusCode, headers, content);
        switch (statusCode) {  
        case 200:  
//            if (content != null && 0 < content.length ) { 
                mHandler.onSuccess(content);
//            }
            break;  
        case 401:  
            mHandler.onFailure(401, "没有登录");

            break;  
        case 403:
            mHandler.onFailure(403, "没有权限");
            break;  
        default:  
            break;  
        }
        
    }
}  

package com.exmyth.utils;

import com.exmyth.net.KeyLoadListener;
import com.exmyth.net.LoadDataHandler;
import com.exmyth.net.WPHttpResponseHandler;

public class HttpUtils{
    
    private static String versionId = "24";
    private static String appVersion = "24";//当前的appVersion,如果版本过低,会有强制更新提示
    private static final String CLIENT_KEY_STORE_PASSWORD = "198345";  
    private static Context mContext;
    private static AsyncHttpClient client =new AsyncHttpClient();    //实例话对象
    public static byte[] key = null;
    public static boolean encrypt = false;
    
    public HttpUtils(Context context){
        mContext = context;
        client.setTimeout(10000);   //设置链接超时，如果不设置，默认为10s
        PersistentCookieStore myCookieStore = new PersistentCookieStore(mContext);
         BasicClientCookie newCookie = new BasicClientCookie("name", CommonUtil.mac);
         newCookie.setVersion(1);
         newCookie.setDomain("mydomain.com");
         newCookie.setPath("/");
         myCookieStore.addCookie(newCookie);
         client.setCookieStore(myCookieStore);
            try {

                                
                KeyStore keystore = KeyStore.getInstance("BKS");
                keystore.load(mContext.getResources().openRawResource(
                    R.raw.client), CLIENT_KEY_STORE_PASSWORD.toCharArray());

                KeyStore trustkeystore = KeyStore.getInstance("BKS");
                trustkeystore.load(mContext.getResources().openRawResource(
                    R.raw.server_trust), CLIENT_KEY_STORE_PASSWORD.toCharArray());
                
                SSLSocketFactory factory = new SSLSocketFactory(keystore, CLIENT_KEY_STORE_PASSWORD, trustkeystore);
                Scheme sch = new Scheme("https", factory, 443);
                client.getHttpClient().getConnectionManager().getSchemeRegistry().register(sch);
            }catch(Exception e){
                e.printStackTrace();
            }
    }

    
    public static void post(final String url, final Map<String, String> param,final LoadDataHandler callback)
    {
        if(encrypt && null != param && 0 < param.keySet().size()){
            if (key == null) {
                getKey(0, callback, new KeyLoadListener() {
                    
                    @Override
                    public void onSuccess(byte[] key) {
                        doPost(0, url, key,param, callback);
                    }
                });
            }
            else{
                doPost(0, url, key,param, callback);
            }
        }else{
            doPost(0, url, null,param, callback);
        }
    }
    //3000    获取key的接口失败(onFailure)
    //4000    app问题,请求失败
    //5000    获取key的接口不能顺利请求(statusCode != 200)
    //5100    服务器端getKey异常
    //5200    服务器端返回结果不合法,或者APP解析结果异常
    //5300    从服务端获取的key是空的(TextUtils.isEmpty(key)==true)
    //6000    第一次请求获取key失败
    //7000    获取到key后,第二请求后仍然失效
    //8000    {success:false}正常aes加密/非加密请求,但是success为false
    //8100    第二次请求aes加密请求仍然失败
    //8200    服务器端返回结果不合法,或者APP解析结果异常
    private static void doPost(final int index, final String url, 
            byte[] key, final Map<String, String> param , final LoadDataHandler callback) {
        
        if (1 < index) {
            callback.onFailure(7000, "获取到key后,第二请求后仍然失效");
        }
        
        RequestParams requestParams = new RequestParams();
        
        if(null != param && 0 < param.keySet().size()&& null != key && 0 < key.length){
            AESUtil aes = new AESUtil(key);
            for (Map.Entry<String, String> entry : param.entrySet()) {   
                requestParams.put(entry.getKey(), defaultEncodeBase64String(aes, entry.getValue()));
            }
        }
        
        //无参数,不需要做aes加密
        requestParams.put("versionId", versionId);
        
        client.post(url, requestParams, new WPHttpResponseHandler(
            new LoadDataHandler() {

                @Override
                public void onSuccess(String data) {
                    try {
                        JSONObject result = new JSONObject(data);
                        if("true".equals(result.optString("success"))){
                            callback.onSuccess(data);
                        }
                        else{
                            //{"errMsg":"Aes Decode error","errorCode":"255","success":false}
                            if ("255".equals(result.optString("errorCode"))) {
                                if(0 < index){
                                    callback.onFailure(8100, "第二次请求aes加密请求仍然失败");
                                }
                                else{
                                    //第一次请求aes加密请求失败,就请求获取key继续调用接口
                                    getKey(0, callback,new KeyLoadListener() {
                                        
                                        @Override
                                        public void onSuccess(byte[] key) {
                                            doPost((index+1), url, key, param, callback);
                                        }
                                    });
                                    
                                }
                                
                            }
                            else{
                                //{success:false}正常aes加密/非加密请求,但是success为false
                                callback.onFailure(8000, data);
                            }
                        }
                    } catch (JSONException e) {
//                        e.printStackTrace();
                        callback.onFailure(8200, data);
                    }
                }
                
                @Override
                public void onFailure(int statusCode, String message) {
                    super.onFailure(statusCode, message);
                    callback.onFailure(4000, message);
                }
            }));
    }

      
      //获得key
      private static void getKey(final int index, final LoadDataHandler callback, final KeyLoadListener listener) {
          if (0 < index) {
            callback.onFailure(6000, "第一次请求获取key失败");
        }
          else{
              client.post(RequestConfig.Key_URL, null, 
                      new AsyncHttpResponseHandler(){
                  
                  @Override
                  public void onSuccess(int statusCode,Header[] headers, byte[] content) {
                      
                      if(200 == statusCode){
                          try {
                              JSONObject jsonObject = new JSONObject(new String(content));
                              String success = jsonObject.optString("success");
                              //{"data":"1234567890ABCDEF1234567890ABCDEF","success":true}
                              if("true".equals(success)){
                                  String data = jsonObject.optString("data");
                                  if (!TextUtils.isEmpty(data)) {
                                      key = Base64.decodeBase64(data.getBytes());
                                      listener.onSuccess(key);
                                  }
                                  else{
//                                      getKey((index + 1), callback,listener);
//                                      listener.onFailure(5300,"从服务端获取的key是空的(TextUtils.isEmpty(key)==true)");
                                      callback.onFailure(5300, "从服务端获取的key是空的(TextUtils.isEmpty(key)==true)");
                                  }
                              }
                              else{
                                  //{"errMsg":"errorCode","success":false}
                                  callback.onFailure(5100, "服务器端getKey异常");
                                  //getKey((index + 1), callback,listener);
                              }
                          } catch (JSONException e) {
//                              e.printStackTrace();
                              callback.onFailure(5200, "服务器端返回结果不合法,或者APP解析结果异常");
                          }
                      }
                      else{
                          callback.onFailure(5000, "获取key的接口不能顺利请求(statusCode != 200)");
                      }
                }
                  
                  @Override
                public void onFailure(int statusCode, Header[] headers,
                        byte[] content, Throwable error) {
                    super.onFailure(statusCode, headers, content, error);
//                    getKey((index + 1), callback,listener);
                    callback.onFailure(3000, "获取key的接口失败(onFailure)");
                }
              });
        }
      }
      

    // 加密密码
    public static String md5(String str) {
        MessageDigest messageDigest = null;
        try {
            messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.reset();
            messageDigest.update(str.getBytes("UTF-8"));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        byte[] byteArray = messageDigest.digest();
        StringBuffer md5StrBuff = new StringBuffer();
        for (int i = 0; i < byteArray.length; i++) {
            if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)
                md5StrBuff.append("0").append(
                        Integer.toHexString(0xFF & byteArray[i]));
            else
                md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));
        }
        return md5StrBuff.toString();
    }
    
    //获取默认请求参数字节
    private static String defaultEncodeBase64String(AESUtil aes, String param){
        //如果是加密请求,调动此方法
        return encodeBase64String(true,aes,param);
        //如果是非加密请求,调动此方法
//        return encodeBase64String(false,null,param);
    }
    
    private static String encodeBase64String(boolean encrypt,AESUtil aes, String param){
        if(null == param){
            return null;
        }
        if(encrypt){
            if(null == aes){
                if (null == key){
                    key = "123456789001234567891234567890CD".getBytes();
                }
                aes = new AESUtil(key);
            }
            return Base64.encodeBase64String(aes.aesEncrypt(param.getBytes()));
        }
//        return Base64.encodeBase64String(param.getBytes());
        return param;
    }

}