Android volley封装实践

在项目中一般使用使用volley方式如下，用起来给人一种很乱的感觉，于是一种盘它的想法油然而生。

public void get() {
String url = "https://tcc.taobao.com/cc/json/mobile_tel_segment.htm?tel=......";
StringRequest request = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {           @Override

           public void onResponse(String s) {

               Toast.makeText(MainActivity.this,s,Toast.LENGTH_SHORT).show();

           }

       }, new Response.ErrorListener() {           @Override

           public void onErrorResponse(VolleyError volleyError) {

               Toast.makeText(MainActivity.this,volleyError.toString(),Toast.LENGTH_SHORT).show();

           }

       });

       request.setTag("abcGet");

       MyApplication.getHttpQueues().add(request);

   }

首先看一下我封装后的使用例子:

 private void initData() {
        NewsApi.getInfo(new NetCallback<News>() {            @Override
            public void OnSuccess(final News result) {
                mAdapter.setData(result.getResult().getData());
            }            @Override
            public void OnError(RestfulError error) {
            }
        });
    }

有没有看起来很舒服的感觉。好吧，让我开始盘它吧！
1.首先我先去写了一个基类，用来创建一个新的request并把它加入到volley内部封装的请求队列中，代码如下：

public abstract class AuthenticatedRequestBase<T> extends Request<T> {    private final static String TAG = "AuthenticatedRequestBase";    private static final int TIME_OUT = 30000;    private static final int MAX_RETRIES = 1;    private static final float BACKOFF_MULT = 2f;    protected Context mContext;    protected RequestQueue mRequestQueue;    /**
     * 创建新的请求，并把请求加入到请求队列requestQueue中
     *
     * @param method
     * @param url
     * @param cache
     * @param errorListener
     */
    @SuppressLint("LongLogTag")    public AuthenticatedRequestBase(int method, String url, boolean cache, Response.ErrorListener errorListener) {        super(method, url, errorListener);        //this.setShouldCache(cache);
        this.setRetryPolicy(new DefaultRetryPolicy(
                TIME_OUT,
                MAX_RETRIES,
                BACKOFF_MULT));

        mRequestQueue = YZ.getInstance().getRequestQueue();        if (mRequestQueue == null) {            throw new IllegalArgumentException("mRequestQueue can't be null");
        }

        mContext = YZ.getInstance().getContext();        if (mContext == null) {            throw new IllegalArgumentException("mContext can't be null");
        }        //如果重新发出服务器请求的时候，需要清除之前的缓存。
        if (!cache) {
            Cache volleyCache = mRequestQueue.getCache();
            Cache.Entry cacheEntry = volleyCache.get(url);            if (cacheEntry != null) {
                volleyCache.remove(url);
                Log.d(TAG, "remove volley cache:" + url);
            }
        }
        mRequestQueue.add(this);
    }    /**
     * 重写这个方法，可以在http请求头里面加入token，客户端能接受的数据类型
     *
     * @return
     * @throws AuthFailureError
     */
    @CallSuper
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        Map<String, String> headers = new HashMap<>();
        String token = "............";        //headers.put("Authorization", "bearer " + token);
        //针对Get方法，申明接受的enum类型
        // headers.put("Accept", "charset=utf-8");
        return headers;
    }    /**
     * 网络错误问题统一处理
     *
     * @param volleyError
     * @return
     */
    @CallSuper
    @Override
    protected VolleyError parseNetworkError(VolleyError volleyError) {        return super.parseNetworkError(volleyError);
    }
}

代码注释比较清晰，就不在赘述。
2.新建一个CommonRequest去继承这个基类，并出解析结果：

