android GreenDao 笔记

手上有一个半自动化的项目，大致是安卓平板和带有wifi热点（只有局域网，没有公网）的板子在scoket下，做一些实时数据的采集，然后在批量上传给服务器。这就意味着要将数据库放到平板这端了。我也就顺其自然的用上了Greendao。。这样不是快点么，我是不想再苦哈哈的写sql了，哈哈哈。。。

一、简介

GreenDAO是一个开源的安卓ORM框架，能够使SQLite数据库的开发再次变得有趣。它减轻开发人员处理低级数据库需求，同时节省开发时间。 SQLite是一个令人敬畏的内嵌的关系数据库，编写SQL和解析查询结果是相当乏味和耗时的任务。通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），GreenDAO可以将它们从这些映射中释放出来，这样，您可以使用简单的面向对象的API来存储，更新，删除和查询数据库。

简单的讲，GreenDAO 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM 解决方案。

二、ORM概念

 

对象-关系映射（OBJECT/RELATIONALMAPPING，简称ORM），是随着面向对象的软件开发方法发展而产生的。用来把对象模型表示的对象映射到基于SQL的关系模型数据库结构中去。这样，我们在具体的操作实体对象的时候，就不需要再去和复杂的 SQL 语句打交道，只需简单的操作实体对象的属性和方法。ORM 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通过这个桥梁来相互转化。

简单的讲，就是JavaBean和我们的数据库进行一个关系映射，一个实例对象对应数据库的一条记录，每个对象的属性则对应着数据库表的字段。

三、添加依赖

// In your root build.gradle file:
buildscript {
    repositories {
        jcenter()
        mavenCentral() // add repository
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.1'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
    }
}
 
// In your app projects build.gradle file:
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // apply plugin
 
dependencies {
    implementation 'org.greenrobot:greendao:3.2.2' // add library
}

四、解锁技能

GreenDao 3.0采用注解的方式来定义实体类，通过gradle插件生成相应的代码。您可以使用greenDAO Gradle插件，无需任何其他配置,但至少要设置schema的版本等;

// In the build.gradle file of your app project:

android {

...

}

greendao

{

schemaVersion 1

daoPackage 'com.ping.greendao.gen'

targetGenDir 'src/main/java'

}

此外，greendao配置元素支持多种配置选项：

• schemaVersion：指定数据库schema版本号，迁移等操作会用到；
• daoPackage：通过gradle插件生成的数据库相关文件的包名，默认为你的entity所在的包名；
• targetGenDir：自定义生成数据库文件的目录，可以将生成的文件放到我们的java目录中，而不是build中，这样就不用额外的设置资源目录了。

通过GreenDao3注解的语法来定义我们的一个数据库实体类及其数据库操作方法；

 

• 我们先生成一个实体类——Meizi，包含id、来源、和图片url地址；

  public class Meizi {
  
      private String _id;
      private String source;
      private String url;
  }
  

  •  

• 通过添加注解为我们的Meizi实体类生成对应的数据库操作方法；

  @Entity
  public class Meizi {
  
      @Id(autoincrement = true)
      private Long _id;
      private String source;
      @NotNull
      private String url;
  }

这里的几个注解含义：

•  @Entity：将我们的java普通类变为一个能够被greenDAO识别的数据库类型的实体类;
•  @nameInDb：在数据库中的名字，如不写则为实体中类名；
•  @Id：选择一个long / Long属性作为实体ID。 在数据库方面，它是主键。 参数autoincrement是设置ID值自增；
•  @NotNull：使该属性在数据库端成为“NOT NULL”列。 通常使用@NotNull标记原始类型（long，int，short，byte）是有意义的；
•  @Transient：表明这个字段不会被写入数据库，只是作为一个普通的java类字段，用来临时存储数据的，不会被持久化。

通过点击AndroidStudio中的MakeProject，便发现GreenDao为我们的Meizi实体类生成了对应的Getter、Setter方法以及俩个构造函数，同时在我们配置的com.ping.greendao.gen包下生成了三个对应类文件DaoMaster、DaoSession和MeiziDao，之后所有相关的数据库操作都依靠这三个文件了；

@Entity
public class Meizi {

