RxCache 整合 Android 的持久層框架 greenDAO、Room

時間  2019-11-16
標籤 rxcache 整合 android 持久 框架 greendao room 欄目 Android 简体版
原文   原文鏈接

海灘美女.jpg

一. 背景

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

以前的文章給 Java 和 Android 構建一個簡單的響應式Local Cache曾詳細介紹過它。android

RxCache 包含了兩級緩存： Memory 和 Persistence 。git

下圖是 rxcache-core 模塊的 uml 類圖github

rxcache_uml.png

二. 持久層

RxCache 的持久層包括 Disk、DB，分別單獨抽象了 Disk、DB 接口並繼承 Persistence。算法

DB 接口:數據庫

package com.safframework.rxcache.persistence.db;

import com.safframework.rxcache.persistence.Persistence;

/** * Created by tony on 2018/10/14. */
public interface DB extends Persistence {

}
複製代碼

在 RxCache 的持久層，嘗試集成 Android 經常使用的持久層框架。json

2.1 集成 greenDAO

greenDAO 是一款開源的面向 Android 的輕便、快捷的 ORM 框架，將 Java 對象映射到 SQLite 數據庫。緩存

首先，建立一個緩存實體 CacheEntity ，它包含 id、key、data、timestamp、expireTime。其中 data 是待緩存的對象並轉換成 json 字符串。app

@Entity
public class CacheEntity {

    @Id(autoincrement = true)
    private Long id;

    public String key;

    public String data;// 對象轉換的 json 字符串

    public Long timestamp;

    public Long expireTime;

    ...... // getter 、setter
}
複製代碼

建立一個單例的 DBService ，並提供返回 CacheEntityDao 的方法。其實，crud 的邏輯也能夠放在此處。框架

public class DBService {

    private static final String DB_NAME = "cache.db";
    private static volatile DBService defaultInstance;
    private DaoSession daoSession;

    private DBService(Context context) {

        DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME);

        DaoMaster daoMaster = new DaoMaster(helper.getWritableDatabase());

        daoSession = daoMaster.newSession();
    }

    public static DBService getInstance(Context context) {
        if (defaultInstance == null) {
            synchronized (DBService.class) {
                if (defaultInstance == null) {
                    defaultInstance = new DBService(context.getApplicationContext());
                }
            }
        }
        return defaultInstance;
    }

    public CacheEntityDao getCacheEntityDao(){
        return daoSession.getCacheEntityDao();
    }

}
複製代碼

建立 GreenDAOImpl 實現 DB 接口，實現真正的緩存邏輯。

import com.safframework.rxcache.config.Constant;
import com.safframework.rxcache.domain.Record;
import com.safframework.rxcache.domain.Source;
import com.safframework.rxcache.persistence.converter.Converter;
import com.safframework.rxcache.persistence.converter.GsonConverter;
import com.safframework.rxcache.persistence.db.DB;
import com.safframework.tony.common.utils.Preconditions;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

/** * @FileName: com.safframework.rxcache4a.persistence.db.greendao.GreenDAOImpl * @author: Tony Shen * @date: 2018-10-15 11:50 * @version: V1.0 <描述當前版本功能> */
public class GreenDAOImpl implements DB {

    private CacheEntityDao dao;
    private Converter converter;

    public GreenDAOImpl(CacheEntityDao dao) {

        this(dao,new GsonConverter());
    }

    public GreenDAOImpl(CacheEntityDao dao, Converter converter) {

        this.dao = dao;
        this.converter = converter;
    }

    @Override
    public <T> Record<T> retrieve(String key, Type type) {

        CacheEntity entity = dao.queryBuilder().where(CacheEntityDao.Properties.Key.eq(key)).unique();

        if (entity==null) return null;

        long timestamp = entity.timestamp;
        long expireTime = entity.expireTime;
        T result = null;

        if (expireTime<0) { // 緩存的數據從不過時

            String json = entity.data;

            result = converter.fromJson(json,type);
        } else {

            if (timestamp + expireTime > System.currentTimeMillis()) {  // 緩存的數據尚未過時

                String json = entity.data;

                result = converter.fromJson(json,type);
            } else {        // 緩存的數據已通過期

                evict(key);
            }
        }

        return result != null ? new Record<>(Source.PERSISTENCE, key, result, timestamp, expireTime) : null;
    }

    @Override
    public <T> void save(String key, T value) {

        save(key,value, Constant.NEVER_EXPIRE);
    }

    @Override
    public <T> void save(String key, T value, long expireTime) {

        if (Preconditions.isNotBlanks(key,value)) {

            CacheEntity entity = new CacheEntity();
            entity.setKey(key);
            entity.setTimestamp(System.currentTimeMillis());
            entity.setExpireTime(expireTime);
            entity.setData(converter.toJson(value));
            dao.save(entity);
        }
    }

