网络请求框架-基于Volley（一）

直接参考volley的JsonRequest 和 JsonObjectRequest的代码

BeanRequest.java
BeanRequest继承了Request，并且使用泛型，利用反射机制获取泛型的Type，使用fastjson将接口返回的数据（String型）转换为我们需要的Bean。泛型继承了BaseBean，BaseBean包含code和msg，BaseBean保存接口返回的通有数据，如果有其他的可以自行添加。这样就实现了直接返回需要的实体类的数据类型。

import com.alibaba.fastjson.JSON;import com.android.volley.AuthFailureError;import com.android.volley.Cache;import com.android.volley.NetworkResponse;import com.android.volley.ParseError;import com.android.volley.Request;import com.android.volley.Response;import com.android.volley.toolbox.HttpHeaderParser;import com.hongxue.volley.bean.BaseBean;import java.io.UnsupportedEncodingException;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.HashMap;import java.util.Map;public class BeanRequest<T extends BaseBean> extends Request<T> {    protected static final String PROTOCOL_CHARSET = "utf-8";    private final SuccessListener<T> mSuccessListener;    private Map<String, String> mPostParamMap;    public static abstract class SuccessListener<T> {        private final Type type;        protected SuccessListener() {            //利用反射机制获取泛型的Type            Type superClass = getClass().getGenericSuperclass();            type = ((ParameterizedType) superClass).getActualTypeArguments()[0];        }        public Type getType() {            return type;        }        public abstract void onResponse(T response);    }    public BeanRequest(int method, String url, Map<String, Object> postParamMap, SuccessListener<T> successListener, Response.ErrorListener errorListener) {        super(method, url, errorListener);        mSuccessListener = successListener;        if (postParamMap != null) {//postParamMap不为空用的是post方法            mPostParamMap = new HashMap<>(postParamMap.size());            for (Map.Entry<String, Object> entry : postParamMap.entrySet()) {                mPostParamMap.put(entry.getKey(), String.valueOf(entry.getValue()));            }        }    }    /**     * post方式使用getParams()将参数交给父类处理     */    @Override    protected Map<String, String> getParams() throws AuthFailureError {        return mPostParamMap;    }    @Override    protected Response<T> parseNetworkResponse(NetworkResponse response) {        try {            String jsonString = new String(response.data,                    HttpHeaderParser.parseCharset(response.headers, PROTOCOL_CHARSET));            Type type = mSuccessListener.getType();            T bean = JSON.parseObject(jsonString, type);//这里使用fastjson直接将String转换成Bean            Cache.Entry entry = HttpHeaderParser.parseCacheHeaders(response);            return Response.success(bean, entry);        } catch (UnsupportedEncodingException e) {            e.printStackTrace();            return Response.error(new ParseError(e));        }    }    @Override    protected void deliverResponse(T response) {        mSuccessListener.onResponse(response);//回调    }}

BaseBean：一般网络请求都会返回code和msg

public class BaseBean {    private String code;    private String msg;    public String getCode() {        return code;    }    public void setCode(String code) {        this.code = code;    }    public String getMsg() {        return msg;    }    public void setMsg(String msg) {        this.msg = msg;    }}

封装自己的HttpClient

public class HxHttpClient {    private static RequestQueue requestQueue;    private final Context context;    private HxHttpClient(Context context) {        this.context = context;    }    public synchronized static HxHttpClient newInstance(Context context) {        if (requestQueue == null) {            HTTPSTrustManager.allowAllSSL();//跳过https的验证，如果用的http请求可以忽略            requestQueue = Volley.newRequestQueue(context.getApplicationContext());        }        return new HxHttpClient(context);    }    public RequestQueue getRequestQueue() {        return requestQueue;    }    public <T extends BaseBean> BeanRequest<T> request(BaseApi api, BeanRequest.SuccessListener<T> successListener, Response.ErrorListener errorListener) {        String url = api.getUrl();        TreeMap<String, Object> params = api.getParams();        if (api.requestMethod() == BaseApi.Method.POST) {            return post(url, params, successListener, errorListener);        } else {            if (!params.isEmpty()) {                url += "?" + mapToQueryString(params);            }            return get(url, successListener, errorListener);        }    }    public <T extends BaseBean> BeanRequest<T> post(String url, Map<String, Object> postParamMap, BeanRequest.SuccessListener<T> successListener, Response.ErrorListener errorListener) {        BeanRequest<T> request = new BeanRequest<>(Request.Method.POST, url, postParamMap, successListener, errorHandler(errorListener));        addRequest(request);        return request;    }    public <T extends BaseBean> BeanRequest<T> get(String url, BeanRequest.SuccessListener<T> successListener, Response.ErrorListener errorListener) {        BeanRequest<T> request = new BeanRequest<T>(Request.Method.GET, url, null, successListener, errorHandler(errorListener));        addRequest(request);        return request;    }    private <T extends BaseBean> void addRequest(BeanRequest<T> request) {        requestQueue.add(request);    }    public Response.ErrorListener errorHandler(final Response.ErrorListener errorListener) {        return new Response.ErrorListener() {            @Override            public void onErrorResponse(VolleyError error) {                error = new VolleyError("亲，您的网络不太顺畅喔~", error);                if (errorListener != null) {                    errorListener.onErrorResponse(error);                }            }        };    }    /**     * 参数拼接     */    private String mapToQueryString(Map<String, Object> params) {        StringBuilder encodedParams = new StringBuilder();        try {            for (Map.Entry<String, Object> entry : params.entrySet()) {                if (entry.getValue() == null || entry.getValue() instanceof File)                    continue;                encodedParams.append(URLEncoder.encode(entry.getKey(), "UTF-8"));                encodedParams.append('=');                encodedParams.append(URLEncoder.encode(String.valueOf(entry.getValue()), "UTF-8"));                encodedParams.append('&');            }            return encodedParams.toString();        } catch (UnsupportedEncodingException uee) {            throw new RuntimeException("Encoding not supported: UTF-8", uee);        }    }}

BaseApi

import com.hongxue.volley.constants.HttpConstant;import java.lang.reflect.Field;import java.util.TreeMap;public abstract class BaseApi {    public enum Method {        GET,        POST,    }    protected abstract String getPath();    public abstract Method requestMethod();    public String getUrl() {        return HttpConstant.API_URL + getPath();    }    /**     * 获得请求接口添加的参数     */    public TreeMap<String, Object> getParams() {        TreeMap<String, Object> params = new TreeMap<String, Object>();        Class clazz = getClass();        Field[] field = clazz.getDeclaredFields();//getDeclaredFields()返回Class中所有的字段，包括私有字段        //这里获取到的是GetImageListInfoApi的type，具体看GetImageListInfoApi.java        try {            for (Field f : field) {                f.setAccessible(true);                if (f.get(this) != null) {                    params.put(f.getName(), f.get(this));                }            }        } catch (IllegalArgumentException | IllegalAccessException e) {            e.printStackTrace();        }        return params;    }}

GetImageInfoApi

public class GetImageListInfoApi extends BaseApi{    private String type;//请求接口需要传递的参数    @Override    public Method requestMethod() {        return Method.POST;    }    @Override    protected String getPath() {        return "api/接口名";    }    public void setType(String type) {        this.type = type;    }}

获取图片信息

    private void getImageListInfo() {        GetImageListInfoApi api = new GetImageListInfoApi();        api.setType("1");        HxHttpClient.newInstance(MainActivity.this).request(api,                new BeanRequest.SuccessListener<ImageListBean >() {                    @Override                    public void onResponse(ImageListBean response) {                        //直接返回了ImageListBean                        ArrayList<ImageBean> list = response.getDataList();                    }                }, new Response.ErrorListener() {                    @Override                    public void onErrorResponse(VolleyError error) {                    }                }        );    }

ImageListBean

public class ImageListBean extends BaseBean {    ArrayList<ImageBean> dataList;    public ArrayList<ImageBean> getDataList() {        return dataList;    }    public void setDataList(ArrayList<ImageBean> dataList) {        this.dataList = dataList;    }}

ImageBean

public class ImageBean {    public String name;//图片名    public String imageUrl;//图片地址    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getImageUrl() {        return imageUrl;    }    public void setImageUrl(String imageUrl) {        this.imageUrl = imageUrl;    }}

总结：总的来说就是使用反射机制和fastjson实现了返回我们需要的实体类类型