修改CacheStrategy为enum，使用更简单

Author: alafighting

app/src/main/java/com/im4j/kakacache/rxjava/demo/GitHubService.java

@@ -2,7 +2,7 @@
 
 import com.im4j.kakacache.rxjava.CACHE;
 import com.im4j.kakacache.rxjava.netcache.ResultData;
-import com.im4j.kakacache.rxjava.netcache.strategy.CacheAndRemoteStrategy;
+import com.im4j.kakacache.rxjava.netcache.strategy.CacheStrategy;
 
 import java.util.List;
 
@@ -18,7 +18,7 @@ public interface GitHubService {
     rx.Observable<List<GithubRepoEntity>> listReposForNormal(@Path("user") String user);
 
     @GET("users/{user}/repos")
-    @CACHE(value = "custom_key_listRepos", strategy = CacheAndRemoteStrategy.class)
+    @CACHE(value = "custom_key_listRepos", strategy = CacheStrategy.CacheAndRemote)
     rx.Observable<ResultData<List<GithubRepoEntity>>> listReposForKaka(@Path("user") String user);
 
 }

app/src/main/java/com/im4j/kakacache/rxjava/demo/MainActivity.java

@@ -7,10 +7,9 @@
 
 import com.im4j.kakacache.rxjava.KakaCache;
 import com.im4j.kakacache.rxjava.common.utils.LogUtils;
-import com.im4j.kakacache.rxjava.netcache.strategy.FirstCacheStrategy;
+import com.im4j.kakacache.rxjava.netcache.strategy.CacheStrategy;
 
 import retrofit2.Retrofit;
-import retrofit2.converter.gson.GsonConverterFactory;
 import rx.android.schedulers.AndroidSchedulers;
 import rx.schedulers.Schedulers;
 