    @Override
    public List<String> allKeys() {

        List<CacheEntity> list = dao.loadAll();

        List<String> result = new ArrayList<>();

        for (CacheEntity entity:list) {

            result.add(entity.key);
        }

        return result;
    }

    @Override
    public boolean containsKey(String key) {

        List<String> keys = allKeys();

        return Preconditions.isNotBlank(keys) ? keys.contains(key) : false;
    }

    @Override
    public void evict(String key) {

        CacheEntity entity = dao.queryBuilder().where(CacheEntityDao.Properties.Key.eq(key)).unique();

        if (entity!=null) {

            dao.delete(entity);
        }

    }

    @Override
    public void evictAll() {

        dao.deleteAll();
    }
}
複製代碼

2.2 集成 Room

Room 是 Google 開發的一個 SQLite 對象映射庫。 使用它來避免樣板代碼並輕鬆地將 SQLite 數據轉換爲 Java 對象。 Room 提供 SQLite 語句的編譯時檢查，能夠返回 RxJava 和 LiveData Observable。

一樣，須要先建立一個 CacheEntity，可是不能共用以前的 CacheEntity。由於 Room、greenDAO 使用的 @Entity不一樣。

@Entity
public class CacheEntity {

    @PrimaryKey(autoGenerate = true)
    private Long id;

    public String key;

    public String data;// 對象轉換的 json 字符串

    public Long timestamp;

    public Long expireTime;

    ...... // getter 、setter
}
複製代碼

建立一個 CacheEntityDao 用於 crud 的實現。

import java.util.List;

import androidx.room.Dao;
import androidx.room.Delete;
import androidx.room.Insert;
import androidx.room.Query;

import static androidx.room.OnConflictStrategy.IGNORE;

/** * @FileName: com.safframework.rxcache4a.persistence.db.room.CacheEntityDao * @author: Tony Shen * @date: 2018-10-15 16:44 * @version: V1.0 <描述當前版本功能> */
@Dao
public interface CacheEntityDao {

    @Query("SELECT * FROM cacheentity")
    List<CacheEntity> getAll();

    @Query("SELECT * FROM cacheentity WHERE `key` = :key LIMIT 0,1")
    CacheEntity findByKey(String key);

    @Insert(onConflict = IGNORE)
    void insert(CacheEntity entity);

    @Delete
    void delete(CacheEntity entity);

    @Query("DELETE FROM cacheentity")
    void deleteAll();
}
複製代碼

建立一個 AppDatabase 表示一個數據庫的持有者。

import androidx.room.Database;
import androidx.room.RoomDatabase;