    @Id(autoincrement = true)
    private Long _id;
    private String source;
    @NotNull
    private String url;
    @Generated(hash = 717937950)
    public Meizi(Long _id, String source, @NotNull String url) {
        this._id = _id;
        this.source = source;
        this.url = url;
    }
    @Generated(hash = 507723578)
    public Meizi() {
    }
    public Long get_id() {
        return this._id;
    }
    public void set_id(Long _id) {
        this._id = _id;
    }
    public String getSource() {
        return this.source;
    }
    public void setSource(String source) {
        this.source = source;
    }
    public String getUrl() {
        return this.url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
}

这里要解释一下生成的三个核心类的作用： 

 

• DaoMaster：使用greenDAO的切入点。DaoMaster保存数据库对象（SQLiteDatabase）并管理特定模式的DAO类（而不是对象）。 它具有静态方法来创建表或将它们删除。 其内部类OpenHelper和DevOpenHelper是在SQLite数据库中创建模式的SQLiteOpenHelper实现。一个DaoMaster就代表着一个数据库的连接。
• DaoSession：管理特定模式的所有可用DAO对象，您可以使用其中一个getter方法获取。 DaoSession还为实体提供了一些通用的持久性方法，如插入，加载，更新，刷新和删除。 DaoSession可以让我们使用一些Entity的基本操作和获取Dao操作类，DaoSession可以创建多个，每一个都是属于同一个数据库连接的。
• XxxDAO：数据访问对象（DAO）持续存在并查询实体。 对于每个实体，GreenDAO生成一个DAO。 它比DaoSession有更多的持久化方法，例如：count，loadAll和insertInTx。

1. 进行增删改操作；

   • 编写DaoManager，用于创建数据库、创建数据库表、包含增删改查的操作以及数据库的升级。

     /**
      * 创建数据库、创建数据库表、包含增删改查的操作以及数据库的升级
      * Created by Mr.sorrow on 2017/5/5.
      */
     
     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;
         }
     
         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(){
             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;
             }
         }
     }
     

   • 编写XxxDaoUtil，用于完成对某一张数据表的具体操作——ORM操作。以创建MeiziDaoUtil为例：

     public class MeiziDaoUtils {
         private static final String TAG = MeiziDaoUtils.class.getSimpleName();
         private DaoManager mManager;
     
         public MeiziDaoUtils(Context context){
             mManager = DaoManager.getInstance();
             mManager.init(context);
         }
     
         /**
          * 完成meizi记录的插入，如果表未创建，先创建Meizi表
          * @param meizi
          * @return
          */
         public boolean insertMeizi(Meizi meizi){
             boolean flag = false;
             flag = mManager.getDaoSession().getMeiziDao().insert(meizi) == -1 ? false : true;
             Log.i(TAG, "insert Meizi :" + flag + "-->" + meizi.toString());
             return flag;
         }
     
         /**
          * 插入多条数据，在子线程操作
          * @param meiziList
          * @return
          */
         public boolean insertMultMeizi(final List<Meizi> meiziList) {
             boolean flag = false;
             try {
                 mManager.getDaoSession().runInTx(new Runnable() {
                     @Override
                     public void run() {
                         for (Meizi meizi : meiziList) {
                             mManager.getDaoSession().insertOrReplace(meizi);
                         }
                     }
                 });
                 flag = true;
             } catch (Exception e) {
                 e.printStackTrace();
             }
             return flag;
         }
     
         /**
          * 修改一条数据
          * @param meizi
          * @return
          */
         public boolean updateMeizi(Meizi meizi){
             boolean flag = false;
             try {
                 mManager.getDaoSession().update(meizi);
                 flag = true;
             }catch (Exception e){
                 e.printStackTrace();
             }
             return flag;
         }
     
         /**
          * 删除单条记录
          * @param meizi
          * @return
          */
         public boolean deleteMeizi(Meizi meizi){
             boolean flag = false;
             try {
                 //按照id删除
                 mManager.getDaoSession().delete(meizi);
                 flag = true;
             }catch (Exception e){
                 e.printStackTrace();
             }
             return flag;
         }
     
         /**
          * 删除所有记录
          * @return
          */
         public boolean deleteAll(){
             boolean flag = false;
             try {
                 //按照id删除
                 mManager.getDaoSession().deleteAll(Meizi.class);
                 flag = true;
             }catch (Exception e){
                 e.printStackTrace();
             }
             return flag;
         }
     
         /**
          * 查询所有记录
          * @return
          */
         public List<Meizi> queryAllMeizi(){
             return mManager.getDaoSession().loadAll(Meizi.class);
         }
     
         /**
          * 根据主键id查询记录
          * @param key
          * @return
          */
         public Meizi queryMeiziById(long key){
             return mManager.getDaoSession().load(Meizi.class, key);
         }
     
         /**
          * 使用native sql进行查询操作
          */
         public List<Meizi> queryMeiziByNativeSql(String sql, String[] conditions){
             return mManager.getDaoSession().queryRaw(Meizi.class, sql, conditions);
         }
     
         /**
          * 使用queryBuilder进行查询
          * @return
          */
         public List<Meizi> queryMeiziByQueryBuilder(long id){
             QueryBuilder<Meizi> queryBuilder = mManager.getDaoSession().queryBuilder(Meizi.class);
             return queryBuilder.where(MeiziDao.Properties._id.eq(id)).list();
         }
     }
     

   • 单个插入操作：

     case R.id.insert:
        mMeiziDaoUtils.insertMeizi(new Meizi(null, "Google",
                 "http://7xi8d6.48096_n.jpg"));
         break;
     

   • 批量插入操作：

     List<Meizi> meiziList = new ArrayList<>();
      meiziList.add(new Meizi(null, "HuaWei",
              "http://7xi8d648096_n.jpg"));
      meiziList.add(new Meizi(null, "Apple",
              "http://7xi8d648096_n.jpg"));
      meiziList.add(new Meizi(null, "MIUI",
              "http://7xi8d648096_n.jpg"));
      mMeiziDaoUtils.insertMultMeizi(meiziList);
     

   • 单个更改操作：（其中原有的数据都不会保存，如果新建的对象有属性没有设置，则会为空，不为空的字段没有设置，则报错）

     Meizi meizi = new Meizi();
     meizi.set_id(1002l);
     meizi.setUrl("http://baidu.jpg");
     mMeiziDaoUtils.updateMeizi(meizi);
     

   • 删除某条记录操作：

     Meizi meizi1 = new Meizi();
     meizi1.set_id(1002l);
     mMeiziDaoUtils.deleteMeizi(meizi1);
     

   • 删除所有记录操作：

     mMeiziDaoUtils.deleteAll();
     

