Okhttp和Picasso配合使用外加ACache实现缓存

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Jiang_Rong_Tao/article/details/51516977

app开发对于网络请求是整个项目的一大块，对于新开的项目的新需求我也打算换一套框架试试。以前用的google官方的volley，现在想试一下其他的。volley确实很方便，但是对https这块需要我们手动改volley源码。所以果断选择okhttp，为了更长远的打算。
Okhttp和Picasso采用了同样的设计模式— 建造者模式【Builder Pattern】 ，详见http://blog.csdn.net/ysq5202121/article/details/7407350 通过链式编程，一行代码实现所有操作，精简明了。

准备工作：

    compile 'com.zhy:okhttputils:2.5.1'
    compile 'com.squareup.picasso:picasso:2.5.2'

对Okhttp简单是二次封装：

public class RequestManager {
    private static  RequestManager reqManager;

    public static RequestManager getInstance(Context context) {
        if (reqManager == null) {
            synchronized (RequestManager.class) {
                if (reqManager == null) {
                    reqManager = new RequestManager();
                    return reqManager;
                }
            }
        }
       return null;
    }

    /**
     * 基本的post请求
     * @param url
     * @param params
     * @param clazz
     * @param callback
     * @param <T>
     */
    public static <T> void sendPost(String url, Map<String, String> params, final Class<T> clazz, Callback<T> callback){

          OkHttpUtils
                  .post()
                  .url(url)
                  .headers(initHeader(params))
                  .params(params)
                  .build()
                  .execute(callback);
      }


    /**
     * 基本的文件上传
     * @param url
     * @param file
     * @param callback
     */
    public static void uploadFile(String url, File file,Callback callback){
        OkHttpUtils
                .postFile()
                .url(url)
                .file(file)
                .build()
                .execute(callback);
    }
}

Picasso的简单使用：

/**
 * Created by rongtao on 2016/5/26.
 * 二次封装picasso实现网络图片的加载
 */
public class APIImageLoader {
    /**
     * 显示网络图片
     * @param context
     * @param url  图片路径
     * @param defResValue 默认占位图片
     * @param errorValue  错误占位图片
     * @param imageView  显示控件
     */
     public static void displayImage(Context context, String url, int defResValue, int errorValue , ImageView imageView){
         Picasso.with(context)
                 .load(url)
                 .placeholder(defResValue)
                 .error(errorValue)
                 .into(imageView);
     }
}

Acache本地缓存处理：
Acache下载https://yunpan.cn/cRHRXCfhWR9mY 访问密码 6d6a

下面的这个二次封装的类来自我的朋友百度大牛–Mr.Zhao

/**
 * Created by zhaokai on 2016-05-15
 * @e-mail [email protected]
 *
 * 数据储存
 * 用于页面跳转大数据 或者复杂数据的 转接
 * 用于缓存数据到本地
 * 用于存储程序运行时常用数据
 *
 * 存储
 * DataCache.setToCache("123",456);
 * ModelUser user = new ModelUser();
 * user.setName("haha");
 * DataCache.setToCache("ev",user);
 *
 * 获取
 * Integer i = DataCache.getFromCache(123+"",Integer.class);
 * ModelUser user = (DataCache.getFromCache("ev",ModelUser.class));
 *
 */
public class DataCache {

    /**
     * App 运行长久缓存
     */
    private static HashMap<String,Object> cacheLong = new HashMap<>();
    private File cacheFile;


