Android开发GreenDAO数据库简单使用

• GreenDao是一个对象关系型框架，也就是我们常说的ORM框架，使用它可以通过操作对象的方式去操作数据库。从而不用手写sql代码，简化开发。

1. 在项目的build.gradle中相应的代码

buildscript {
    dependencies {
        classpath 'com.android.tools.build:gradle:3.5.3'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.3.0' // 添加
    }
}

2. 在app/build.gradle中相应的代码

apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // 添加
 
android {
    greendao {
        // 指定数据库schema版本号，迁移等操作会用到
        schemaVersion 1
        // 设置生成数据库文件的目录，默认是在build中，可以将生成的文件放到我们的java目录中
        targetGenDir 'src/main/java'
        // 设置生成的数据库相关文件的包名，默认为entity所在的包名
        daoPackage '应用包名.db.greendao'
    }
}

dependencies {
    implementation 'org.greenrobot:greendao:3.3.0' // 添加
}

3. 需要根据第二步中的daoPackage配置的包名创建出对应的空文件。

4. 在entity目录下新建自己的实体类，如IdentificationResultsEntry

图片.png

需要注意的是@Id：通过这个注解标记的字段必须是包装类型Long类型，表示该字段为主键，并且它默认就是自增。否则在升级/降级数据库的时候，会报错。*

5. 通过Make Project 后，我们会发现在greendao目录下自动生成了UserInfoDao文件。

图片.png

生成数据库操作类

我们先封装一个DBManager类

public class DaoManager {
    private static final String TAG = DaoManager.class.getSimpleName();
    private static final String DB_NAME = "greendaotest";

    private Context context;

    //多线程中要被共享的使用volatile关键字修饰
    private volatile static DaoManager manager = new DaoManager();
    private static DaoMaster sDaoMaster;
    private static DaoMaster.DevOpenHelper sHelper;
    private static DaoSession sDaoSession;

    /**
     * 单例模式获得操作数据库对象
     *
     * @return
     */
    public static DaoManager getInstance() {
        return manager;
    }

    private DaoManager() {
        setDebug();
    }

    public void init(Context context) {
        this.context = context;
    }

    /**
     * 判断是否有存在数据库，如果没有则创建
     *
     * @return
     */
    public DaoMaster getDaoMaster() {
        if (sDaoMaster == null) {
            DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
            sDaoMaster = new DaoMaster(helper.getWritableDatabase());
        }
        return sDaoMaster;
    }

    /**
     * 完成对数据库的添加、删除、修改、查询操作，仅仅是一个接口
     *
     * @return
     */
    public DaoSession getDaoSession() {
        if (sDaoSession == null) {
            if (sDaoMaster == null) {
                sDaoMaster = getDaoMaster();
            }
            sDaoSession = sDaoMaster.newSession();
        }
        return sDaoSession;
    }

    /**
     * 打开输出日志，默认关闭
     */
    public void setDebug() {
        if (BuildConfig.DEBUG) {
            QueryBuilder.LOG_SQL = true;
            QueryBuilder.LOG_VALUES = true;
        }
    }

    /**
     * 关闭所有的操作，数据库开启后，使用完毕要关闭
     */
    public void closeConnection() {
        closeHelper();
        closeDaoSession();
    }

    public void closeHelper() {
        if (sHelper != null) {
            sHelper.close();
            sHelper = null;
        }
    }

    public void closeDaoSession() {
        if (sDaoSession != null) {
            sDaoSession.clear();
            sDaoSession = null;
        }
    }
}

对数据表的进行操作工具类

public class DbOperationUtils {

    private static final String TAG = DbOperationUtils.class.getSimpleName();
    private DaoManager mManager;

    public DbOperationUtils(Context context) {
        mManager = DaoManager.getInstance();
        mManager.init(context);
    }

    /**
     * 完成IdentificationResultsEntry记录的插入，如果表未创建，先创建IdentificationResultsEntry表
     *
     * @param ident
     * @return
     */
    public boolean insertIdent(IdentificationResultsEntry ident) {
        boolean flag = false;
        flag = mManager.getDaoSession().getIdentificationResultsEntryDao().insert(ident) == -1 ? false : true;
        Log.i(TAG, "insert ident :" + flag + "-->" + ident.toString());
        return flag;
    }

    /**
     * 插入多条数据，在子线程操作
     *
     * @param identList
     * @return
     */
    public boolean insertMultIdent(final List identList) {
        boolean flag = false;
        try {
            mManager.getDaoSession().runInTx(new Runnable() {
                @Override
                public void run() {
                    for (IdentificationResultsEntry ident : identList) {
                        mManager.getDaoSession().insertOrReplace(ident);
                    }
                }
            });
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 修改一条数据
     *
     * @param ident
     * @return
     */
    public boolean updateIdent(IdentificationResultsEntry ident) {
        boolean flag = false;
        try {
            mManager.getDaoSession().update(ident);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 删除单条记录
     *
     * @param ident
     * @return
     */
    public boolean deleteIdent(IdentificationResultsEntry ident) {
        boolean flag = false;
        try {
            //按照id删除
            mManager.getDaoSession().delete(ident);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 删除所有记录
     *
     * @return
     */
    public boolean deleteAll() {
        boolean flag = false;
        try {
            //按照id删除
            mManager.getDaoSession().deleteAll(IdentificationResultsEntry.class);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 查询所有记录
     *
     * @return
     */
    public List queryAllIdent() {
        return mManager.getDaoSession().loadAll(IdentificationResultsEntry.class);
    }

    /**
     * 根据主键id查询记录
     *
     * @param key
     * @return
     */
    public IdentificationResultsEntry queryIdentById(long key) {
        return mManager.getDaoSession().load(IdentificationResultsEntry.class, key);
    }

    /**
     * 使用native sql进行查询操作
     */
    public List queryIdentByNativeSql(String sql, String[] conditions) {
        return mManager.getDaoSession().queryRaw(IdentificationResultsEntry.class, sql, conditions);
    }

    /**
     * 使用queryBuilder进行查询
     *
     * @return
     */
    public List queryIdentByQueryBuilder(long id) {
        QueryBuilder queryBuilder = mManager.getDaoSession().queryBuilder(IdentificationResultsEntry.class);
        return queryBuilder.where(IdentificationResultsEntryDao.Properties.SearchId.eq(id)).list();
    }

}