Android网络请求框架

本篇主要介绍一下Android中经常用到的网络请求框架；

客户端网络请求，就是客户端发起网络请求，经过网络框架的特殊处理，让后将请求发送的服务器，服务器根据

请求的参数，返回客户端需要的数据，经过网络框架的处理，最后返回给客户端需要的数据，具体如下图所示：

如上图所示，网络框架其实就是架设在客户端和服务器之间的通信桥梁，负责处理客户端的请求数据，并想服务器发送请求任务

然后处理服务器返回的数据，并将最终结果返回给客户端，具体代码实现如下：

网络请求类：

 package com.jiao.yichenetframe.net;

 import java.util.ArrayList;
 import android.content.Context;
 import android.os.AsyncTask;

 import com.jiao.yichenetframe.net.RequestAsyncTask.ResponseCallBack;

 /**
  * 连接View层与网络交互的中间层 用来创建异步任务请求网络 管理所有的网络请求任务
  *
  */
 public class RequestNet {
     public static RequestNet requestnet = null;
     public static ArrayList<AsyncTask> arrayAsyncTask;

     public static RequestNet getRequestNet() {
         // 单例，保证整个项目中只有一个网络请求实体
         if (requestnet == null) {
             requestnet = new RequestNet();
             arrayAsyncTask = new ArrayList<AsyncTask>();
         }
         return requestnet;
     }

     /**
      * 请求网络数据
      * */
     public RequestAsyncTask RequestData(Context context, String ip,
             Object jsonObject, ResponseCallBack callBack1) {
         RequestAsyncTask asynctask = new RequestAsyncTask(context, ip,
                 jsonObject, callBack1);

         asynctask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
         arrayAsyncTask.add(asynctask);
         return asynctask;
     }

 }

网络任务具体执行类（真正的发起网络请求任务，处理客户端传递过来的参数，并处理服务器返回的数据）

 package com.jiao.yichenetframe.net;

 import java.io.File;
 import java.util.ArrayList;
 import java.util.Map;
 import org.json.JSONException;
 import org.json.JSONObject;
 import android.content.Context;
 import android.os.AsyncTask;
 import android.text.TextUtils;
 import com.jiao.yichenetframe.tool.ConstantTool;
 import com.jiao.yichenetframe.tool.MsLog;

 /**
  * 主要负责网络的异步请求
  *
  * @author pengqm
  *
  */
 public class RequestAsyncTask extends AsyncTask<String, Integer, String> {
     private String ip;// 接口地址
     private Object jsonObject;// 接口参数对象
     private ResponseCallBack callBack1;// 接口回调
     private GetJsonRequest getJsonRequest;
     private HttpUrlConnection_Request urlConnection_Req;
     private ArrayList<File> arrFile = null;
     private Context mcontext;

     public RequestAsyncTask(Context context, String ip, Object jsonObject,
             ResponseCallBack callBack1) {
         this.ip = ip;
         this.jsonObject = jsonObject;
         this.callBack1 = callBack1;
         mcontext = context;
         getJsonRequest = new GetJsonRequest(context);
         urlConnection_Req = new HttpUrlConnection_Request(mcontext);
     }

     public void setArrayFile(ArrayList<File> Files) {
         arrFile = Files;
     }

     public Context getContent() {
         return mcontext;
     }

     @Override
     protected String doInBackground(String... arg0) {
         String jsonarr = null;
         MsLog.e("ip", ip);
         try {
             if (jsonObject == null) {
                 jsonarr = urlConnection_Req.makeHttpRequest(ip,
                         ConstantTool.post, null);
             } else {
                 // 得到拼接的访问接口字符串
                 String jsonStr = getJsonRequest.getJsonObject(jsonObject);
                 MsLog.e("Request_jsonStr", jsonStr);
                 // 如果arrFile等于null 表示普通请求数据，否则带图片请求
                 if (!TextUtils.isEmpty(jsonStr)) {
                     if (arrFile != null) {
                         Map map = getJsonRequest.objectMap(jsonObject);
                         jsonarr = HttpUrlConnection_Request_PD.uploadSubmit(ip,
                                 map, arrFile, mcontext);
                     } else {
                         jsonarr = urlConnection_Req.makeHttpRequest(ip,
                                 ConstantTool.post, jsonStr);
                     }
                 }
             }
         } catch (Exception e) {
             // e.printStackTrace();
             // publishProgress(0);

         }
         if (isCancelled()) {
             return null;
         }
         MsLog.e("jsonarr----", jsonarr);
         return jsonarr;
     }

     @Override
     protected void onProgressUpdate(Integer... values) {
         super.onProgressUpdate(values);
     }

     @Override
     protected void onPostExecute(String result) {
         super.onPostExecute(result);
         // 接口访问完成后 将任务从任务列表中移除
         RequestNet.getRequestNet().arrayAsyncTask.remove(this);
         if (callBack1 == null) {
             return;
         }
         if (result != null) {
             // 根据返回值 判断是否是错误码
             if (result.equals(ConstantTool.LOCALERRO_NETTIMEROUT)) {
                 // 网络超时
                 callBack1.onErrorResponse(ConstantTool.LOCALERRO_NETTIMEROUT);
             } else {// 不是错误码 表示数据正常 接口访问成功 返回json字符串
                 try {
                     JSONObject jb;
                     jb = new JSONObject(result);
                     callBack1.onResponse(jb);
                 } catch (JSONException e) {
                     e.printStackTrace();
                     // 网络异常
                     callBack1.onErrorResponse(ConstantTool.LOCALERROR_UNUSUAL);
                 }
             }
         } else {// 没有返回值
             // 无网络连接
             callBack1.onErrorResponse(ConstantTool.LOCALERRO_NONETWORK);
         }
     }

     public interface ResponseCallBack {
         public void onResponse(JSONObject response);

         public void onErrorResponse(String error);
     }
 }

