一、简介

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:2.3.0'
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 {
compile 'org.greenrobot:greendao:3.2.2' // add library
}

四、解锁技能

  1. 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'
    }
  2. 此外,greendao配置元素支持多种配置选项:

    • schemaVersion:指定数据库schema版本号,迁移等操作会用到;
    • daoPackage:通过gradle插件生成的数据库相关文件的包名,默认为你的entity所在的包名;
    • targetGenDir:自定义生成数据库文件的目录,可以将生成的文件放到我们的java目录中,而不是build中,这样就不用额外的设置资源目录了。
  3. 通过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。
  4. 进行增删改操作;

    • 编写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();
  5. 专为查询单独列出

    • 查询所有记录:

      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懒加载是指一次性查完数据保存在内存中,然后关闭所有连接,再次查询时从内存中获取。一般查询大数据量时用。

五、Demo下载

源码链接

Android框架之路——GreenDao3.2.2的使用的更多相关文章

  1. Android框架之路——OkGo的使用

    一.简介 该库是封装了okhttp的标准RESTful风格的网络框架,可以与RxJava完美结合,比Retrofit更简单易用.支持大文件上传下载,上传进度回调,下载进度回调,表单上传(多文件和多参数 ...

  2. App 组件化/模块化之路——Android 框架组件(Android Architecture Components)使用指南

    面对越来越复杂的 App 需求,Google 官方发布了Android 框架组件库(Android Architecture Components ).为开发者更好的开发 App 提供了非常好的样本. ...

  3. Android学习之路——简易版微信为例(一)

    这是“Android学习之路”系列文章的开篇,可能会让大家有些失望——这篇文章中我们不介绍简易版微信的实现(不过不是标题党哦,我会在后续博文中一步步实现这个应用程序的).这里主要是和广大园友们聊聊一个 ...

  4. 小猪的Android入门之路 day 1

    小猪的Android入门之路 Day 1 Android相关背景与开发环境的搭建 ------转载请注明出处:coder-pig 本节引言: 随着社会经济的发展,移动互联网的越来越热,手机APP开发显 ...

  5. Android学习之路书籍推荐

    Android开发书籍推荐:从入门到精通系列学习路线书籍介绍 JAVA入门书籍: < Introduction to java programming > < Core java & ...

  6. Android高薪之路-Android程序员面试宝典

    Android高薪之路-Android程序员面试宝典

  7. Android 框架简介--Java环境(转)

    ==========================上=========================== 这里简单的介绍了Android的java环境基础,在后面一节中会结合具体的实例来理解这一节 ...

  8. Android学习之路——简易版微信为例(二)

    1 概述 从这篇博文开始,正式进入简易版微信的开发.深入学习前,想谈谈个人对Android程序开发一些理解,不一定正确,只是自己的一点想法.Android程序开发不像我们在大学时候写C控制台程序那样, ...

  9. 【Android - 框架】之GreenDao的使用

    上一篇博客([Android - 框架]之ORMLite的使用)中介绍了ORMLite的基本使用,今天我们来研究以下GreenDao的使用. GreenDao和ORMLite一样,都是基于ORM(Ob ...

随机推荐

  1. 【转】IBM PowerVM虚拟化技术笔记

    1. 从CPU虚拟化的角度, 分区(partition)可以分成两大类:Micro-partition和Dedicated-procesor.前者可以将物理处理器以0.01的 粒度分配给微分区,分区创 ...

  2. ng-disabled的使用

    1.适用范围 该指令适用于<input>, <select>,<button> 和 <textarea> 元素. 2.用法解析 ng-disabled ...

  3. GPU instancing

    参考 https://www.cnblogs.com/hont/p/7143626.html github地址 https://github.com/yingsz/instancing/ 补充2点: ...

  4. python 元类metaclass

    文章转自:http://www.cnblogs.com/linhaifeng/articles/8029564.html 一 知识储备 exec:三个参数 参数一:字符串形式的命令 参数二:全局作用域 ...

  5. Linux学习笔记(2)linux系统信息与进程相关命令

    man 获得命令的帮助手册,如man cp:按q键退出 su 切换用户,如su - root; '-'表示改变用户的环境变量 who 显示系统中登录的用户 w 显示登录用户的详细信息 last 查看最 ...

  6. (4.5)DBCC的概念与用法(DBCC TRACEON、DBCC IND、DBCC PAGE)

    转自:http://www.cnblogs.com/huangxincheng/p/4249248.html DBCC的概念与用法 一:DBCC 1:什么是DBCC 我不是教学老师,我也说不到没有任何 ...

  7. nodejs中全栈开发框架meteor的文档

    http://wiki.jikexueyuan.com/project/discover-meteor/routing.html,   这本书的源码地址: https://github.com/Dis ...

  8. LeetCode-day04

    35. Same Tree 判断两棵树相同 36. Invert Binary Tree 翻转树 37. Symmetric Tree 判断树是不是镜像对称的 38. Maximum Depth of ...

  9. PyQt4 颜色选择,字体选择代码

    # -*- coding: utf-8 -*- """ ------------------------------------------------- File Na ...

  10. open函数and文件处理

    一 介绍 计算机系统分为:计算机硬件,操作系统,应用程序三部分 我们用python或其他语言编写的应用程序若想要把数据永久保存下来,必须要保存于硬盘中,这就涉及到应用程序要操作硬件,应用程序是无法操作 ...