网络请求框架-基于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实现了返回我们需要的实体类类型