请求字符串处理工具类（用来处理请求参数，创建符合服务器和客户端事先约定的请求规则的请求字符串）

注：我是根据我们约定的规则来定义此类的，不同的项目或不同的公司规则不一致，可以自行修改

 package com.jiao.yichenetframe.net;

 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 import java.util.Map;
 import android.content.Context;
 import com.google.gson.Gson;

 /**
  * 将请求接口的数据进行包装
  * */
 public class GetJsonRequest {
     public Context mcontext;

     public GetJsonRequest(Context context) {
         mcontext = context;
     }

     /**
      *
      * 根据对象属性名获取属性的值
      *
      */
     private Object getFieldValueByName(String fieldName, Object o) {
         try {
             String firstLetter = fieldName.substring(0, 1).toUpperCase();
             String getter = "get" + firstLetter + fieldName.substring(1);
             Method method = o.getClass().getMethod(getter, new Class[] {});
             Object value = method.invoke(o, new Object[] {});
             return value;
         } catch (Exception e) {
             e.printStackTrace();
             return null;
         }
     }

     /**
      *
      * 通过反射将实体类获取字段,进行拼装返回一个完整的字符串，用于请求服务器
      *
      */
     public String getJsonObject(Object object) {
         Gson gson = new Gson();
         String j = gson.toJson(object);

         //遍历实体类的各个参数值，并生成一个map集合
         try {
             HashMap<String, Object> map = new HashMap<String, Object>();
             Field[] fields = object.getClass().getDeclaredFields();
             for (Field field : fields) {
                 field.setAccessible(true);
                 String name = field.getName();
                 Object value = getFieldValueByName(name, object);
                 if (value == null) {
                     value = "";
                 }
                 map.put(name, value);

             }
             //遍历map集合，根据既定规则拼接访问接口的字符串
             String target_string = "";
             for (Map.Entry<String, Object> me : map.entrySet()) {
                 target_string = target_string + me.getKey() + "="
                         + me.getValue() + "&";
             }
             //去掉最后的"&"
             target_string = target_string.substring(0,target_string.lastIndexOf("&"));
             return target_string;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 根据对象转换map，上传图片时携带的参数
      * */
     public Map<String, Object> objectMap(Object object) {
         HashMap<String, Object> map = new HashMap<String, Object>();
         try {
             Field[] fields = object.getClass().getDeclaredFields();
             for (Field field : fields) {
                 field.setAccessible(true);
                 String name = field.getName();
                 Object value = getFieldValueByName(name, object);
                 if (value == null) {
                     value = "";
                 }
                 map.put(name, value);
             }
             return map;
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;

     }

 }

网络工具类（和服务器交互，向服务器传递数据，并接收服务器返回的数据）

 package com.jiao.yichenetframe.net;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.net.HttpURLConnection;
 import java.net.SocketTimeoutException;
 import java.net.URL;
 import org.json.JSONArray;
 import android.content.Context;
 import com.jiao.yichenetframe.YiCheNetFrameApplication;
 import com.jiao.yichenetframe.tool.ConstantTool;
 import com.jiao.yichenetframe.tool.Utils;

 /**
  * 采用HttpUrlConnection请求服务类
  * */
 public class HttpUrlConnection_Request {
     InputStream inputstream = null;
     JSONArray jObj = null;
     String result = null;
     public HttpUrlConnection_Request urlConnection_request = null;
     private Context mcontext;

     // constructor
     public HttpUrlConnection_Request(Context context) {
         mcontext = context;
     }

     // function get json from url
     public String makeHttpRequest(String url, String method, String params) {
         HttpURLConnection urlConnection = null;
         // Making HTTP request
         try {
             String versionCode = YiCheNetFrameApplication.VERSIONCODE;
             if (method.equals(ConstantTool.post)) {
                 urlConnection = (HttpURLConnection) new URL(url)
                         .openConnection();
                 urlConnection.setConnectTimeout(40000);
                 urlConnection.setReadTimeout(40000);
                 urlConnection.setDoInput(true);
                 urlConnection.setDoOutput(true);
                 urlConnection.setRequestProperty("connection", "close");
                 urlConnection.setChunkedStreamingMode(0);
                 urlConnection.setRequestMethod(method);
                 urlConnection.setRequestProperty("MallAppVersion", versionCode);
                 urlConnection.setRequestProperty("SystemType",
                         ConstantTool.SystemType);
                 urlConnection.setRequestProperty("Content-Type",
                         "application/x-www-form-urlencoded");
                 urlConnection.setRequestProperty("AccessToken",
                         "4b5b8693-5ebb-4f34-9070-d8b3f3875ad7");
                 urlConnection.setRequestProperty("Charsert", "UTF-8");
                 OutputStream out = new BufferedOutputStream(
                         urlConnection.getOutputStream());
                 if (params != null) {
                     out.write(params.getBytes("UTF-8"));
                 }
                 out.flush();
                 out.close();
                 int responseCode = urlConnection.getResponseCode();
                 if (responseCode == 200) {
                     inputstream = new BufferedInputStream(
                             urlConnection.getInputStream());
                 } else {
                     inputstream = new BufferedInputStream(
                             urlConnection.getErrorStream());
                 }
             }
             result = Utils.convertStreamToString(inputstream).trim();
             inputstream.close();
             inputstream = null;
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         } catch (SocketTimeoutException e) {
             result = ConstantTool.LOCALERRO_NETTIMEROUT;
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             urlConnection.disconnect();
         }
         // return JSON String
         return result;

     }
 }

网络请求示例：

 // 获取列表四个参数分别是：Context、url请求接口地址、object请求参数（封装对象）、请求回调
         RequestNet.getRequestNet().RequestData(this, url,
                 object, new ResponseCallBack() {
                     @Override
                     public void onResponse(JSONObject response) {

                         // 网络请求成功 返回json
                         System.out.println("返回值：" + response);

                     }

                     @Override
                     public void onErrorResponse(String error) {
                         // 网络请求失败 失败原因
                         System.out.println("错误：" + error);
                     }
                 });