RxCache源码解析

RxCache

是使用注解为Retrofit加入二级缓存(内存,磁盘)的缓存库。 开头膜拜大神
项目地址 : RxCache

本文最先发表于简书RxCache源码解析

RxCache使用方法

定义接口

public interface CacheProviders {

    @LifeCache(duration = 2, timeUnit = TimeUnit.MINUTES)
    Observable<Reply<List<Repo>>> getRepos(Observable<List<Repo>> oRepos, DynamicKey userName, EvictDynamicKey evictDynamicKey);

    @LifeCache(duration = 2, timeUnit = TimeUnit.MINUTES)
    Observable<Reply<List<User>>> getUsers(Observable<List<User>> oUsers, DynamicKey idLastUserQueried, EvictProvider evictProvider);

    Observable<Reply<User>> getCurrentUser(Observable<User> oUser, EvictProvider evictProvider);
}

十分简洁，使用了注解@LifeCache声明了缓存的超时时间（duration长度,timeUnit时间单位），接口定义了之后，如何实例化这个接口，看下面。

创建CacheProviders对象

providers = new RxCache.Builder()
                .persistence(cacheDir, new GsonSpeaker())
                .using(Providers.class);

之后的使用和Retrofit无异

实例化的过程是比较常见的Builder模式，和Retrofit的API的实例化的方式很像，调用using()就创建了接口的实例，和Retrofit的create()方法也十分相似，当然内部实现也很相似（都是使用了动态代理）。

RxCache源码分析

using() 方法创建CacheProviders接口实例的过程

public <T> T using(final Class<T> classProviders) {
    proxyProviders = new ProxyProviders(builder, classProviders);

    return (T) Proxy.newProxyInstance(
        classProviders.getClassLoader(),
        new Class<?>[] {classProviders},
        proxyProviders);
  }

创建接口的实例使用的是动态代理技术

简而言之，就是动态生成接口的实现类（当然生成实现类有缓存机制），并创建其实例（称之为代理），代理把对接口的调用转发给 InvocationHandler实例，而在 InvocationHandler的实现中，除了执行真正的逻辑（例如再次转发给真正的实现类对象），我们还可以进行一些有用的操作，例如统计执行时间、进行初始化和清理、对接口调用进行检查等。

为什么要用动态代理？ 因为对接口的所有方法的调用都会集中转发到 InvocationHandler#invoke函数中，我们可以集中进行处理，更方便了。你可能会想，我也可以手写这样的代理类，把所有接口的调用都转发到InvocationHandler#invoke呀，当然可以，但是可靠地自动生成岂不更方便？

在RxCache 1.5.2版本中,上述ProxyProviders对象的创建方法不是简单的new,而是使用了依赖注入框架dagger,dagger在后面的还有使用,这里只是提一下。

在这里ProxyProviders实现了InvocationHandler,所以代理把对接口的调用转发给了ProxyProviders#invoke,所以我们就看下invoke()方法。