    /**
     * App运行临时缓存
     */
    private final LruCache<String, Object> cache;
    private DataCache() {
        cache = new LruCache<>(50);
        cacheFile = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "dir"+File.separator+"cache");
        if (!cacheFile.exists()) {
            cacheFile.mkdirs();
        }
    }

    private static DataCache dataCache ;

    private static DataCache getInstance() {
        if (dataCache == null){

            dataCache = new DataCache();
        }
        return dataCache;
    }

    /**
     * 从数据缓存中获取 此数据不会自动清空
     * @param key       数据索引
     * @param clazz     类文件
     * @return          需要的类
     */
    public static <T> T getFromStore(String key,Class<T> clazz){
        return getInstance().getFromStoreIml(key,clazz);
    }

    private <T> T getFromStoreIml(String key, Class<T> clazz) {

        Object obj = null;
        if(cacheLong!=null){
            obj = cacheLong.get(key);
        }

//        LogUtil.e("DataCache",obj.getClass().getSimpleName());
//        LogUtil.e("DataCache",clazz.getSimpleName());

        if(obj!=null&&clazz.getSimpleName().equals(obj.getClass().getSimpleName())){
            return (T)obj;
        }
        return null;
    }


    /**
     * 移除临时缓存
     * @param key
     */
    public static void removeFromCache(String key) {
        getInstance().removeFromCacheImp(key);
    }

    private void removeFromCacheImp(String key) {
        cache.remove(key);
    }

    /**
     * App 运行期间缓存数据
     * @param key           数据索引
     * @param value         数据值
     * @return              同一key 值的其他索引
     *
     */
    public static <V> V setToStore(String key,V value){
        return getInstance().setToStoreIml(key,value);
    }

    private <V> V setToStoreIml(String key, V value) {
        Object obj = null;
        if(cacheLong!=null){
            obj = cacheLong.put(key,value);
        }
        return obj==null||!obj.getClass().getSimpleName().equals(value.getClass().getSimpleName())?null: ((V) obj);
    }

    /**
     * 从长久缓存中移除 数据
     * @param key       数据的key 值
     * @return          是否存在并移除
     */
    public static boolean removeFromStore(String key){
        Object obj = cacheLong.remove(key);
        return obj==null;
    }

    /**
     * 清空长久缓存
     */
    public static void clearLongCache(){
        getInstance().clearLongCacheIml();
    }

    private void clearLongCacheIml() {
        cacheLong.clear();
    }

    /**
     * 清空短期缓存
     */
    public static void clearCache(){
        getInstance().clearCacheIml();
    }

    private void clearCacheIml() {
        cache.evictAll();
    }


    /**
     * 从缓存中获取数据
     * @param key 要获取数据的key值
     *
     * @return 返回数据
     */
    public static <T> T getFromCache(String key,Class<T> clazz) {

        return getInstance().getFromCacheIml(key,clazz);
    }

    public static String getString(String key){
        return getInstance().getFromCacheIml(key,String.class);
    }

    public <T> T getFromCacheIml(String key,Class<T> T) {

        T obj ;
        if(key !=null){
            try {
                obj = ((T) cache.get(key));
                return obj;
            }catch (Exception e){
                Log.e("DataCache",e.toString());
            }
        }
        return null;
    }

    /**
     * 存储键值对到缓存
     * @param key       获取数据的key值
     * @param value     存储的值
     *
     * @return          之前存放的值
     */
    public static <V> V setToCache(String key,V value){
        return getInstance().setToCacheIml(key,value);
    }

    public static String setString(String key,String value){
        return getInstance().setToCacheIml(key,value);
    }
    public <V> V setToCacheIml(String key,V value) {
        if (key == null || value == null) {
            throw new NullPointerException("key == null || value == null");
        }
        try {
            Object obj = cache.put(key,value);
            return obj==null||!obj.getClass().getSimpleName().equals(value.getClass().getSimpleName())?null: ((V) obj);
        }catch (Exception e){
            Log.e("DataCache",e.toString());
        }
        return null;
    }


    /**
     * 保存JSON 到本地
     * @param key       文件索引
     * @param json      JSON数据
     */
    public static void saveToLocal(String key,String json){
        getInstance().saveToLocalImp(key,json,dataCache.cacheFile);
    }

    /**
     * 保存JSON 到本地
     * @param key       文件索引
     * @param json      JSON数据
     * @param cacheFile 缓存目录
     */
    public static void saveToLocal(String key, String json, File cacheFile) {
        getInstance().saveToLocalImp(key,json,cacheFile);
    }

    private void saveToLocalImp(String key, String json, File cacheFile){
        ACache aCache = ACache.get(cacheFile);
        aCache.put(key,json);
    }

    /**
     * 从本地获取缓存数据
     * @param key       文件索引
     * @param cacheFile 缓存目录
     * @return          缓存数据
     */
    public static String getFromLocal(String key, File cacheFile){
        return getInstance().getFromLocalImp(key,cacheFile);
    }
    /**
     * 从本地获取缓存数据
     * @param key       文件索引
     * @return          缓存数据
     */
    public static String getFromLocal(String key){
        return getInstance().getFromLocalImp(key,dataCache.cacheFile);
    }
    private String getFromLocalImp(String key, File cacheFile){
        ACache aCache = ACache.get(cacheFile);
        return aCache.getAsString(key);
    }



    /**
     * 缓存其他类型的数据到本地
     * @param key       索引
     * @param value     继承自Serializabe的module
     */
    public static <V extends Serializable> void saveToLocal(String key, V value){
        getInstance().saveToLocalImp(key,value);
    }
    public <V extends Serializable> void saveToLocalImp(String key, V value){
        ACache aCache = ACache.get(cacheFile);
        aCache.put(key,value);
    }

    /**
     * 缓存其他类型的数据到本地
     * @param key       索引
     */
    public static <T extends Serializable> T getFromLocal(String key,Class<T> clazz){
        return getInstance().getFromLocalImp(key,clazz);
    }
    public <T extends Serializable> T getFromLocalImp(String key,Class<T> clazz){
        ACache aCache = ACache.get(cacheFile);
        Object obj;
        obj = aCache.getAsObject(key);
        Log.e("DataCache","clazz = "+clazz.getSimpleName());
        if(obj !=null&&clazz.getSimpleName().equals(obj.getClass().getSimpleName())){
            try {
                return ((T) obj);
            }catch (Exception e){
                Log.e("DataCache","Exception = "+e.toString());
            }
        }
        return null;
    }
}

这个三个类在网络请求这一块基本可以独挡一面了。

Okhttp想扒的更多可以去看鸿洋大神的github:
https://github.com/hongyangAndroid/okhttp-utils
Picasso可以去它的官网：
http://square.github.io/picasso/

这也就是我这一周的收货吧，分享给大家。

不会敲代码没关系，要懂得粘代码（CV大法，开发必备）。