/**
 * Created by yz on 2019/2/2.
 */public class CommonRequest<TRequest, TResponse> extends AuthenticatedRequestBase<TResponse> {    private String TAG = this.getClass().getSimpleName();    private final static Gson gson = new Gson();    private final Response.Listener<TResponse> listener;    private final Class<TResponse> tResponseClazz;    private TRequest request;    private static final String PROTOCOL_CHARSET = "utf-8";    private boolean cacheHit;    private String mUrl;    private NetCallback<TResponse> cb;    /**
     * @param url
     * @param callback
     */
    public CommonRequest(String url, NetCallback<TResponse> callback) {        this(url, null, null, false, callback);
    }    /**
     * @param url
     * @param request
     * @param callback
     */
    public CommonRequest(String url, TRequest request, NetCallback<TResponse> callback) {        this(url, request, null, false, callback);
    }    /**
     * @param url
     * @param responseClass
     * @param cache
     * @param callback
     */
    public CommonRequest(String url, Class<TResponse> responseClass, boolean cache, NetCallback<TResponse> callback) {        this(url, null, responseClass, cache, callback);
    }    /**
     * @param url
     * @param request
     * @param responseClass
     * @param cache
     * @param callback
     */
    public CommonRequest(String url, TRequest request, Class<TResponse> responseClass, boolean cache, NetCallback<TResponse> callback) {        super(request == null ? Method.GET : Request.Method.POST, url, cache, callback.getErrorListener());        this.request = request;        this.tResponseClazz = responseClass;        this.mUrl = url;        this.listener = callback.getSuccessListener();        this.cb = callback;
    }    /**
     * get请求返回null，post请求返回byte【】
     *
     * @return
     */
    @Override
    public byte[] getBody() {        if (request == null) return null;

        String mRequestBody = gson.toJson(this.request);        try {            return mRequestBody == null ? null : mRequestBody.getBytes(PROTOCOL_CHARSET);
        } catch (UnsupportedEncodingException uee) {
            VolleyLog.wtf("Unsupported Encoding while trying to get the bytes of %s using %s",
                    mRequestBody, PROTOCOL_CHARSET);            return null;
        }
    }    /**
     * 这个是缓存的标记，与本地缓存相关，返回response时才会使用此标志
     *
     * @param tag
     */
    @Override
    public void addMarker(String tag) {        super.addMarker(tag);
        cacheHit = tag.equals("cache-hit");
    }    /**
     * clazz为空时，返回null
     *
     * @param response
     * @return
     */
    @Override
    protected Response<TResponse> parseNetworkResponse(NetworkResponse response) {        //无需返回数据
        if (tResponseClazz == null) {            return Response.success(null, parseCacheHeaders(response));
        }

        Gson gson = new Gson();        //无网络时，使用本地缓存,通过url去匹配缓存，volley sdk是通过url创建不同的文件来实现缓存的
        if (!NetUtils.isConnect(mContext) && mRequestQueue.getCache().get(mUrl) != null) {
            String json = new String(mRequestQueue.getCache().get(mUrl).data);
            Log.d(TAG, "url==" + mUrl + ",json" + json);
            cb.fResponseCacheStatus = ResponseCacheStatus.StaleFromCache;            return Response.success(gson.fromJson(json, tResponseClazz), parseCacheHeaders(response));
        }        //数据是否有更新
        try {            if (response.statusCode == 304) {                //服务端返回缓存数据
                cb.fResponseCacheStatus = ResponseCacheStatus.NotModifiedFromServer;
            } else if (response.statusCode == 200) {                if (cacheHit) {                    //使用本地缓存
                    cb.fResponseCacheStatus = ResponseCacheStatus.FreshFromCache;
                } else {                    //使用服务端更新数据
                    cb.fResponseCacheStatus = ResponseCacheStatus.NewFromServer;
                }
            } else {
                cb.fResponseCacheStatus = ResponseCacheStatus.NewFromServer;
            }

            Log.d(TAG, "fResponseCacheStatus = " + cb.fResponseCacheStatus);
            String json = new String(response.data, parseCharset(response.headers));            return Response.success(gson.fromJson(json, tResponseClazz), parseCacheHeaders(response));
        } catch (UnsupportedEncodingException | JsonSyntaxException e) {            return Response.error(new ParseError(e));
        }
    }    @Override
    protected void deliverResponse(TResponse response) {
        listener.onResponse(response);
    }

}

3.上面只做了返回成功的处理方式，返回失败时由NetCallback内部统一处理：