@@ -59,7 +58,7 @@ protected void onCreate(@Nullable Bundle savedInstanceState) {
      */
     void demoForNormal() {
         service.listReposForNormal("alafighting")
-                .compose(KakaCache.transformer(KEY_CACHE, new FirstCacheStrategy()))
+                .compose(KakaCache.transformer(KEY_CACHE, CacheStrategy.FirstCache))
                 .subscribeOn(Schedulers.io())
                 .observeOn(AndroidSchedulers.mainThread())
                 .subscribe(data -> {

library/src/main/java/com/im4j/kakacache/rxjava/CACHE.java

@@ -1,7 +1,6 @@
 package com.im4j.kakacache.rxjava;
 
 import com.im4j.kakacache.rxjava.netcache.strategy.CacheStrategy;
-import com.im4j.kakacache.rxjava.netcache.strategy.FirstCacheStrategy;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.Retention;
@@ -31,6 +30,6 @@
      * 缓存策略
      * @return
      */
-    Class<? extends CacheStrategy> strategy() default FirstCacheStrategy.class;
+    CacheStrategy strategy() default CacheStrategy.FirstCache;
 
 }

library/src/main/java/com/im4j/kakacache/rxjava/KakaCache.java

@@ -14,7 +14,6 @@
 import com.im4j.kakacache.rxjava.common.utils.Utils;
 import com.im4j.kakacache.rxjava.core.CacheCore;
 import com.im4j.kakacache.rxjava.core.disk.converter.KryoDiskConverter;
-import com.im4j.kakacache.rxjava.core.disk.converter.SerializableDiskConverter;
 import com.im4j.kakacache.rxjava.core.disk.journal.LRUDiskJournal;
 import com.im4j.kakacache.rxjava.core.disk.storage.FileDiskStorage;
 import com.im4j.kakacache.rxjava.core.memory.journal.LRUMemoryJournal;

library/src/main/java/com/im4j/kakacache/rxjava/core/disk/journal/BasicDiskJournal.java

@@ -27,7 +27,7 @@ final LiteOrm getDb() {
     }
 
     @Override
-    public final CacheEntry get(String key) {
+    public CacheEntry get(String key) {
         if (Utils.isEmpty(key)) {
             throw new NullException("key == null");
         }

library/src/main/java/com/im4j/kakacache/rxjava/netcache/retrofit/CacheInfo.java

@@ -30,7 +30,7 @@ public static CacheInfo get(Annotation[] annotations) {
 
     private String key;
     private boolean enable;
-    private Class<? extends CacheStrategy> strategy;
+    private CacheStrategy strategy;
 
     public CacheInfo() {
     }
@@ -40,7 +40,7 @@ public String toString() {
         return "CacheInfo{" +
                 "key='" + key + '\'' +
                 ", enable=" + enable +
-                ", strategy=" + strategy.getSimpleName() +
+                ", strategy=" + strategy.name() +
                 '}';
     }
 
@@ -60,11 +60,11 @@ public void setEnable(boolean enable) {
         this.enable = enable;
     }
 
-    public Class<? extends CacheStrategy> getStrategy() {
+    public CacheStrategy getStrategy() {
         return strategy;
     }
 
-    public void setStrategy(Class<? extends CacheStrategy> strategy) {
+    public void setStrategy(CacheStrategy strategy) {
         this.strategy = strategy;
     }
 }

library/src/main/java/com/im4j/kakacache/rxjava/netcache/retrofit/KakaRxCallAdapterFactory.java

@@ -4,7 +4,7 @@
 import com.im4j.kakacache.rxjava.common.utils.LogUtils;
 import com.im4j.kakacache.rxjava.common.utils.Utils;
 import com.im4j.kakacache.rxjava.netcache.ResultData;
-import com.im4j.kakacache.rxjava.netcache.strategy.FirstCacheStrategy;
+import com.im4j.kakacache.rxjava.netcache.strategy.CacheStrategy;
 
 import java.lang.annotation.Annotation;
 import java.lang.reflect.ParameterizedType;
@@ -108,11 +108,11 @@ public <R> Observable<?> adapt(Call<R> call) {
                     LogUtils.log("fileName="+info.getKey());
 
                     if (info.getStrategy() == null) {
-                        info.setStrategy(FirstCacheStrategy.class);
+                        info.setStrategy(CacheStrategy.FirstCache);
                     }
 
                     return callAdapter.doAdaptUnwrap(call)
-                            .compose(KakaCache.transformer(info.getKey(), Utils.newInstance(info.getStrategy())));
+                            .compose(KakaCache.transformer(info.getKey(), info.getStrategy()));
                 }
 
                 return callAdapter.doAdaptUnwrap(call);

library/src/main/java/com/im4j/kakacache/rxjava/netcache/strategy/BasicCacheStrategy.java

@@ -1,15 +1,70 @@
 package com.im4j.kakacache.rxjava.netcache.strategy;
 
+import com.im4j.kakacache.rxjava.KakaCache;
+import com.im4j.kakacache.rxjava.common.utils.LogUtils;
 import com.im4j.kakacache.rxjava.netcache.ResultData;
+import com.im4j.kakacache.rxjava.netcache.ResultFrom;
 
 import rx.Observable;
+import rx.schedulers.Schedulers;
 
 /**
  * 缓存策略
- * @version alafighting 2016-06
+ * @version alafighting 2016-07
  */
-public interface CacheStrategy {
+public enum CacheStrategy {
+    /** 优先缓存 */
+    FirstCache{
+        @Override
+        public <T> Observable<ResultData<T>> execute(String key, Observable<T> source) {
+            Observable<ResultData<T>> cache = loadCache(key);
+            Observable<ResultData<T>> remote = loadRemote(key, source);
+            return Observable.concat(cache, remote)
+                    .firstOrDefault(null, it -> it.data != null)
+                    .subscribeOn(Schedulers.io());
+        }
+    },
+    /** 优先服务器 */
+    FirstRemote{
+        @Override
+        public <T> Observable<ResultData<T>> execute(String key, Observable<T> source) {
+            Observable<ResultData<T>> cache = loadCache(key);
+            Observable<ResultData<T>> remote = loadRemote(key, source);
+            return Observable.concat(remote, cache)
+                    .firstOrDefault(null, it -> it.data != null)
+                    .subscribeOn(Schedulers.io());
+        }
+    },
+    /** 先缓存，后网络 */
+    CacheAndRemote{
+        @Override
+        public <T> Observable<ResultData<T>> execute(String key, Observable<T> source) {
+            Observable<ResultData<T>> cache = loadCache(key);
+            Observable<ResultData<T>> remote = loadRemote(key, source);
+            return Observable.concat(cache, remote)
+                    .filter(result -> result.data != null)
+                    .onBackpressureBuffer()
+                    .subscribeOn(Schedulers.io());
+        }
+    };
 
-    <T> Observable<ResultData<T>> execute(String key, Observable<T> source);
+
+
+    protected <T> Observable<ResultData<T>> loadCache(String key) {
+        return KakaCache.manager().load(key).map(it -> {
+            LogUtils.debug("loadCache result="+it);
+            return new ResultData<>(ResultFrom.Cache, key, (T) it);
+        });
+    }
+
+    protected <T> Observable<ResultData<T>> loadRemote(String key, Observable<T> source) {
+        return source.map(it -> {
+            LogUtils.debug("loadRemote result="+it);
+            KakaCache.manager().save(key, it).subscribe(status -> LogUtils.log("save status => "+status) );
+            return new ResultData<>(ResultFrom.Remote, key, it);
+        });
+    }
+
+    public abstract <T> Observable<ResultData<T>> execute(String key, Observable<T> source);
 
 }