基于Android RxCache使用方法详解

RxCache is a reactive caching library for Android and Java which turns your caching needs into an interface.
RxCache是一个用于Android和Java的响应式缓存库，它可将您的缓存需求转换为一个接口。

allprojects {
  repositories {
    jcenter()
    maven { url "https://jitpack.io" }
  }
}

dependencies {
  compile "com.github.VictorAlbertos.RxCache:runtime:1.8.1-2.x"
  compile "io.reactivex.rxjava2:rxjava:2.0.6"
  //我们再添加这个依赖，下面有说明
  compile 'com.github.VictorAlbertos.Jolyglot:gson:0.0.3'
}

dependencies {
  // To use Gson 
  compile 'com.github.VictorAlbertos.Jolyglot:gson:0.0.3'
  // To use Jackson
  compile 'com.github.VictorAlbertos.Jolyglot:jackson:0.0.3'
  // To use Moshi
  compile 'com.github.VictorAlbertos.Jolyglot:moshi:0.0.3'
}

public interface GitHubService {
  @GET("users/{user}")
  Observable<User> getRxUser(@Path("user") String user);
}

public class GitHubServiceManager {
  private GitHubService service;
  public GitHubServiceManager() {
    init();
  }
  private void init() {
    HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor()
        .setLevel(HttpLoggingInterceptor.Level.BODY);
    OkHttpClient client = new OkHttpClient()
        .newBuilder()
        .addInterceptor(interceptor)
        .build();
    service = new Retrofit.Builder()
        .baseUrl("https://api.github.com/")
        .addConverterFactory(GsonConverterFactory.create())
        .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
        .client(client)
        .build()
        .create(GitHubService.class);
  }
  public Observable<User> getUser(String user){
    return service.getRxUser(user);
  }
}

@Data  //lombok插件的注解，自动生成get、set方法
public class User {
 public String login;
 public String name;
}

 new GitHubServiceManager()
        .getUser(userName)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(user1 -> Toast.makeText(this, user1.toString(), Toast.LENGTH_SHORT).show());

public interface UserCacheProviders {
  /**
   * LifeCache设置缓存过期时间. 如果没有设置@LifeCache , 数据将被永久缓存理除非你使用了 EvictProvider,EvictDynamicKey or EvictDynamicKeyGroup .
   * @param user
   * @param userName 驱逐与一个特定的键使用EvictDynamicKey相关的数据。比如分页，排序或筛选要求
   * @param evictDynamicKey  可以明确地清理指定的数据 DynamicKey.
   * @return
   */
  @LifeCache(duration = 1,timeUnit = TimeUnit.MINUTES)
  Observable<User> getUser(Observable<User> user, DynamicKey userName, EvictDynamicKey evictDynamicKey);
}

@param user：这是个Observable类型的对象，简单来说，这就是你将要缓存的数据对象。
@param userName:DynamicKey类型，顾名思义，就是一个动态的key，我们以它作为tag，将数据存储到对应名字的File中
@param evictDynamicKey 可以明确地清理指定的数据 ，很简单，如果我们该参数传入为true，那么RxCache就会驱逐对应的缓存数据直接进行网络的新一次请求（即使缓存没有过期）。如果传入为false，说明不驱逐缓存数据，如果缓存数据没有过期，那么就不请求网络，直接读取缓存数据返回。
@return 可以看到，该接口方法中，返回值为Observable,泛型为user，这个Observable的对象user和参数中传进来的Observable的对象user有什么区别呢？ 
― 很简单，返回值Observable中的数据为经过缓存处理的数据。

public class CacheProviders {
  private static UserCacheProviders userCacheProviders;
  public synchronized static UserCacheProviders getUserCache() {
    if (userCacheProviders == null) {
      userCacheProviders = new RxCache.Builder()
          .persistence(BaseApplication.getApplication().getExternalCacheDir(), new GsonSpeaker())//缓存文件的配置、数据的解析配置
          .using(UserCacheProviders.class);//这些配置对应的缓存接口
    }
    return userCacheProviders;
  }
}

 private void requestHttp(String userName) {
     //网络请求数据
    Observable<User> user = new GitHubServiceManager()
        .getUser(userName);
    //缓存配置    
    CacheProviders.getUserCache()
        .getUser(user, new DynamicKey(userName), new EvictDynamicKey(false))//用户名作为动态key生成不同文件存储数据，默认不清除缓存数据
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(user1 -> Toast.makeText(this, user1.toString(), Toast.LENGTH_SHORT).show());
}