Android Studio集成greenDAO 3.0基础教程

摘要：

greenDAO 3是一款当前Android开发较流行的SQLite框架，该框架在集成、使用方面和其他框架有所不同，本文将从以下几方面帮助初学者了解greenDAO 3：1、快速集成greenDAO 3，2、初步体验greenDAO 3对数据增、删、改、查的便捷，3、深入理解Gradle Plugin插件，4、深入理解注解的基础知识，5、greenDAO 3源码分析

一、快速集成greenDAO 3

与以往集成框架不同的是，greenDAO 3除了需要在build.gradle文件的dependencies标签添加依赖包greendao:3.2.2外，还需要下载并添加一个Gradle插件，该插件叫：greendao-gradle-plugin:3.2.2，使用Android Studio插件module后，打开build.gradle文件

第一步：添加greenDAO依赖包

compile 'org.greenrobot:greendao:3.2.2'

第二步：下载并添加greenDAO 3构建插件

// 下载greenDAOI插件
buildscript {
    repositories {
        jcenter()
        mavenCentral() // add repository
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.1'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
    }
}

// 应用greenDAO插件
apply plugin: 'org.greenrobot.greendao'

细心的读者会发现，greenDAO 3插件的代码和apply plugin: 'com.android.application'的代码有几分相似，后者的代码在每一个新建的Application Module中都会出现，如果新建的是一个Library Module，上述代码变成apply plugin: 'com.android.library'，现在我们先不讨论，后面会深入理解Gradle Plugin。

第三步：同步buid.gradle文件，配置如下图

在项目中展开External Libraries，可以看到greendao-3.2.2和greendao-api-3.2.2两个类库，后面会分析这两个类库的源码，从源码中学习它们的使用，如下图：

这个时候，我们已经完成Android Studio集成greenDAO 3的任务，接下来greenDAO怎么使用。

二、初步体会greenDAO 3增、删、改、查数据的便捷

greenDAO 3相比greenDAO 2有了重大的改变（本文介绍的是greenDAO 3的用法），greenDAO 3使用了注解的方式定义Java实体和SQLite表之间的关系，实体和表之间处于一种关联的关系，当实体中的属性发生改变，调用update方法更新表中的内容；当需要往表添加内容，调用insert方法插入数据，减少开发者编写重复、繁琐的SQL代码，体会greenDAO 3带来数据操作的便捷

现在，需要创建一张学生表，用于保存学生的基本信息：姓名、年龄、成绩，使用greenDAO 3框架就会显得很方便，代码如下：

/**
 * Created by https://www.teachcourse.cn on 2017/8/15.
 */
@Entity(indexes = {
        @Index(value = "name, age,grade DESC", unique = true)
})
public class Student {
    @Id
    private Long id;

    @NotNull
    private String name;
    @NotNull
    private int age;
    @NotNull
    private String grade;
}

新建一个Student类，并添加greenDAO相关的注解，注解包括：@Entity定义SQLite表相关内容，@Id定义表的主键，@NotNull定义表的列不为空，还有其他注解的标签，TeachCourse将在后面进行介绍。

前面我们不清楚为什么需要添加一个Gradle Plugin，现在我们在新建Student类后，点击菜单Build——>Make Project或Make Module xxx，然后等待构建完成，需要注意：原来的Student类自动添加了一些额外的代码，如下：

@Entity(indexes = {
        @Index(value = "name, age,grade DESC", unique = true)
})
public class Student {
    @Id
    private Long id;

    @NotNull
    private String name;
    @NotNull
    private int age;
    @NotNull
    private String grade;

    @Generated(hash = 827539117)
    public Student(Long id, @NotNull String name, int age, @NotNull String grade) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    @Generated(hash = 1556870573)
    public Student() {
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGrade() {
        return this.grade;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }
}

这是使用greenDAO 3其中一个便捷的地方，减少我们编写额外的代码（关于会自动生成哪些代码，学习greenDAO注解的时候会说到）。

如果你没有在build.gradle文件的greendao标签中定义属性：daoPackage，默认生成表的相关Java代码位于如下路径：

build/generated/source/greendao

我们展开上述路径，看到如下图：

除了生成生成表的相关Java代码外，还多创建了两个类DaoMaster和DaoSession，这两个类用于操作表的增、删、改、查，同时这两个类在第一次构建生成后，以后不再重新生成。简单地说，如果我们还想要创建一张课程表Course，代码如下：

@Entity(indexes = {
        @Index(value = "name DESC", unique = true)
})
public class Course {
    @Id
    private long id;
    @NotNull
    private String name;
}

点击菜单Build——>Make Project或Make Module xxx，然后等待构建完成，生成新的CourseDao类，而不会重新生成DaoMaster和DaoSession，如下图：

打开StudentDao类，发现里面自动生成了一些创建表的SQL语句以及一些操作表的方法；DaoSession类是greenDAO框架其中一个重要的接口，为开发者提供访问实体的操作和DAOs的一系列操作，基本用法如下：

