一、简介

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. 单片机c语言教程:C51循环语句

    单片机c语言教程第十三课 C51循环语句 循环语句是几乎每个程序都会用到的,它的作用就是用来实现需要反复进行多次的操 作.如一个 12M 的 51 芯片应用电路中要求实现 1 毫秒的延时,那么就要执行 ...

  2. 《挑战程序设计竞赛》2.2 贪心法-区间 POJ2376 POJ1328 POJ3190

    POJ2376 Cleaning Shifts Time Limit: 1000MS   Memory Limit: 65536K Total Submissions: 14585   Accepte ...

  3. PHP heredoc 用法

    php 中的 heredoc技术是php用来引用字符串的一种方式.在phpwind中巧妙的运用了这个技术,实现了逻辑代码和界面设计的分离. 语法: 1. 使用操作符  “<<<” 2 ...

  4. git原理:提交原理

    当运行git add  git commit的时候,git底层都做了什么? 这里涉及到的底层命令:git hash-object 讲对象写入到git object中git update-index   ...

  5. win7与win server 2008防火墙设置

    转自:http://blog.51cto.com/jimshu/590411 Windows 防火墙通过阻止未授权用户通过 Internet 或网络访问您的计算机来帮助保护计算机. Windows 2 ...

  6. 转载:阮一峰 RESTful API设计指南

    阮一峰先生的文章对我理解启发很大,转载到我的博客 http://www.ruanyifeng.com/blog/2014/05/restful_api.html 网络应用程序,分为前端和后端两个部分. ...

  7. window + document + height

    jQuery(window).height()代表了当前可见区域的大小,而jQuery(document).height()则代表了整个文档的高度,可视具体情况使用.     注意当浏览器窗口大小改变 ...

  8. Zuul

    一.zuul是什么 zuul 是netflix开源的一个API Gateway 服务器, 本质上是一个web servlet应用. Zuul 在云平台上提供动态路由,监控,弹性,安全等边缘服务的框架. ...

  9. python tkinter组件学习

    http://blog.csdn.net/pfm685757/article/details/50162567

  10. python 运行报错 Process finished with exit code -1073741819 (0xC0000005)

    发现是由于openpyxl模块导致的,去掉这个模块的内容就能运行,import openpyxl就运行不起来, 将openpyxl卸载了重装, 以及更换了不同的openpyxl版本,都不行,还是运行不 ...