GreenDao3.2.2的使用

https://github.com/greenrobot/greenDAO

一、在app的build.gradle中配置

Project:

classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'

app:

apply plugin: 'org.greenrobot.greendao'

greendao {
    schemaVersion 1
    daoPackage 'com.at3.bitcontinent.dao'  //生成的文件存放的文件夾
    targetGenDir 'src/main/java'
}

//greenDao ---> https://github.com/greenrobot/greenDAO
implementation 'org.greenrobot:greendao:3.2.2'

實體類註解:
@Entity
@Id(autoincrement = true)

生成文件如下：

DaoMaster
DaoSession
XXXEntitiDao

二、自定義封裝

1. 接口IDao

public interface IDao<Entity, Key> {
    /**
     * 添加一條
     */
    boolean insert(Entity entity);

    /**
     * 添加一條(存在則替換)
     */
    boolean insertOrReplace(@NonNull Entity entity);

    /**
     * 添加多條
     */
    boolean insertList(List<Entity> entityList);

    /**
     * 添加多條(主鍵相同則替換)
     */
    boolean insertOrReplaceList(List<Entity> entityList);

    /**
     * 刪除一條
     */
    boolean delete(Entity entity);

    /**
     * 通過key刪除
     */
    boolean deleteByKey(Key key);

    /**
     * 刪除多條
     */
    boolean deleteList(List<Entity> entityList);

    /**
     * 在事務中刪除多條
     */
    boolean deleteByKeyInTx(Key... key);

    /**
     * 刪除全部
     */
    boolean deleteAll();

    /**
     * 修改一條
     */
    boolean update(Entity entity);

    /**
     * 在事務中修改
     */
    boolean updateInTx(Entity... entity);

    /**
     * 修改多條
     */
    boolean updateList(List<Entity> entityList);

    /**
     * 通過主鍵查詢
     */
    Entity selectByPrimaryKey(Key key);

    /**
     * 查詢所有
     */
    List<Entity> loadAll();

    /**
     * 自定義查詢
     */
    QueryBuilder<Entity> getQueryBuilder();

    /**
     * 條件查詢
     */
    List<Entity> queryRaw(String where, String... selectionArg);

    /**
     * 刷新某條數據
     */
    boolean refresh(Entity entity);

    /**
     * 清理緩存
     */
    void clearDaoSession();

    /**
     * 從數據庫刪除所有的表
     */
    boolean dropDatabase();

    /**
     * 事務
     */
    void runInTx(Runnable runnable);
}

2. 基類AbstractDbManager

public abstract class AbstractDbManager<Entity, Key> implements IDao<Entity, Key> {
    protected static DaoSession daoSession;
    /**
     * The Android Activity reference for access to DatabaseManager.
     */
    private static DaoMaster.DevOpenHelper mHelper;

    /**
     * 在application中初始化DatabaseHelper
     */
    private static DaoMaster.DevOpenHelper getOpenHelper(@NonNull Context context, @Nullable String dataBaseName) {
        closeDbConnections();
        return new DaoMaster.DevOpenHelper(context, dataBaseName, null);
    }

    /**
     * Query for writable DB
     */
    protected static void openWritableDb() throws SQLiteException {
        SQLiteDatabase db = mHelper.getWritableDatabase();
        daoSession = new DaoMaster(db).newSession();
    }

    /**
     * 只關閉helper就好,看源碼就知道helper關閉的時候會關閉數據庫
     */
    public static void closeDbConnections() {
        if (mHelper != null) {
            mHelper.close();
            mHelper = null;
        }
        if (daoSession != null) {
            daoSession.clear();
            daoSession = null;
        }
    }

    /**
     * 初始化OpenHelper
     */
    public static void initOpenHelper(@NonNull Context context, @NonNull String dataBaseName) {
        mHelper = getOpenHelper(context, dataBaseName);
        openWritableDb();
    }

