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();