    private DaoSession daoSession;
...
    DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "test-db");
    Database db =helper.getWritableDb();
    daoSession = new DaoMaster(db).newSession();
...

每创建一个新的session，需要分配对应的内存空间，最好的做法：在application的onCreate()方法初始化，对外提供访问session的方法，减少内存的消耗，如下图：

2.1 插入数据

    public void insert(View view){
        DaoSession daoSession=((App)getApplication()).getDaoSession();
        StudentDao studentDao=daoSession.getStudentDao();
        studentDao.insert(student);
        Log.d("DaoExample", "Inserted new student, ID: " + student.getId());
    }

2.2 删除数据

    public void delete(View view){
        DaoSession daoSession=((App)getApplication()).getDaoSession();
        StudentDao studentDao=daoSession.getStudentDao();
        studentDao.delete(student);
        Log.d("DaoExample", "Delete a student, ID: " + student.getId());
    }

2.3 更新数据

    public void update(View view){
        student.setName("张翰");
        student.setGrade("大三");
        student.setAge(26);
        DaoSession daoSession=((App)getApplication()).getDaoSession();
        StudentDao studentDao=daoSession.getStudentDao();
        studentDao.update(student);
        Log.d("DaoExample", "Update a student, ID: " + student.getId());
    }

2.4 查询数据

    public void query(View view){
        DaoSession daoSession=((App)getApplication()).getDaoSession();
        StudentDao studentDao=daoSession.getStudentDao();
        Query<Student> studentQuery=studentDao.queryBuilder().orderAsc(StudentDao.Properties.Name).build();
        List<Student> studentList = studentQuery.list();
        for (Student student:studentList) {
            Log.d("DaoExample", "Query students, ID: " + student.getId());
        }
    }

到此，我们已经体会到greenDAO对数据增、删、改、查的便捷，接下来将进行高级教程的学习。

三、深入理解Gradle Plugin插件

Gradle是一种新一代的自动化构建工具，类似于Apache ant和Apache Maven，既继承了后两者自动化工具的优点，又添加新的特性，它的特性是：使用Groovy而不是xml编写配置文件，大大降低构建脚本的大小而且更易读。

Groovy虽说是一门新的语言，但因其源自于Java运行在Java Virtual Machine，所以和Java语言有很多相似的地方，更加简单、轻量级，比如：

3.1 Java和Groovy定义类的区别

1. Java，定义一个类名前可以添加public（或省略）关键字：
   public class MainActivity...
2. Groovy，定义一个类名统一没有作用域：

   class GreetingPlugin implements Plugin<Project>...
   

3.2 Java和Groovy定义变量的区别

1. Java，定义一个变量，需要区分不同类型：
   String name
2. Groovy，定义一个变量，允许使用关键字def：

   def name='ZhaoYun'
   def role="$name plays the part of WangZheRongYao!"
   def name_size="Your name is $(name.size()) characters long."
   

3.3 Java和Groovy定义方法的区别

1. Java，可以在方法名前面添加不同的作用域，同时传入的参数可以指定不同类型：

   private void initView(View view) {
        TextView tv=view.findViewById(R.id.text);
   }
   

2. Groovy，定义方法和定义变量一样，统一使用关键字def：

    String greeting = 'hello from GreetingTask'
    def greet() {
        println greeting
    }
   

3.4 Java和Groovy调用方法的区别

1. Java，实例调用方法或类名调用方法：

   User user=new User();
   user.setUserName("ZhaoYun");
   user.getUserName();
   

2. Groovy，使用关键字def定义实例：

   def instance=new GreetingPlugin（）
   instance.setGreeting 'Hello,Groovy！'
   instance.getGreeting()
   //或者
   instance.getGreeting
   

3.5 Java和Groovy其他方面的区别

1. Groovy，使用''和""的区别(参考定义变量例子):两者都可以用于定义一个字符串，双引号内可以包含插入的表达式语句
2. Groovy，不需要使用；表示结束
3. Groovy，方法名后省略括号（参考调用方法例子）
4. Groovy，统一使用关键字print，表示输出语句（参考定义方法例子）
5. Groovy，定义方法的另外的写法（有点类似Lambda表达式）：

   def caculate(def a){
    println a*a
   }
   //或者
   def caculate ={a ->
    println a*a   
   }
   //或者在匿名类中使用关键字Closure、it
   Closure caculate ={
    println it*it
   }
   

