Retrofit 风格的 RxCache及其多种缓存替换算法

RxCache 是一个支持 Java 和 Android 的 Local Cache 。

之前的文章《给 Java 和 Android 构建一个简单的响应式Local Cache》、《RxCache 整合 Android 的持久层框架 greenDAO、Room》曾详细介绍过它。

目前，对框架增加一些 Annotation 以及 Cache 替换算法。

一. 基于 Annotation 完成缓存操作

类似 Retrofit 风格的方式，支持通过标注 Annotation 来完成缓存的操作。

例如先定义一个接口，用于定义缓存的各种操作。

1. public interface Provider {


2. 


4.    @CacheKey("user")

5.    @CacheMethod(methodType = MethodType.GET)

6.    <T> Record<T> getData(@CacheClass Class<T> clazz);


7. 


10.    @CacheKey("user")

11.    @CacheMethod(methodType = MethodType.SAVE)

12.    @CacheLifecycle(duration = 2000)

13.    void putData(@CacheValue User user);


14. 


17.    @CacheKey("user")

18.    @CacheMethod(methodType = MethodType.REMOVE)

19.    void removeUser();


20. 


22.    @CacheKey("test")

23.    @CacheMethod(methodType = MethodType.GET, observableType = ObservableType.MAYBE)

24.    <T> Maybe<Record<T>> getMaybe(@CacheClass Class<T> clazz);

25. }

通过 CacheProvider 创建该接口，然后可以完成各种缓存操作。

1. public class TestCacheProvider {

3.    public static void main(String[] args) {


4. 


7.        RxCache.config(new RxCache.Builder());

9.        RxCache rxCache = RxCache.getRxCache();


10. 


12.        CacheProvider cacheProvider = new CacheProvider.Builder().rxCache(rxCache).build();

14.        Provider provider = cacheProvider.create(Provider.class);

16.        


17.        User u = new User();

18.        u.name = "tony";

19.        u.password = "123456";

21.        provider.putData(u); // 将u存入缓存中


22. 


24.        Record<User> record = provider.getData(User.class); // 从缓存中获取key="user"的数据

26.        if (record!=null) {

28.            System.out.println(record.getData().name);

29.        }


30. 


32.        provider.removeUser(); // 从缓存中删除key="user"的数据

34.        record = provider.getData(User.class);

36.        if (record==null) {

38.            System.out.println("record is null");

39.        }






2.        User u2 = new User();

3.        u2.name = "tony2";

4.        u2.password = "000000";

5.        rxCache.save("test",u2);


6. 


8.        Maybe<Record<User>> maybe = provider.getMaybe(User.class); // 从缓存中获取key="test"的数据，返回的类型为Maybe

9.        maybe.subscribe(new Consumer<Record<User>>() {

10.            @Override

11.            public void accept(Record<User> userRecord) throws Exception {

13.                User user = userRecord.getData();

14.                if (user!=null) {

16.                    System.out.println(user.name);

17.                    System.out.println(user.password);

18.                }

19.            }

20.        });

21.    }

22. }

CacheProvider 核心是 create()，它通过动态代理来创建Provider。

1.    public <T> T create(Class<T> clazz) {

3.        CacheProxy cacheProxy = new CacheProxy(rxCache);

5.        try {

6.            return (T) Proxy.newProxyInstance(CacheProvider.class.getClassLoader(), new Class[]{clazz}, cacheProxy);

7.        } catch (Exception e) {

8.            e.printStackTrace();

9.        }

11.        return null;

12.    }

其中，CacheProxy 实现了 InvocationHandler 接口，是创建代理类的调用处理器。

1. package com.safframework.rxcache.proxy;

3. import com.safframework.rxcache.RxCache;

4. import com.safframework.rxcache.proxy.annotation.*;

6. import java.lang.annotation.Annotation;

7. import java.lang.reflect.InvocationHandler;

8. import java.lang.reflect.Method;

10. /**

11. * Created by tony on 2018/10/30.

12. */

13. public class CacheProxy implements InvocationHandler {

15.    RxCache rxCache;


16. 


18.    public CacheProxy(RxCache rxCache) {

20.        this.rxCache = rxCache;

21.    }


22. 


24.    @Override

25.    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

27.        CacheMethod cacheMethod = method.getAnnotation(CacheMethod.class);

28.        CacheKey cacheKey = method.getAnnotation(CacheKey.class);

29.        CacheLifecycle cacheLifecycle = method.getAnnotation(CacheLifecycle.class);

31.        Annotation[][] allParamsAnnotations = method.getParameterAnnotations();

33.        


34.        Class cacheClazz = null;

35.        Object cacheValue = null;


36. 


38.        if (allParamsAnnotations != null) {

39.            for (int i = 0; i < allParamsAnnotations.length; i++) {

40.                Annotation[] paramAnnotations = allParamsAnnotations[i];

41.                if (paramAnnotations != null) {

42.                    for (Annotation annotation : paramAnnotations) {

43.                        if (annotation instanceof CacheClass) {

44.                            cacheClazz = (Class) args[i];

45.                        }

47.                        if (annotation instanceof CacheValue) {

48.                            cacheValue = args[i];

49.                        }

50.                    }

51.                }

52.            }

53.        }


54. 


56.        if (cacheMethod!=null) {

58.            MethodType methodType = cacheMethod.methodType();

60.            long duration = -1;

62.            if (cacheLifecycle != null) {

63.                duration = cacheLifecycle.duration();

64.            }

66.            if (methodType == MethodType.GET) {

68.                ObservableType observableType = cacheMethod.observableType();

70.                if (observableType==ObservableType.NOUSE) {

72.                    return  rxCache.get(cacheKey.value(),cacheClazz);

73.                } else if (observableType == ObservableType.OBSERVABLE){

75.                    return  rxCache.load2Observable(cacheKey.value(),cacheClazz);

76.                } else if (observableType==ObservableType.FLOWABLE) {

78.                    return  rxCache.load2Flowable(cacheKey.value(),cacheClazz);

79.                } else if (observableType==ObservableType.SINGLE) {

81.                    return  rxCache.load2Single(cacheKey.value(),cacheClazz);

82.                } else if (observableType==ObservableType.MAYBE) {

84.                    return  rxCache.load2Maybe(cacheKey.value(),cacheClazz);

85.                }

87.            } else if (methodType == MethodType.SAVE) {

89.                rxCache.save(cacheKey.value(),cacheValue,duration);

91.            } else if (methodType == MethodType.REMOVE) {

93.                rxCache.remove(cacheKey.value());

94.            }

95.        }

97.        return null;

98.    }

