retrofit2.0增加先读缓存后请求网络的功能

由于前段时间升级了retrofit版本到了2.1，导致原来写的缓存框架出现了点问题，后来在github上看到一个smartCache缓存框架

而其版本是2.0beta版和正式版有点差距，于是就自己更改了一下框架代码，现在分享给大家

项目只有6个类

AndroidExecutor：线程池里面封装了一个handler为了post数据到主线程种

CachingSystem：接口里面就两方法存缓存以及获取缓存

BasicCaching:CachingSystem对应的实现类，实现了存取缓存方法，使用的是LruCache以及DiskLruCache算法对其进行缓存

SmartCall:自定义的一个回调接口，要使用这个框架就必须使用这个回调而不是retrofit对应的Call

SmartUtils:工具类，主要是用来把网络数据转化成byte数据，数据转成byte

SmartCallFactory:关键类，所有的逻辑都在里面

主要讲解一下SmartCallFactory这个类

public class SmartCallFactory extends CallAdapter.Factory {    //缓存类    private final CachingSystem cachingSystem;    //线程池    private final Executor asyncExecutor;    public SmartCallFactory(CachingSystem cachingSystem){        this.cachingSystem = cachingSystem;        this.asyncExecutor = new AndroidExecutor();    }    public SmartCallFactory(CachingSystem cachingSystem, Executor executor){        this.cachingSystem = cachingSystem;        this.asyncExecutor = executor;    }    @Override    public CallAdapter<SmartCall<?>> get(final Type returnType, final Annotation[] annotations,                                         final Retrofit retrofit) {        TypeToken<?> token = TypeToken.of(returnType);        //如果不是对应的SmartCall则不会执行        if (token.getRawType() != SmartCall.class) {            return null;        }        if (!(returnType instanceof ParameterizedType)) {            //必须有实体类            throw new IllegalStateException(                    "SmartCall must have generic type (e.g., SmartCall<ResponseBody>)");        }        //获得SmartCall<T>中的类型        final Type responseType = ((ParameterizedType) returnType).getActualTypeArguments()[0];        final Executor callbackExecutor = asyncExecutor;        return new CallAdapter<SmartCall<?>>() {            @Override            public Type responseType() {                return responseType;            }            @Override            public <R> SmartCall<R> adapt(Call<R> call) {                return new SmartCallImpl<>(callbackExecutor, call, responseType(), annotations,                        retrofit, cachingSystem);            }        };    }    /**     * 自定义一个回调实例     * 所有的逻辑都是在这里面     * @param <T>     */    static class SmartCallImpl<T> implements SmartCall<T>{        private final Executor callbackExecutor;        private final Call<T> baseCall;        private final Type responseType;        private final Annotation[] annotations;        private final Retrofit retrofit;        private final CachingSystem cachingSystem;        private final Request request;        public SmartCallImpl(Executor callbackExecutor, Call<T> baseCall, Type responseType,                             Annotation[] annotations, Retrofit retrofit, CachingSystem cachingSystem){            this.callbackExecutor = callbackExecutor;            this.baseCall = baseCall;            this.responseType = responseType;            this.annotations = annotations;            this.retrofit = retrofit;            this.cachingSystem = cachingSystem;            // This one is a hack but should create a valid Response (which can later be cloned)            this.request = buildRequestFromCall();        }        /***         * 构建一个新的请求         * 这里使用的反射机制         * * @return A valid Request (that contains query parameters, right method and endpoint)         */        private Request buildRequestFromCall(){            try {                Field argsField = baseCall.getClass().getDeclaredField("args");                argsField.setAccessible(true);                Object[] args = (Object[]) argsField.get(baseCall);                //retrofit2.0更改了字段(1.0+)requestFactory-->(2.0+)serviceMethod                Field serviceMethodField = baseCall.getClass().getDeclaredField("serviceMethod");                serviceMethodField.setAccessible(true);                Object requestFactory = serviceMethodField.get(baseCall);                //retrofit2.0更改了方法(1.0+)create-->(2.0+)toRequest                Method createMethod = requestFactory.getClass().getDeclaredMethod("toRequest", Object[].class);                createMethod.setAccessible(true);                return (Request) createMethod.invoke(requestFactory, new Object[]{args});            }catch(Exception exc){//                Log.e("buildRequestFromCall"+exc.toString());                return null;            }        }        public void enqueueWithCache(final Callback<T> callback) {            Runnable enqueueRunnable = new Runnable() {                @Override                public void run() {                    /* 读取缓存 */                    byte[] data = cachingSystem.getFromCache(buildRequest());                    if(data != null) {                        //获得缓存数据                        final T convertedData = SmartUtils.bytesToResponse(retrofit, responseType, annotations,                                data);                        Runnable cacheCallbackRunnable = new Runnable() {                            @Override                            public void run() {                                //存在数据直接回调给调用者,                                callback.onResponse(baseCall, Response.success(convertedData));                            }                        };                        callbackExecutor.execute(cacheCallbackRunnable);                    }                    /* 运行网络请求 */                    baseCall.enqueue(new Callback<T>() {                        @Override                        public void onResponse(final Call<T> call,final Response<T> response) {                            Runnable responseRunnable = new Runnable() {                                @Override                                public void run() {                                    if (response.isSuccessful()) {                                        //保存数据                                        byte[] rawData = SmartUtils.responseToBytes(retrofit, response.body(),                                                responseType(), annotations);                                        cachingSystem.addInCache(response, rawData);                                    }                                    //再一次回调给调用者                                    callback.onResponse(call, response);                                }                            };                            // Run it on the proper thread                            callbackExecutor.execute(responseRunnable);                        }                        @Override                        public void onFailure(final Call<T> call, final Throwable t) {                            Runnable failureRunnable = new Runnable() {                                @Override                                public void run() {                                    callback.onFailure(call,t);                                }                            };                            callbackExecutor.execute(failureRunnable);                        }                    });                }            };            Thread enqueueThread = new Thread(enqueueRunnable);            enqueueThread.start();        }        @Override        public void enqueue(final Callback<T> callback) {            if(buildRequest().method().equals("GET")){                //只对GET请求有用                enqueueWithCache(callback);            }else{                //其他的请求和retrofit一样                baseCall.enqueue(new Callback<T>() {                    @Override                    public void onResponse(final Call<T> call, final Response<T> response) {                        callbackExecutor.execute(new Runnable() {                            @Override                            public void run() {                                callback.onResponse(call,response);                            }                        });                    }                    @Override                    public void onFailure(final Call<T> call, final Throwable t) {                        callbackExecutor.execute(new Runnable() {                            @Override                            public void run() {                                callback.onFailure(call,t);                            }                        });                    }                });            }        }        @Override        public Type responseType() {            return responseType;        }        @Override        public Request buildRequest() {            return request.newBuilder().build();        }        @Override        public SmartCall<T> clone() {            return new SmartCallImpl<>(callbackExecutor, baseCall.clone(), responseType(),                    annotations, retrofit, cachingSystem);        }        @Override        public Response<T> execute() throws IOException {            return baseCall.execute();        }        @Override        public void cancel() {            baseCall.cancel();        }    }}

里面的我加入详细注释，应该很容易看懂

主要就是在自定义的SmartCallFactory的call实例中自己改写了请求回调的方式，先看缓存中是否有数据，

有直接回调给调用者，请求数据成功后也会回调给调用者，而对应的使用方法为

Retrofit client = new Retrofit.Builder()        .baseUrl(HOST)        .client(okHttpClient)        .addConverterFactory(GsonConverterFactory.create(gson))        .addCallAdapterFactory(smartFactory)        .addCallAdapterFactory(RxJavaCallAdapterFactory.create())        .build();mGuDong = client.create(MeoHttp.class);

构建retrofit时应增加一个自定义的CallAdapterFactory

接口调用则为

/** * 获得图片列表 */@GET("tnfs/api/list")SmartCall<ImageListBean> getImageList();

使用自定义的SmartCall

其他的使用方法和retrofit一致

demo地址：github记得star给星，如若有问题请留言或者在github上提issue