    @Override
    public boolean insert(@NonNull Entity entity) {
        try {
            openWritableDb();
            getAbstractDao().insert(entity);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertOrReplace(@NonNull Entity entity) {
        try {
            openWritableDb();
            getAbstractDao().insertOrReplace(entity);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertList(@NonNull List<Entity> list) {
        try {
            if (list.isEmpty()) {
                return false;
            }
            openWritableDb();
            getAbstractDao().insertInTx(list);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertOrReplaceList(@NonNull List<Entity> list) {
        try {
            if (list.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().insertOrReplaceInTx(list);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean delete(@NonNull Entity m) {
        try {
            openWritableDb();
            getAbstractDao().delete(m);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteByKey(Key key) {
        try {
            if (TextUtils.isEmpty(key.toString()))
                return false;
            openWritableDb();
            getAbstractDao().deleteByKey(key);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteList(List<Entity> entityList) {
        try {
            if (entityList == null || entityList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().deleteInTx(entityList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteByKeyInTx(Key... key) {
        try {
            openWritableDb();
            getAbstractDao().deleteByKeyInTx(key);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteAll() {
        try {
            openWritableDb();
            getAbstractDao().deleteAll();
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean update(@NonNull Entity entity) {
        try {
            openWritableDb();
            getAbstractDao().update(entity);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean updateInTx(Entity... entities) {
        try {
            if (entities == null)
                return false;
            openWritableDb();
            getAbstractDao().updateInTx(entities);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean updateList(List<Entity> entityList) {
        try {
            if (entityList == null || entityList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().updateInTx(entityList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public Entity selectByPrimaryKey(@NonNull Key key) {
        try {
            openReadableDb();
            return getAbstractDao().load(key);
        } catch (SQLiteException e) {
            return null;
        }
    }

    /**
     * Query for readable DB
     */
    protected static void openReadableDb() throws SQLiteException {
        daoSession = new DaoMaster(getReadableDatabase()).newSession();
    }

    private static SQLiteDatabase getReadableDatabase() {
        return mHelper.getReadableDatabase();
    }

    @Override
    public List<Entity> loadAll() {
        openReadableDb();
        return getAbstractDao().loadAll();
    }

    @Override
    public QueryBuilder<Entity> getQueryBuilder() {
        openReadableDb();
        return getAbstractDao().queryBuilder();
    }

    @Override
    public List<Entity> queryRaw(String where, String... selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRaw(where, selectionArg);
    }

    @Override
    public boolean refresh(@NonNull Entity entity) {
        try {
            openWritableDb();
            getAbstractDao().refresh(entity);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public void clearDaoSession() {
        if (daoSession != null) {
            daoSession.clear();
            daoSession = null;
        }
    }

    @Override
    public boolean dropDatabase() {
        try {
            openWritableDb();
            // DaoMaster.dropAllTables(database, true); // drops all tables
            // mHelper.onCreate(database); // creates the tables
//          daoSession.deleteAll(BankCardBean.class); // clear all elements
            // from
            // a table
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    @Override
    public void runInTx(Runnable runnable) {
        try {
            openWritableDb();
            daoSession.runInTx(runnable);
        } catch (SQLiteException e) {
        }
    }

    /**
     * 獲取Dao
     */
    public abstract AbstractDao<Entity, Key> getAbstractDao();

    public Query<Entity> queryRawCreate(String where, Object... selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRawCreate(where, selectionArg);
    }

    public Query<Entity> queryRawCreateListArgs(String where, Collection<Object> selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRawCreateListArgs(where, selectionArg);
    }
}

以上是基類

3. 在Application中初始化

AbstractDbManager.initOpenHelper(this, DB_NAME, true);

4. 定義數據庫表操作類，繼承AbstractDbManager

public class AdverDaoUtils extends AbstractDbManager<AdverEntity, Long> {
    public static AdverDaoUtils sAdverDaoUtils ;
    public static AdverDaoUtils getInstance() {
        if (sAdverDaoUtils == null) {
            sAdverDaoUtils = new AdverDaoUtils();
        }
        return sAdverDaoUtils ;
    }

    @Override
    public AbstractDao<AdverEntity, Long> getAbstractDao() {
        return daoSession.getAdverEntityDao();
    }
}

以上資源下載：點擊下載

使用：
直接new構建AdverDaoUtils 對象，直接調用方法即可

注意：

1. 主鍵必須是Long類型，而不是long類型
2. 實體類定義的變量添加 @Index(unique = true) 表示該值在表中是唯一的
3. 對於網絡請求獲取的數據，生成的實體類，新增一個@Id Long _id屬性。此處如果網絡數據是唯一的，一般會有一個唯一的int id屬性，此處給其添加一個@Unique註解，再調用insertOrReplaceInTx屬性即可在每次拉取數據的時候覆蓋該條id對應的數據，從而解決insertOrReplaceList重複添加數據的問題。如果不設置，依然會重複添加，因爲每次拉取之後_id是不一樣的。

---

常規使用

DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "demo.db", null);
SQLiteDatabase db = helper.getWritableDatabase();
DaoMaster daoMaster = new DaoMaster(db);
DaoSession daoSession = daoMaster.newSession();
DemoEntityDao mDemoEntityDao = daoSession.getDemoEntityDao();