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);
                    }
                });