2. 专为查询单独列出；

   • 查询所有记录：

     case R.id.checksingle:
         Log.i(TAG, mMeiziDaoUtils.queryMeiziById(1008l).toString());
         break;
     

   • 根据主键查询记录：

     case R.id.checkmult:
         List<Meizi> meiziList1 = mMeiziDaoUtils.queryAllMeizi();
         for (Meizi meizi2 : meiziList1) {
             Log.i(TAG, meizi2.toString());
         }
         break;
     

   • 各种条件查询：

     • 使用native sql进行条件查询：

       case R.id.queryNativeSql:
           String sql = "where _id > ?";
           String[] condition = new String[]{"1008"};
           List<Meizi> meiziList2 = mMeiziDaoUtils.queryMeiziByNativeSql(sql, condition);
           for (Meizi meizi2 : meiziList2) {
               Log.i(TAG, meizi2.toString());
           }
           break;
       

     • 使用queryBuilder进行条件查询： 
           QueryBuilder能够让你在不涉及SQL语句的情况下查询实体。写SQL有几个缺点，首先是易错的，其次是要在运行时才知道有没有问题（假如属性名是pid，你写成了id，也要到运营时才会崩溃），QueryBuilder能够在编译时检查错误（如属性的引用是否错误）。 
           关于Api：在org.greenrobot.greendao.query包下，QueryBuilder类中查看其方法；构造函数可以传递我们的Xxx实体类型，查询方法有很多逻辑的where方法。where方法中需要设置WhereCondition类型的条件参数，而在org.greenrobot.greendao包下的Property类中，每一种操作符的方法都返回WhereCondition类型。获取Property实例则不需要我们去做，在我们的XxxDao中已经有对应的提供，例如我们这里的MeiziDao.Properties.XXX。

       List<Meizi> meiziList2 = mMeiziDaoUtils.queryMeiziByQueryBuilder(1008);
       for (Meizi meizi2 : meiziList2) {
           Log.i(TAG, meizi2.toString());
       }
       

           LazyList懒加载是指一次性查完数据保存在内存中，然后关闭所有连接，再次查询时从内存中获取。一般查询大数据量时用。

最后分享一下项目中可能会用到的方法：

/**
 * 创建数据库、创建数据库表、包含增删改查的操作以及数据库的升级
 * 使用GreenDao 实现简单的增删改查，下面是基本方法
 * 增加单个数据
 * getShopDao().insert(shop);
 * getShopDao().insertOrReplace(shop);
 * 增加多个数据
 * getShopDao().insertInTx(shopList);
 * getShopDao().insertOrReplaceInTx(shopList);
 * 查询全部
 * List< Shop> list = getShopDao().loadAll();
 * List< Shop> list = getShopDao().queryBuilder().list();
 * 查询附加单个条件
 * .where()
 * .whereOr()
 * 查询附加多个条件
 * .where(, , ,)
 * .whereOr(, , ,)
 * 查询附加排序
 * .orderDesc()
 * .orderAsc()
 * 查询限制当页个数
 * .limit()
 * 查询总个数
 * .count()
 * 修改单个数据
 * getShopDao().update(shop);
 * 修改多个数据
 * getShopDao().updateInTx(shopList);
 * 删除单个数据
 * getTABUserDao().delete(user);
 * 删除多个数据
 * getUserDao().deleteInTx(userList);
 * 删除数据ByKey
 * getTABUserDao().deleteByKey();
 *
 * //@Id 代表主键 需要区分的删改操作必须要有主键