/** * @FileName: com.safframework.rxcache4a.persistence.db.room.AppDatabase * @author: Tony Shen * @date: 2018-10-15 16:40 * @version: V1.0 <描述當前版本功能> */
@Database(entities = {CacheEntity.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {

    public abstract CacheEntityDao cacheEntityDao();
}
複製代碼

最後，建立 RoomImpl 實現 DB 接口，實現真正的緩存邏輯。

import android.content.Context;

import com.safframework.rxcache.config.Constant;
import com.safframework.rxcache.domain.Record;
import com.safframework.rxcache.domain.Source;
import com.safframework.rxcache.persistence.converter.Converter;
import com.safframework.rxcache.persistence.converter.GsonConverter;
import com.safframework.rxcache.persistence.db.DB;
import com.safframework.tony.common.utils.Preconditions;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import androidx.room.Room;

/** * @FileName: com.safframework.rxcache4a.persistence.db.room.RoomImpl * @author: Tony Shen * @date: 2018-10-15 16:46 * @version: V1.0 <描述當前版本功能> */
public class RoomImpl implements DB {

    private AppDatabase db;
    private Converter converter;
    private static final String DB_NAME = "cache";

    public RoomImpl(Context context) {

        this(context,new GsonConverter());
    }

    public RoomImpl(Context context, Converter converter) {

        this.db = Room.databaseBuilder(context, AppDatabase.class, DB_NAME).build();
        this.converter = converter;
    }

    @Override
    public <T> Record<T> retrieve(String key, Type type) {

        CacheEntity entity = db.cacheEntityDao().findByKey(key);

        if (entity==null) return null;

        long timestamp = entity.timestamp;
        long expireTime = entity.expireTime;
        T result = null;

        if (expireTime<0) { // 緩存的數據從不過時

            String json = entity.data;

            result = converter.fromJson(json,type);
        } else {

            if (timestamp + expireTime > System.currentTimeMillis()) {  // 緩存的數據尚未過時

                String json = entity.data;

                result = converter.fromJson(json,type);
            } else {        // 緩存的數據已通過期

                evict(key);
            }
        }

        return result != null ? new Record<>(Source.PERSISTENCE, key, result, timestamp, expireTime) : null;
    }

    @Override
    public <T> void save(String key, T value) {

        save(key,value, Constant.NEVER_EXPIRE);
    }

    @Override
    public <T> void save(String key, T value, long expireTime) {

        if (Preconditions.isNotBlanks(key,value)) {

            CacheEntity entity = new CacheEntity();
            entity.setKey(key);
            entity.setTimestamp(System.currentTimeMillis());
            entity.setExpireTime(expireTime);
            entity.setData(converter.toJson(value));
            db.cacheEntityDao().insert(entity);
        }
    }

    @Override
    public List<String> allKeys() {

        List<CacheEntity> list = db.cacheEntityDao().getAll();

        List<String> result = new ArrayList<>();

        for (CacheEntity entity:list) {

            result.add(entity.key);
        }

        return result;
    }

    @Override
    public boolean containsKey(String key) {

        List<String> keys = allKeys();

        return Preconditions.isNotBlank(keys) ? keys.contains(key) : false;
    }

    @Override
    public void evict(String key) {

        CacheEntity entity = db.cacheEntityDao().findByKey(key);

        if (entity!=null) {

            db.cacheEntityDao().delete(entity);
        }
    }

    @Override
    public void evictAll() {

        db.cacheEntityDao().deleteAll();
    }
}
複製代碼

這兩種集成方式，都使用 CacheEntity 的 data 來存儲對象轉換後的 json 字符串。使用這種方式，能夠替換成任何的持久層框架。使得 DB 也能夠成爲 RxCache 的其中一級緩存。

三. 使用

編寫單元測試，看一下集成 greenDAO 的效果。

分別測試多種對象的存儲、帶 ExpireTime 的存儲。

import android.content.Context;
import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;

import com.safframework.rxcache.RxCache;
import com.safframework.rxcache.domain.Record;
import com.safframework.rxcache4a.persistence.db.greendao.CacheEntityDao;
import com.safframework.rxcache4a.persistence.db.greendao.DBService;
import com.safframework.rxcache4a.persistence.db.greendao.GreenDAOImpl;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;

/** * @FileName: com.safframework.rxcache4a.GreenDAOImplTest * @author: Tony Shen * @date: 2018-10-15 18:51 * @version: V1.0 <描述當前版本功能> */
@RunWith(AndroidJUnit4.class)
public class GreenDAOImplTest {

    Context appContext;
    DBService dbService;

    @Before
    public void setUp() {
        appContext = InstrumentationRegistry.getTargetContext();
        dbService = DBService.getInstance(appContext);
    }

    @Test
    public void testWithObject() {

        CacheEntityDao dao = dbService.getCacheEntityDao();
        GreenDAOImpl impl = new GreenDAOImpl(dao);
        impl.evictAll();

        RxCache.config(new RxCache.Builder().persistence(impl));

        RxCache rxCache = RxCache.getRxCache();

        Address address = new Address();
        address.province = "Jiangsu";
        address.city = "Suzhou";
        address.area = "Gusu";
        address.street = "ren ming road";

        User u = new User();
        u.name = "tony";
        u.password = "123456";
        u.address = address;

        rxCache.save("user",u);

        Record<User> record = rxCache.get("user", User.class);

        assertEquals(u.name, record.getData().name);
        assertEquals(u.password, record.getData().password);
        assertEquals(address.city, record.getData().address.city);

        rxCache.save("address",address);

        Record<Address> record2 = rxCache.get("address", Address.class);
        assertEquals(address.city, record2.getData().city);
    }

    @Test
    public void testWithExpireTime() {

        CacheEntityDao dao = dbService.getCacheEntityDao();
        GreenDAOImpl impl = new GreenDAOImpl(dao);
        impl.evictAll();

        RxCache.config(new RxCache.Builder().persistence(impl));

        RxCache rxCache = RxCache.getRxCache();

        User u = new User();
        u.name = "tony";
        u.password = "123456";
        rxCache.save("test",u,2000);

        try {
            Thread.sleep(2500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        Record<User> record = rxCache.get("test", User.class);

        assertNull(record);
    }
}
複製代碼

兩個 test case 都順利經過，表示集成 greenDAO 沒有問題。固然，集成 Room 也是同樣。

四. 總結

我單首創建了一個項目 RxCache4a 用於整合的 greenDAO、Room 等。

Github 地址: github.com/fengzhizi71…

將來，可能對框架增長一些 Annotation，以及增長 Cache 清除的算法。

RxCache 系列的相關文章：

  1. ReentrantReadWriteLock讀寫鎖及其在 RxCache 中的使用
  2. 堆外內存及其在 RxCache 中的使用
  3. Retrofit 風格的 RxCache及其多種緩存替換算法
  4. 給 Java 和 Android 構建一個簡單的響應式Local Cache

Java與Android技術棧：每週更新推送原創技術文章，歡迎掃描下方的公衆號二維碼並關注，期待與您的共同成長和進步。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程