@UiThreadpublic abstract class NetCallback<TResponse> {    public ResponseCacheStatus fResponseCacheStatus = ResponseCacheStatus.NewFromServer;    private String TAG = this.getClass().getSimpleName();    public boolean enableAutomaticToastOnError = true;    public NetCallback() {
    }    public NetCallback(boolean enableAutomaticToastOnError) {        this.enableAutomaticToastOnError = enableAutomaticToastOnError;
    }    public abstract void OnSuccess(TResponse result);    public abstract void OnError(RestfulError error);    public void OnNetworkOff() {        //do nothing ,use it according to requirement
    }    public Response.Listener<TResponse> getSuccessListener() {        return new Response.Listener<TResponse>() {            @Override
            public void onResponse(TResponse result) {
                OnSuccess(result);
            }
        };
    }    public Response.ErrorListener getErrorListener() {        return new Response.ErrorListener() {            @Override
            public void onErrorResponse(VolleyError volleyError) {                if (volleyError instanceof TimeoutError) {
                    Log.e(TAG, "networkResponse == null");                    //volley TimeoutError
                    OnError(new RestfulError());
                }                if (volleyError.networkResponse != null) {                    int statusCode = volleyError.networkResponse.statusCode;
                    String errorMessage = new String(volleyError.networkResponse.data);                    switch (statusCode) {                        case 401:                            //post a Permission authentication failed event
                            break;                        default:
                            Log.d(TAG, "errorMessage =" + errorMessage);                            try {
                                RestfulError error = new Gson().fromJson(errorMessage, RestfulError.class);                                if (enableAutomaticToastOnError && error.getCode() != null) {                                    //toast(error.ExceptionMessage); //toast it in main thread
                                }
                                OnError(error);
                            } catch (Exception e) {
                                OnError(new RestfulError());
                                Log.d(TAG, "e =" + e.toString());
                            }                            break;
                    }
                }
            }
        };
    }
}

4.注意到没有，在AuthenticatedRequestBase内部有一个环境类YZ,主要负责获取项目主程序中的context和请求队列：

public class YZ implements AppRequestQueue {    private static final int DEFAULT_VOLLEY_CACHE_SIZE = 100 * 1024 * 1024;    private Context context;    private int cacheSize;    private YZ() {
    }    @Override
    public RequestQueue getRequestQueue() {        return Volley.newRequestQueue(context, cacheSize);
    }    public Context getContext() {        return context;
    }    private static class SingletonHolder {        private static YZ instance = new YZ();
    }    public static YZ getInstance() {        return SingletonHolder.instance;
    }    /**
     * need a app context
     *
     * @param appContext
     */
    public void init(final Context appContext) {
        init(appContext, DEFAULT_VOLLEY_CACHE_SIZE);
    }    /**
     * @param appContext
     * @param cacheSize
     */
    public void init(final Context appContext, final int cacheSize) {        this.context = appContext;        this.cacheSize = cacheSize;
    }
}

这个类需要在app的application中初始化：

public class BaseApp extends Application {    public String TAG = this.getClass().getSimpleName();    public static Context applicationContext;    public static Executor threadPool;    public static final int THREAD_POOL_SIZE = 3;    public static final boolean isDebug = BuildConfig.BUILD_TYPE.equals("debug");    @Override
    public void onCreate() {        super.onCreate();
        applicationContext = getApplicationContext();
        threadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

        initNet();
    }    private void initNet() {
        YZ.getInstance().init(this);
    }    public Context getInstance() {        return applicationContext;
    }

}

4.现在可以开始外部封装啦,测试了一下，get和post请求都可以成功。

public class NewsApi {

    public static void getInfo(NetCallback<News> callback) {        new CommonRequest<>(INetConstant.NEWS, News.class, true, callback);
    }    public static void postInfo(NetCallback<News> callback) {
        RequestBody body = new RequestBody("top", "b2f8e4aeacfa310cabfadd5189bbe4d5");        new CommonRequest<>(INetConstant.NEWS, body, News.class, true, callback);
    }    public static void cancelGetInfo() {        //how to do
    }
}

还有一点，volley的缓存实现需要服务端配合在http请求的Cache-control: max-age配置支持缓存，并设定好缓存时间，否则无法生效。

作者：一朵喇叭花呜拉呜拉
链接：https://www.jianshu.com/p/1f09e91bee66