@Override public Object invoke(final Object proxy, final Method method, final Object[] args)
      throws Throwable {
    return Observable.defer(new Func0<Observable<Object>>() {
      @Override public Observable<Object> call() {
        return processorProviders.process(proxyTranslator.processMethod(method, args));
      }
    });

method包含了调用方法的基本信息（注解,返回值类型等）,args是方法的参数列表。

 ConfigProvider processMethod(Method method, Object[] objectsMethod) {
    ConfigProvider prev = loadConfigProviderMethod(method);

    ConfigProvider configProvider = new ConfigProvider(prev.getProviderKey(),
        null, prev.getLifeTimeMillis(), prev.requiredDetailedResponse(), prev.isExpirable(),
        prev.isEncrypted(), getDynamicKey(method, objectsMethod),
        getDynamicKeyGroup(method, objectsMethod),
        getLoaderObservable(method, objectsMethod),
        evictProvider(method, objectsMethod));

    return configProvider;
  }

ConfigProvider是一个包装类，里面包装了该方法本身的属性(名称,相关注解,超时时间之类的)以及方法的调用参数,。

ProxyTranslator#processMethod这个方法先通过ProxyTranslator#loadConfigProviderMethodload出了一个ConfigProvider对象,这个load方法是先从map
中读缓存,没有缓存再新创建实例（下面的configProviderMethodCache是一个HashMap）,这里也和Retrofit中的请求方法的缓存方式一样。

private ConfigProvider loadConfigProviderMethod(Method method) {
    ConfigProvider result;
    synchronized (configProviderMethodCache) {
      result = configProviderMethodCache.get(method);
      if (result == null) {
        result = new ConfigProvider(getProviderKey(method),
            null, getLifeTimeCache(method),
            requiredDetailResponse(method), getExpirable(method), isEncrypted(method),
            null, null, null, null);
        configProviderMethodCache.put(method, result);
      }
    }
    return result;
  }

再ProxyTranslator中提供了很多的get()方法,这些get方法可以分为两种,一种是只需要传入一个参数method,另一种需要传入两个参数method和objectsMethod。这里以ProxyTranslator#getLifeTimeCache（一个参数）,ProxyTranslator#getDynamicKey（两个参数）为例。

private Long getLifeTimeCache(Method method) {
    LifeCache lifeCache = method.getAnnotation(LifeCache.class);
    if (lifeCache == null) return null;
    return lifeCache.timeUnit().toMillis(lifeCache.duration());
  }

一个参数的很简单，将注解中的超时时间读取出来并换算为毫秒,其他的get()方法也相同,都是为了从注解中取出信息。

private String getDynamicKey(Method method, Object[] objectsMethod) {
    DynamicKey dynamicKey = getObjectFromMethodParam(method, DynamicKey.class, objectsMethod);
    if (dynamicKey != null) return dynamicKey.getDynamicKey().toString();

    DynamicKeyGroup dynamicKeyGroup =
        getObjectFromMethodParam(method, DynamicKeyGroup.class, objectsMethod);
    if (dynamicKeyGroup != null) return dynamicKeyGroup.getDynamicKey().toString();

    return "";
  }

两个参数的也不复杂，比较重要的是ProxyTranslator#getObjectFromMethodParam,这个方法传入三个参数method,Class对象(从参数数组中取出参数的类型),objectsMethod(参数数组)

 private <T> T getObjectFromMethodParam(Method method, Class<T> expectedClass,
      Object[] objectsMethod) {
    int countSameObjectsType = 0;
    T expectedObject = null;

    for (Object objectParam : objectsMethod) {
      if (expectedClass.isAssignableFrom(objectParam.getClass())) {
        expectedObject = (T) objectParam;
        countSameObjectsType++;
      }
    }

    if (countSameObjectsType > 1) {
      String errorMessage =
          method.getName() + Locale.JUST_ONE_INSTANCE + expectedObject.getClass().getSimpleName();
      throw new IllegalArgumentException(errorMessage);
    }

    return expectedObject;
  }

通过代码可以知道,传入Class对象是为了通过遍历取出和你期待的参数类型相同的参数（注意这个isAssignableFrom方法，是用来判断一个类和另一个类是否相同或是另一个类的超类或接口，注意countSameObjectsType这个整形,就是为了根据作者的本意的约定，防止有继承相同父类或者实现相同接口的参数类型出现）并返回,至此,两个参数的get()方法意图也很明显根据类型取出从外部调用时的参数对象

从上面分析看来ProxyTranslator#processMethod的过程就是对一次动态代理的invoke()过程的再封装,返回的是方法调用的信息的集合（包括方法的参数，注解包含的信息，返回值等）,接下来又回到了动态代理中真正的InvocationHandler实现类ProxyProviders中,继续看真正的invoke()方法

@Override public Object invoke(final Object proxy, final Method method, final Object[] args)
      throws Throwable {
    return Observable.defer(new Func0<Observable<Object>>() {
      @Override public Observable<Object> call() {
        return processorProviders.process(proxyTranslator.processMethod(method, args));
      }
    });

又粘贴了下上面的代码哈,这次是ProcessorProviders#process,这个ProcessorProviders点进去看是一个接口,那么真正的实现类呢?

processorProviders = DaggerRxCacheComponent.builder()
        .rxCacheModule(new RxCacheModule(builder.getCacheDirectory(),
            builder.useExpiredDataIfLoaderNotAvailable(),
            builder.getMaxMBPersistenceCache(), getEncryptKey(providersClass),
            getMigrations(providersClass), builder.getJolyglot()))
        .build().providers();

实例化ProcessorProviders的过程在ProxyProviders的构造函数里。使用了依赖注入框架dagger,本文对dagger的用法不做介绍。点进RxCacheModule#provideProcessorProviders里面返回值类型是ProcessorProvidersBehaviour,它正是ProcessorProviders的实现类。我们主要关心ProcessorProviders#process这个方法。

@Override
  public <T> Observable<T> process(final ConfigProvider configProvider) {
    return (Observable<T>) Observable.defer(new Func0<Observable<Object>>() {
      @Override public Observable<Object> call() {
        if (hasProcessesEnded) {
          return getData(configProvider);
        }

        return oProcesses.flatMap(new Func1<Void, Observable<?>>() {
          @Override public Observable<?> call(Void aVoid) {
            return getData(configProvider);
          }
        });
      }
    });
  }

而这个方法主要定位到getData()再由这个方法继续定位下去是TwoLayersCache#retrieve,方法返回值类型为Record而且被Observable#just发射

<T> Observable<T> getData(final ConfigProvider configProvider) {
    return (Observable<T>) Observable.just(
        twoLayersCache.retrieve(configProvider.getProviderKey(), configProvider.getDynamicKey(),
            configProvider.getDynamicKeyGroup(), useExpiredDataIfLoaderNotAvailable,
            configProvider.getLifeTimeMillis(), configProvider.isEncrypted()))
        .map(new Func1<Record, Observable<Reply>>() {
          @Override public Observable<Reply> call(final Record record) {
            if (record != null && !configProvider.evictProvider().evict()) {
              return Observable.just(
                  new Reply(record.getData(), record.getSource(), configProvider.isEncrypted()));
            }

            return getDataFromLoader(configProvider, record);
          }
        }).flatMap(new Func1<Observable<Reply>, Observable<Object>>() {
          @Override
          public Observable<Object> call(Observable<Reply> responseObservable) {
            return responseObservable.map(new Func1<Reply, Object>() {
              @Override
              public Object call(Reply reply) {
                return getReturnType(configProvider, reply);
              }
            });
          }
        });

TwoLayersCache#retrieve接收configProvider传过来的各种参数,直接将参数return到方法RetrieveRecord#retrieveRecord
这个方法也是读取缓存的真正逻辑所在,读取的结果以Record类型返回,RxCache还支持类似于Spring的@CacheEvict按key清除缓存功能,看代码和注释。

<T> Record<T> retrieveRecord(String providerKey, String dynamicKey, String dynamicKeyGroup,
      boolean useExpiredDataIfLoaderNotAvailable, Long lifeTime, boolean isEncrypted) {
    String composedKey = composeKey(providerKey, dynamicKey, dynamicKeyGroup);
    //根据key从内存中读数据
    Record<T> record = memory.getIfPresent(composedKey);

    if (record != null) {
      //内存不为空,将source标记为内存
      record.setSource(Source.MEMORY);
    } else {
      try {
        //为空就从磁盘读取,将source标记为磁盘
        record = persistence.retrieveRecord(composedKey, isEncrypted, encryptKey);
        record.setSource(Source.PERSISTENCE);
        memory.put(composedKey, record);
      } catch (Exception ignore) {
        return null;
      }
    }

    record.setLifeTime(lifeTime);

    //判断超时时间
    if (hasRecordExpired.hasRecordExpired(record)) {
      //下面就是根据EvictDynamicKey/EvictDynamicKeyGroup做缓存清除的工作,根据作者Github介绍,RxCache支持类似于Spring的@CacheEvict功能
      if (!dynamicKeyGroup.isEmpty()) {
        evictRecord.evictRecordMatchingDynamicKeyGroup(providerKey, dynamicKey,
            dynamicKeyGroup);
      } else if (!dynamicKey.isEmpty()) {
        evictRecord.evictRecordsMatchingDynamicKey(providerKey, dynamicKey);
      } else {
        evictRecord.evictRecordsMatchingProviderKey(providerKey);
      }

      return useExpiredDataIfLoaderNotAvailable ? record : null;
    }

    return record;
  }

上面说到返回的Record被Observable#just发射又由Observable#map转换为Observable<Reply>,之后有一个判断,就是当Record != null并且没有被标记需要清空全部缓存的时候才继续讲Record转换为Reply并发射。不满足条件的话就执行ProcessorProvidersBehaviour#getDataFromLoader,就是将使用的时候传入的外部请求(也是Observable,通常是Retrofit的接口请求方法)进行请求,将数据写入TwoLayersCache并将数据的Source标记为CLOUD(云端),以Observable<Reply>形式返回。

之后又做了一次Observable#flatMap和Observable#map,在map中做了一次判断if(configProvider.requiredDetailedResponse()),就返回带有详细信息的数据(Reply类型)return new Reply<>(data, reply.getSource(), configProvider.isEncrypted());否则就返回data的深拷贝(Object类型),当然最后整个方法ProcessorProvidersBehaviour#getData的返回还是一个Observable供外部调用。

最后又回到了实现了InvocationHandler接口的ProxyProviders#invoke,还是动态代理哈,将接口的调用转发给ProxyProviders#invoke,真正的方法在这里面实现就好。