Android 本地缓存开源库 Reservoir 替代SharedPreferences

一、Android SharedPreferences 简介

        众所周知，SharedPreferences是一种轻型的Android数据存储方式，它的本质是基于XML文件存储key-value键值对数据，通常用来存储一些简单的配置信息。它的存储位置是在/data/data/<包名>/shared_prefs目录下。SharedPreferences对象本身只能获取数据而不支持存储和修改，存储修改是通过Editor对象实现。比较经典的使用方式例如用户输入框对过往登录账户的存储。实现SharedPreferences存储的步骤如下：

1、根据Context获取SharedPreferences对象
2、利用edit()方法获取Editor对象。
3、通过Editor对象存储key-value键值对数据。
4、通过commit()或apply()方法提交数据。

commit和apply方法的区别：

1.apply没有返回值而commit返回boolean表明修改是否提交成功
2.apply是将修改数据原子提交到内存，而后异步真正提交到硬件磁盘；而commit是同步的提交到硬件磁盘，因此，在多个并发的提交commit的时候，他们会等待正在处理的commit保存到磁盘后在操作，从而降低了效率。而apply只是原子的提交到内容，后面有调用apply的函数的将会直接覆盖前面的内存数据，这样从一定程度上提高了很多效率。
3.apply方法不会提示任何失败的提示。

一般的话，建议使用apply，当然，如果是需要确保数据提交成功，且有后续操作的话，则需要用commit方法。

二、Reservoir 开源库的介绍

它的中文翻译是：蓄水池; 贮液器;储藏

顾名思义，它是一个用键值对存储数据的轻量级库，官方的文档介绍是：Android library to easily serialize and cache your objects to disk using key/value pairs.  规范地来说，它是一个易于序列化和缓存对象使用的键值对本地缓存库。关于SharedPreferences文章开头也有简单的描述了一下，而Reservoir可以更好的帮我们实现键值对存储数据，特别是序列化实体数据的本地缓存。

1.项目引入：

在项目build.gradle文件中配置以下代码，然后点击Sync按钮同步一下代码：

repositories {
    jcenter()
}

dependencies {
    compile 'com.anupcowkur:reservoir:3.1.0'
}

2.初始化：

在使用之前，需要初始化Reservoir ，初始化最好是在应用的Application中初始化，并设置缓存内存大小，官方写的例子是2048b， 的内存，太小了，应该改大一点。一般来说设置1-2M左右就够用了，具体大小视自己项目而定。

这里我是设置的1M：

try {
   Reservoir.init(this, 1024*1024); //in bytes 1M
} catch (Exception e) {
   //failure
}

如果想使用自己自定义的Gson 实例：

try {
   Reservoir.init(this, 2048, mGsonInstance);
} catch (Exception e) {
   //failure
}

3.Put数据，保存到本地缓存：

数据的保存有同步和异步两种方式，异步使用有两个回调方法，同步则没有。具体使用哪种方式视项目情况而定：

3.1 采取异步的方式：

//async put:
      List<String> sList = new ArrayList<String>();

      sList.add("one");
      sList.add("two");
      sList.add("three");
      Reservoir.putAsync("mKey", sList, new ReservoirPutCallback() {
         @Override
         public void onSuccess() {
            //success
         }

         @Override
         public void onFailure(Exception e) {
            //error
         }
      });

3.2 采取同步的方式：

//Put a simple object
      try {
         Reservoir.put("mKey", mObject);
      } catch (Exception e) {
         //failure;
      }

4.读取缓存的键值对数据：

4.1 采取异步的方式：

//Get data
      Type resultType = new TypeToken<List<String>>() {}.getType();
      Reservoir.getAsync("myKey", resultType, new ReservoirGetCallback<List<String>>() {
         @Override
         public void onSuccess(List<String> strings) {
            //success
         }

         @Override
         public void onFailure(Exception e) {
            //error
         }
      });

4.2 采取同步的方式：

//Get data
      Type resultType = new TypeToken<List<String>>() {}.getType();
      try {
         Reservoir.get("myKey", resultType);
      }
      catch (Exception e) {
         //failure}
      }

4.3 检查键值是否存在

当你想要检查某一个键值对是否存在时，可用以下代码实现：

try {
   boolean objectExists = Reservoir.contains("mKey");
} catch (Exception e) {
}

5.删除缓存的键值对数据：

Async delete （异步）：

Reservoir.deleteAsync("mKey", new ReservoirDeleteCallback() {  
   @Override   
   public void onSuccess(MyClass myObject) {  
   //success   
   }    
   @Override   
   public void onFailure(Exception e) { 
      //error   
   }});

synchronous delete（同步）

try {  
   Reservoir.delete("mKey");
} catch (Exception e) {    
   //failure
}

5.清除缓存的Reservoir 数据：

Async clear（异步）：

Reservoir.clearAsync(new ReservoirClearCallback() {    
   @Override    
   public void onSuccess() {
      try {
         assertEquals(0, Reservoir.bytesUsed());      
      } catch (Exception e) {
      }    
   }    
   @Override    
   public void onFailure(Exception e) {
      
   }
});

sync clear（同步）：

try {
   Reservoir.clear();
} catch (Exception e) {
   //failure
}

RxJava下使用：

Put :

//Put a simple object
      Reservoir.putUsingObservable("myKey", myObject) returns Observable<Boolean>

//Put collection
            List<String> strings = new ArrayList<String>();
      strings.add("one");
      strings.add("two");
      strings.add("three");
      Reservoir.putUsingObservable("myKey", strings) returns Observable<Boolean>

Get:

//Get a simple object
      Reservoir.getUsingObservable("myKey", MyClass.class) returns Observable<MyClass>

//Get collection
            
      Type collectionType = new TypeToken<List<String>>() {}.getType();
      Reservoir.getUsingObservable("myKey", String.class, collectionType) returns Observable<String>

Delete:

Reservoir.deleteUsingObservable("myKey") returns Observable<Boolean>

Clear:

Reservoir.clearUsingObservable() returns Observable<Boolean>

Reservoir项目GitHub地址：   https://github.com/anupcowkur/Reservoir