99. }

CacheProxy 的 invoke() 方法先获取 Method 所使用的 Annotation，包括CacheMethod、CacheKey、CacheLifecycle。

其中，CacheMethod 是最核心的 Annotation，它取决于 rxCache 使用哪个方法。CacheMethod 支持的方法类型包括：获取、保存、删除缓存。当 CacheMethod 的 methodType 是 GET 类型，则可能会返回 RxJava 的各种 Observable 类型，或者还是返回所存储的对象类型。

CacheKey 是任何方法都需要使用的 Annotation。CacheLifecycle 只有保存缓存时才会使用。

二. 支持多种缓存替换算法

RxCache 包含了两级缓存： Memory 和 Persistence 。

Memory 的默认实现 FIFOMemoryImpl、LRUMemoryImpl、LFUMemoryImpl 分别使用 FIFO、LRU、LFU 算法来缓存数据。

2.1 FIFO

通过使用 LinkedList 存放缓存的 keys，ConcurrentHashMap 存放缓存的数据，就可以实现 FIFO。

2.2 LRU

LRU是Least Recently Used的缩写，即最近最少使用，常用于页面置换算法，是为虚拟页式存储管理服务的。

使用 ConcurrentHashMap 和 ConcurrentLinkedQueue 实现该算法。如果某个数据已经存放在缓存中，则从 queue 中删除并添加到 queue 的第一个位置。如果缓存已满，则从 queue 中删除最后面的数据。并把新的数据添加到缓存。

1. public class LRUCache<K,V> {

3.    private Map<K,V> cache = null;

4.    private AbstractQueue<K> queue = null;

5.    private int size = 0;


6. 


8.    public LRUCache() {

10.        this(Constant.DEFAULT_CACHE_SIZE);

11.    }


12. 


14.    public LRUCache(int size) {

16.        this.size = size;

17.        cache = new ConcurrentHashMap<K,V>(size);

18.        queue = new ConcurrentLinkedQueue<K>();

19.    }


20. 


22.    public boolean containsKey(K key) {

24.        return cache.containsKey(key);

25.    }


26. 


28.    public V get(K key) {

30.        //Recently accessed, hence move it to the tail

31.        queue.remove(key);

32.        queue.add(key);

33.        return cache.get(key);

34.    }


35. 


37.    public V getSilent(K key) {

39.        return cache.get(key);

40.    }


41. 


43.    public void put(K key, V value) {

45.        //ConcurrentHashMap doesn't allow null key or values

46.        if(key == null || value == null) throw new RxCacheException("key is null or value is null");

48.        if(cache.containsKey(key)) {

49.            queue.remove(key);

50.        }

52.        if(queue.size() >= size) {

53.            K lruKey = queue.poll();

54.            if(lruKey != null) {

55.                cache.remove(lruKey);

56.            }

57.        }

59.        queue.add(key);

60.        cache.put(key,value);

61.    }


62. 


64.    /**

65.     * 获取最近最少使用的值

66.     * @return

67.     */

68.    public V getLeastRecentlyUsed() {

70.        K remove = queue.remove();

71.        queue.add(remove);

72.        return cache.get(remove);

73.    }


74. 


76.    public void remove(K key) {

78.        cache.remove(key);

79.        queue.remove(key);

80.    }


81. 


83.    public void clear() {

85.        cache.clear();

86.        queue.clear();

87.    }

88.    ......

89. }

2.3 LFU

LFU是Least Frequently Used的缩写，即最近最不常用使用。

看上去跟 LRU 类似，其实它们并不相同。LRU 是淘汰最长时间未被使用的数据，而 LFU 是淘汰一定时期内被访问次数最少的数据。

LFU 会记录数据在一定时间内的使用次数。稍显复杂感兴趣的可以阅读 RxCache  中相关的源码。

三. 总结

RxCache 大体已经完成，初步可以使用。

RxCache github 地址：https://github.com/fengzhizi715/RxCache Android 版本的 RxCache github 地址：https://github.com/fengzhizi715/RxCache4a

对于 Android ，除了支持常见的持久层框架之外，还支持 RxCache 转换成 LiveData。如果想要跟 Retrofit 结合，可以通过 RxCache 的 transform 策略。

对于Java 后端，RxCache 只是一个本地缓存，不适合存放大型的数据。但是其内置的 Memory 层包含了多种缓存替换算法，不用内置的 Memory 还可以使用 Guava Cache、Caffeine 。

关注【Java与Android技术栈】

更多精彩内容请关注扫码：