6. 其他的区别可以阅读《Gradle for Android》或《Gradle In Action》以及参考官网文档

3.6 自定义Gradle Plugin

在当前的例子中，greendao-gradle-plugin是一个使用Groovy语法编写的自定义插件，上传到开源的仓库，只需要在build.gradle添加如下代码，即可在项目中集成使用：

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
    }
}

现在，我们需要定义自己的一个插件，自定义的插件上传本地仓库，只需要在build.gradle文件添加如下代码，即可使用：

buildscript {  
    repositories {  
        maven {  
            url uri('../repo')  
        }  
    }  

    dependencies {  
        classpath group: 'cn.teachcourse',  
            name: 'custom-gradle-plugin',  
            version: '1.0.0'  
    }  
}  

apply plugin: 'cn.teachcourse.MyCustomPlugin'

在本地创建一个Groovy项目，项目名称为app-groovy，项目结构如下图：

1. app-groovy项目的根目录包括build.gradle和settings.gradle两个文件，如下图：
   
2. groovy和resources属于两个固定名称的文件夹，前者用于存储Groovy语言编写的代码，后者用于存放当前插件的属性文件，如下图：
   
   

3.7 详细了解上述各个文件代码

• build.gradle文件添加了两个插件groovy和maven，uploadArchives是添加插件提供的一个task，作用是将当前插件上传本地，代码如下：

apply plugin: 'groovy'
apply plugin: 'maven'

dependencies {
    compile gradleApi()
    compile localGroovy()
}

repositories {
    mavenCentral()
}

group='cn.teachcourse'
version='1.0.0'

uploadArchives {
    repositories {
        mavenDeployer {
            repository(url: uri('../repo'))
        }
    }
}

• settings.gradle文件定义当前插件的名字，只有一句代码，如下：

rootProject.name='custom-gradle-plugin'

• groovy文件夹内添加对应的包名，然后新建一个以.groovy后缀的文件，实现Plugin<Project>接口，重写apply()方法，该方法会在应用插件的时候回调，代码如下：

package cn.teahcourse

import org.gradle.api.Plugin
import org.gradle.api.Project

class MyCustomPlugin implements Plugin<Project> {

    @Override
    void apply(Project project) {
        project.task('myTask') << {
            println 'hell i am a task in plugin'
        }
    }
}

• resources文件夹包含子文件夹：META-INF——>gradle-plugins，然后新建以.properties为后缀的属性文件，文件名与apply plugin ''的插件名称一致，文件内部添加实现类的目录位置，代码如下：

implementation-class=cn.teahcourse.MyCustomPlugin

• 到此完成了自定义插件的app-groovy的开发

3.8 Gradle工具自动化构建app-groovy

Android Studio默认下载了Gradle自动化构建工具到本地，在AS的安装目录Android Studio\gradle找到，配置一下gradle的环境变量，即可在cmd命令行使用，可以参考《Android开发之深入理解Android Studio构建文件build.gradle配置》

Gradle具体构建过程步骤如下：

1. gradle -v，检查环境变量是否配置成功
   
2. gradle task_name，执行指定的task_name，这里执行uploadArchives，在项目同级目录创建仓库repo，如下图：
   
   
3. gradle -q tasks --all，如果你不清楚项目包含哪些可执行的tasks，使用上述命令可检查项目包含可执行的task（切换到当前项目根目录），如下图：
   
4. 到此，TeachCourse完成了app-groovy项目的构建，这个过程和使用AS构建Android项目是一样

3.9 如何引用自定义的Gradle Plugin？

在app-groovy项目的同级目录下新建文件夹sample，然后里面新建文件build.gradle，代码如下：

buildscript {  
    repositories {  
        maven {  
            url uri('../repo')  
        }  
    }  

    dependencies {  
        classpath group: 'cn.teachcourse',  
            name: 'custom-gradle-plugin',  
            version: '1.0.0'  
    }  
}  

apply plugin: 'cn.teachcourse.MyCustomPlugin'

1. gradle build，检查当前build.gradle文件应用的插件，如下图：
   
2. gradle myTask，执行指定的task，如下图：
   
3. 到此，TeachCourse完成了build.gradle文件应用Gradle Plugin

PS：剩下的内容，下一篇文章介绍