前言

之前在开发过程中，数据库基本上会使用 Litepal 和 SQlite 自己写，最近换新环境，公司原先使用的数据库就是 GreenDao，在各种情况的作用下，准备了解下 GreenDao，顺便写一篇文章记录下 GreenDao 的基本使用！大家在使用 GreenDao 的时候遇到什么问题，欢迎帮忙给我留言。

回归正题，不再扯没用的了！本文主要从如下几个方面进行讲解：

1. 存储的数据库结构

2. GreenDao的优缺点

3. GreenDao 的使用配置

4. 使用GreenDao实现数据的增删改查

5. GreenDao的注解使用

6. GreenDao的关系处理

7. GreenDao数据库加密

咱们先看一波最终的效果图：

存储的数据库结构

学习数据库之前，我们先得设计自己的数据库，不多废话，下面是我此次学习的数据库结构，后面所有的数据请参考这个图进行学习：

GreenDao的介绍

什么是GreenDao？

GreenDAO 是一个开源的 Android ORM(“对象/关系映射”)，通过 ORM（称为“对象/关系映射”），在我们数据库开发过程中节省了开发时间！

GreenDao的官方文档

GreenDao，适用于您的SQLite数据库的 Android ORM：

http://greenrobot.org/greendao/

GreenDao的作用？

通过 GreenDao，我们可以更快速的操作数据库，我们可以使用简单的面相对象的API来存储，更新，删除和查询 Java 对象。

GreenDao的优缺点？

1. 高性能，下面是官方给出的关于 GreenDao，OrmLite 和 ActiveAndroid 三种 ORM 解决方案的数据统计图：
2. 
   

1. 
   
2. 易于使用的强大 API，涵盖关系和连接；
3. 最小的内存消耗;
4. 小库大小（<100KB）以保持较低的构建时间并避免65k 方法限制;
5. 数据库加密：greenDAO 支持 SQLCipher，以确保用户的数据安全;

GreenDao的使用

GreenDao 的核心类有三个：分别是 DaoMaster,DaoSession,XXXDao，这三个类都会自动创建，无需自己编写创建！

• DaoMaster:：DaoMaster 保存数据库对象（SQLiteDatabase）并管理特定模式的 DAO 类（而不是对象）。它有静态方法来创建表或删除它们。它的内部类 OpenHelper 和DevOpenHelper 是 SQLiteOpenHelper 实现，它们在 SQLite 数据库中创建模式。
• DaoSession：管理特定模式的所有可用 DAO 对象，您可以使用其中一个getter方法获取该对象。DaoSession 还提供了一些通用的持久性方法，如实体的插入，加载，更新，刷新和删除。
• XXXDao：数据访问对象（DAO）持久存在并查询实体。对于每个实体，greenDAO 生成DAO。它具有比 DaoSession 更多的持久性方法，例如：count，loadAll 和 insertInTx。
• Entities ：可持久化对象。通常, 实体对象代表一个数据库行使用标准 Java 属性(如一个POJO 或 JavaBean )。

导入 Gradle 插件和 Dao 代码生成

要在 Android 项目中使用 GreenDao，您需要添加 GreenDao Gradle 插件并添加GreenDao 库：

导入插件

// 在 Project的build.gradle 文件中添加:
buildscript {
 repositories {
 jcenter()
 mavenCentral() // add repository
 }
 dependencies {
 classpath 'com.android.tools.build:gradle:3.1.2'
 classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
 }
}

配置相关依赖

// 在 Moudle:app的 build.gradle 文件中添加:
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // apply plugin
dependencies {
 implementation 'org.greenrobot:greendao:3.2.2' // add library
}

配置数据库相关信息

greendao {
 schemaVersion 1 //数据库版本号
 daoPackage 'com.aserbao.aserbaosandroid.functions.database.greenDao.db'
// 设置DaoMaster、DaoSession、Dao 包名
 targetGenDir 'src/main/java'//设置DaoMaster、DaoSession、Dao目录
 generateTests false //设置为true以自动生成单元测试。
 targetGenDirTests 'src/main/java' //应存储生成的单元测试的基本目录。默认为 src / androidTest / java。
}

GreenDao初始化

我们可以在Application中维持一个全局的会话。我们在 Applicaiton 进行数据库的初始化操作：

 /**
 * 初始化GreenDao,直接在Application中进行初始化操作
 */
 private void initGreenDao() {
 DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "aserbao.db");
 SQLiteDatabase db = helper.getWritableDatabase();
 DaoMaster daoMaster = new DaoMaster(db);
 daoSession = daoMaster.newSession();
 }
 private DaoSession daoSession;
 public DaoSession getDaoSession() {
 return daoSession;
 }

创建存储对象实体类

使用 GreenDao 存储数据只需要在存储数据类前面声明 @Entity 注解就让 GreenDao 为其生成必要的代码：

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Unique
 int studentNo;//学号
 int age; //年龄
 String telPhone;//手机号
 String sex; //性别
 String name;//姓名
 String address;//家庭住址
 String schoolName;//学校名字
 String grade;//几年级
 ……getter and setter and constructor method……
 }

这时候重新 build 一下项目会发现在设置的 targetGenDir 的目录生成三个类文件，这个是GreenDao 自动生成的！

使用 GreenDao 实现增删改查

• 增

insert() 插入数据

@Override
 public void insertData(Thing s) {
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 for (int i = 0; i < 1000; i++) {
 Student student = new Student();
 student.setStudentNo(i);
 int age = mRandom.nextInt(10) + 10;
 student.setAge(age);
 student.setTelPhone(RandomValue.getTel());
 String chineseName = RandomValue.getChineseName();
 student.setName(chineseName);
 if (i % 2 == 0) {
 student.setSex("男");
 } else {
 student.setSex("女");
 }
 student.setAddress(RandomValue.getRoad());
 student.setGrade(String.valueOf(age % 10) + "年纪");
 student.setSchoolName(RandomValue.getSchoolName());
 daoSession.insert(student);
 }
 }

insertOrReplace()**数据存在则替换，数据不存在则插入

@Override
 public void insertData(Thing s) {
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 for (int i = 0; i < 1000; i++) {
 Student student = new Student();
 student.setStudentNo(i);
 int age = mRandom.nextInt(10) + 10;
 student.setAge(age);
 student.setTelPhone(RandomValue.getTel());
 String chineseName = RandomValue.getChineseName();
 student.setName(chineseName);
 if (i % 2 == 0) {
 student.setSex("男");
 } else {
 student.setSex("女");
 }
 student.setAddress(RandomValue.getRoad());
 student.setGrade(String.valueOf(age % 10) + "年纪");
 student.setSchoolName(RandomValue.getSchoolName());
 daoSession.insertOrReplace(student);//插入或替换
 }
 }

• 删

删除有两种方式：delete()和 deleteAll()；分别表示删除单个和删除所有。

@Override
 public void deleteData(Student s) {
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 daoSession.delete(s);
 }

@Override
 public void deleteAll() {
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 daoSession.deleteAll(Student.class);
 }

• 改

通过 update 来进行修改：

@Override
 public void updataData(Student s) {
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 daoSession.update(s);
 }

• 查

查询的方法有：

• loadAll()：查询所有数据。
• queryRaw()：根据条件查询。
• queryBuilder() : 方便查询的创建，后面详细讲解。

public List queryAll(){
 List students = daoSession.loadAll(Student.class);
 return students;
 }
@Override
 public void queryData(String s) {
 List students = daoSession.queryRaw(Student.class, " where id = ?", s);
 mDataBaseAdapter.addNewStudentData(students);
 }

QueryBuilder的使用

编写 SQL 可能很困难并且容易出现错误，这些错误仅在运行时才会被注意到。该QueryBuilder 的类可以让你建立你的实体，而不 SQL 自定义查询，并有助于在编译时已检测错误。

我们先讲下 QueryBuilder 的常见方法：

• where(WhereCondition cond, WhereCondition… condMore): 查询条件，参数为查询的条件！
• or(WhereCondition cond1, WhereCondition cond2, WhereCondition… condMore): 嵌套条件或者，用法同 or。
• and(WhereCondition cond1, WhereCondition cond2, WhereCondition… condMore): 嵌套条件且，用法同 and。
• join(Property sourceProperty, Class destinationEntityClass):多表查询，后面会讲。
• 输出结果有四种方式，选择其中一种最适合的即可，list()返回值是 List,而其他三种返回值均实现 Closeable,需要注意的不使用数据时游标的关闭操作：
• list （）所有实体都加载到内存中。结果通常是一个没有魔法的 ArrayList。最容易使用。
• listLazy （）实体按需加载到内存中。首次访问列表中的元素后，将加载并缓存该元素以供将来使用。必须关闭。
• listLazyUncached （）实体的“虚拟”列表：对列表元素的任何访问都会导致从数据库加载其数据。必须关闭。
• listIterator （）让我们通过按需加载数据（懒惰）来迭代结果。数据未缓存。必须关闭。

GreenDao 中 SQL 语句的缩写，我们也了解下，源码在Property中,使用的时候可以自己点进去查询即可：

• eq()：“equal (’=?’)” 等于；
• notEq() ：“not equal (’<>?’)” 不等于；
• like()：" LIKE ?" 值等于；
• between()：" BETWEEN ? AND ?" 取中间范围；
• in()：" IN (" in命令;
• notIn()：" NOT IN (" not in 命令;
• gt()：">?" 大于;
• lt()："
• ge()：">=?" 大于等于;
• le()："<=? " 小于等于;
• isNull()：" IS NULL" 为空;
• isNotNull()：" IS NOT NULL" 不为空;

使用QueryBuilder进行查询操作

• 简单条件查询

查询当前Student表的所有的数据：

 public List queryAllList(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 QueryBuilder qb = daoSession.queryBuilder(Student.class);
 List list = qb.list(); // 查出所有的数据
 return list;
 }

查询 Name 为“一”的所有 Student:

public List queryListByMessage(String name){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 QueryBuilder qb = daoSession.queryBuilder(Student.class);
 QueryBuilder studentQueryBuilder = qb.where(StudentDao.Properties.Name.eq("一")).orderAsc(StudentDao.Properties.Name);
 List studentList = studentQueryBuilder.list(); //查出当前对应的数据
 return list;
 }

• 原始查询

通过原始的 SQL 查询语句进行查询！其实上面有提到 QueryBuilder 的目的就是方便快捷的编写 SQL 查询语句，避免我们自己在编写过程中出错！简单介绍下通过 QueryBuilder 编写数据库，方式方法如下 ：

public List queryListBySqL(){
// 查询ID大于5的所有学生
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 Query query = daoSession.queryBuilder(Student.class).where(
 new WhereCondition.StringCondition("_ID IN " +
 "(SELECT _ID FROM STUDENT WHERE _ID > 5)")
 ).build();
 List list = query.list();
 return list;
 }

• 嵌套条件查询

查询 Id 大于5小于10，且 Name 值为"一"的数据：

public List queryList(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 QueryBuilder qb = daoSession.queryBuilder(Student.class);
 qb = daoSession.queryBuilder(Student.class);
 List list2 = qb.where(StudentDao.Properties.Name.eq("一"),
 qb.and(StudentDao.Properties.Id.gt(5),
 StudentDao.Properties.Id.le(50))).list();
 return list2;
 }

取10条 Id 大于1的数据，且偏移2条

 public List queryListByOther(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 QueryBuilder qb = daoSession.queryBuilder(Student.class);
 //搜索条件为Id值大于1，即结果为[2,3,4,5,6,7,8,9,10,11];
 // offset(2)表示往后偏移2个，结果为[4,5,6,7,8,9,10,11,12,13];
 List list = qb.where(StudentDao.Properties.Id.gt(1)).limit(10).offset(2).list();
 return list;
 }
！

• 多次执行查找

使用 QueryBuilder 构建查询后，可以重用 Query 对象以便稍后执行查询。这比始终创建新的 Query 对象更有效。如果查询参数没有更改，您可以再次调用 list / unique 方法。可以通过 setParameter 方法来修改条件参数值：

public List queryListByMoreTime(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 QueryBuilder qb = daoSession.queryBuilder(Student.class);
 //搜索条件为Id值大于1，即结果为[2,3,4,5,6,7,8,9,10,11];
 // offset(2)表示往后偏移2个，结果为[4,5,6,7,8,9,10,11,12,13];
 Query query = qb.where(StudentDao.Properties.Id.gt(1)).limit(10).offset(2).build();
 List list = query.list();
 //通过SetParameter来修改上面的查询条件，比如我们将上面条件修改取10条Id值大于5，往后偏移两位的数据，方法如下！
 query.setParameter(0,5);
 List list1 = query.list();
 return list1;
 }

• 在多个线程中使用 QueryBuilder

如果在多个线程中使用查询，则必须调用 forCurrentThread （）以获取当前线程的 Query实例。Query 的对象实例绑定到构建查询的拥有线程。

这使您可以安全地在 Query 对象上设置参数，而其他线程不会干扰。如果其他线程尝试在查询上设置参数或执行绑定到另一个线程的查询，则会抛出异常。像这样，您不需要同步语句。实际上，您应该避免锁定，因为如果并发事务使用相同的 Query 对象，这可能会导致死锁。

每次调用 forCurrentThread （）时， 参数都会在使用其构建器构建查询时设置为初始参数。

使用QueryBuilder进行批量删除操作

使用 QueryBuilder 进行批量删除操作，不会删除单个实体，但会删除符合某些条件的所有实体。要执行批量删除，请创建 QueryBuilder，调用其 buildDelete （）方法，然后执行返回的 DeleteQuery。

例子：删除数据库中id大于5的所有其他数据

public boolean deleteItem(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 QueryBuilder where = daoSession.queryBuilder(Student.class).where(StudentDao.Properties.Id.gt(5));
 DeleteQuery deleteQuery = where.buildDelete();
 deleteQuery.executeDeleteWithoutDetachingEntities();
 return false;
 }

注解讲解

从 GreenDao 3 使用注解来定义模型和实体，前面也讲过，通过注解的使用可以快速构建数据库表，包括设置主键，自增，值是否唯一等等等……

下面我们来看下注解的简单使用：

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Unique
 int studentNo;//学号
 int age; //年龄
 String telPhone;//手机号
 String sex; //性别
 String name;//姓名
 String address;//家庭住址
 String schoolName;//学校名字
 String grade;//几年级
 ……getter and setter and constructor method……
 }

@Entity 注解

@Entity 是 GreenDao 必不可少的注解，只有在实体类中使用了@Entity 注解 GreenDao 才会创建对应的表。当然我们也可以使用@Entity 配置一些细节：

• schema：如果你有多个架构，你可以告诉 GreenDao 当前属于哪个架构。
• active：标记一个实体处于活跃状态，活动实体有更新、删除和刷新方法。
• nameInDb：在数据中使用的别名，默认使用的是实体的类名。
• indexes：标记如果 DAO 应该创建数据库表(默认为true)，如果您有多个实体映射到一个表，或者表的创建是在 greenDAO 之外进行的，那么将其设置为 false。
• createInDb：标记创建数据库表。
• generateGettersSetters：如果缺少，是否应生成属性的 getter 和 setter 方法。

@Entity(
 schema = "myschema",
 active = true,
 nameInDb = "AWESOME_USERS",
 indexes = {
 @Index(value = "message DESC", unique = true)
 },
 createInDb = false,
 generateConstructors = true,
 generateGettersSetters = true
)
public class Student{
……
}

基础属性注解（@Id，@Property，@NotNull，@Transient）

• @Id

@Id注解选择 long / Long属性作为实体 ID。在数据库方面，它是主键。参数autoincrement = true 表示自增，id 不给赋值或者为赋值为 null 即可（这里需要注意，如果要实现自增，id 必须是 Long,为 long 不行！)。

• @Entity

public class Student {
 @Id(autoincrement = true)
 Long id;
 ……
}

• @Property

允许您定义属性映射到的非默认列名。如果不存在，GreenDAO 将以 SQL-ish 方式使用字段名称（大写，下划线而不是 camel 情况，例如 name 将成为 NAME）。注意：您当前只能使用内联常量来指定列名。

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Property (nameInDb="name") //设置了，数据库中的表格属性名为"name",如果不设置，数据库中表格属性名为"NAME"
 String name;
 ……
}

• @NotNull

设置数据库表当前列不能为空 。

• @Transient

添加次标记之后不会生成数据库表的列。标记要从持久性中排除的属性。将它们用于临时状态等。或者，您也可以使用 Java 中的 transient 关键字。

索引注解

• @Index：使用@Index 作为一个属性来创建一个索引，通过 name 设置索引别名，也可以通过unique给索引添加约束。
• @Unique：向索引添加 UNIQUE 约束，强制所有值都是唯一的。

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Property(nameInDb="name")
 @Index(unique = true)
 String name;
 ……
}

注意： 上面这种情况，约定 name 为唯一值，向数据库中通过 insert 方法继续添加已存在的name 数据，会抛异常：

10-08 20:59:46.274 31939-31939/com.example.aserbao.aserbaosandroid E/AndroidRuntime: FATAL EXCEPTION: main
 Process: com.example.aserbao.aserbaosandroid, PID: 31939
 android.database.sqlite.SQLiteConstraintException: UNIQUE constraint failed: STUDENT.name (Sqlite code 2067), (OS error - 2:No such file or directory)
 ……

若使用 insertOrReplace()方法添加数据，当前数据库中不会有重复的数据，但是重复的这条数据的 id 会被修改！若项目中有用到 id 字段进行排序的话，这一点需要特别注意。

关系注解

关系型注解 GreenDao 中主要就两个：

• @ToOne：定义与另一个实体（一个实体对象）的关系
• @ToMany：定义与多个实体对象的关系

至于如何使用，我们马上就讲。

关系表的创建

平常项目中，我们经常会使用到多表关联，如文章开头所说的数据库表结构设置的那样！接下来我们来讲如何通过GreenDao实现多表关联。

一对一

一个学生对应一个身份证号:

做法：

• 我们在 Student 中设置一个注解@ToOne(joinProperty = “name”)
• 在创建 Student 的时候，将对应的数据传递给 IdCard;
• 代码部分

学生 Student 代码

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Unique
 int studentNo;//学号
 int age; //年龄
 String telPhone;//手机号
 String sex; //性别
 String name;//姓名
 String address;//家庭住址
 String schoolName;//学校名字
 String grade;//几年级
 @ToOne(joinProperty = "name")
 IdCard student;
 ……getter and setter ……
}

身份证 IdCard 代码

@Entity
public class IdCard {
 @Id 
 String userName;//用户名
 @Unique
 String idNo;//身份证号
 ……getter and setter ……
}

insert 一组数据

public void addStudent(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 Student student = new Student();
 student.setStudentNo(i);
 int age = mRandom.nextInt(10) + 10;
 student.setAge(age);
 student.setTelPhone(RandomValue.getTel());
 String chineseName = RandomValue.getChineseName();
 student.setName(chineseName);
 if (i % 2 == 0) {
 student.setSex("男");
 } else {
 student.setSex("女");
 }
 student.setAddress(RandomValue.getRoad());
 student.setGrade(String.valueOf(age % 10) + "年纪");
 student.setSchoolName(RandomValue.getSchoolName());
 daoSession.insert(student);
 //插入对应的IdCard数据
 IdCard idCard = new IdCard();
 idCard.setUserName(userName);
 idCard.setIdNo(RandomValue.getRandomID());
 daoSession.insert(idCard);
 }

ok,数据可以了！现在数据库表插入完成了。

一对多

一个人拥有多个信用卡

做法：

• 在我们在 Student 中设置@ToMany(referencedJoinProperty = “id”);
• 我们在 CreditCard 中设置编写对应的id主键；

Student 的代码

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Unique
 int studentNo;//学号
 int age; //年龄
 String telPhone;//手机号
 String sex; //性别
 String name;//姓名
 String address;//家庭住址
 String schoolName;//学校名字
 String grade;//几年级
 @ToMany(referencedJoinProperty = "id") // 这个id是对应在CreditCard中的id
 List creditCardsList;
 ……getter and setter ……
 }

CreditCard 的代码

@Entity
public class CreditCard {
 @Id
 Long id;
 Long userId;
 String userName;//持有者名字
 String cardNum;//卡号
 String whichBank;//哪个银行的
 int cardType;//卡等级，分类 0 ~ 5 
 ……getter and setter ……
 }

添加数据代码

public void addStudent(){
 DaoSession daoSession = ((AserbaoApplication) getApplication()).getDaoSession();
 Student student = new Student();
 student.setStudentNo(i);
 int age = mRandom.nextInt(10) + 10;
 student.setAge(age);
 student.setTelPhone(RandomValue.getTel());
 String chineseName = RandomValue.getChineseName();
 student.setName(chineseName);
 if (i % 2 == 0) {
 student.setSex("男");
 } else {
 student.setSex("女");
 }
 student.setAddress(RandomValue.getRoad());
 student.setGrade(String.valueOf(age % 10) + "年纪");
 student.setSchoolName(RandomValue.getSchoolName());
 daoSession.insert(student);
 //插入对应的CreditCard数据
 for (int j = 0; j < random.nextInt(5) + 1 ; j++) {
 CreditCard creditCard = new CreditCard();
 creditCard.setUserId(id);
 creditCard.setUserName(userName);
 creditCard.setCardNum(String.valueOf(random.nextInt(899999999) + 100000000) + String.valueOf(random.nextInt(899999999) + 100000000));
 creditCard.setWhichBank(RandomValue.getBankName());
 creditCard.setCardType(random.nextInt(10));
 daoSession.insert(creditCard);
 }
 }

多对多

一个学生有多个老师，老师有多个学生。

• 做法

我们需要创建一个学生老师管理器(StudentAndTeacherBean)，用来对应学生和老师的ID;

我们需要在学生对象中，添加注解：

@ToMany
@JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = “studentId”,targetProperty = “teacherId”)
List teacherList;

我们需要在老师对象中，添加注解：

@ToMany
@JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = “teacherId”,targetProperty = “studentId”)
List studentList;

StudentAndTeacherBean 代码

@Entity
public class StudentAndTeacherBean {
 @Id(autoincrement = true)
 Long id;
 Long studentId;//学生ID
 Long teacherId;//老师ID
 ……getter and setter ……
}

Student 代码

@Entity
public class Student {
 @Id(autoincrement = true)
 Long id;
 @Unique
 int studentNo;//学号
 int age; //年龄
 String telPhone;//手机号
 String sex; //性别
 String name;//姓名
 String address;//家庭住址
 String schoolName;//学校名字
 String grade;//几年级
 @ToMany
 @JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = "studentId",targetProperty = "teacherId")
 List teacherList;
 ……getter and setter ……
 }

Teacher 代码

@Entity
public class Teacher {
 @Id(autoincrement = true)
 Long id;
 @Unique
 int teacherNo;//职工号
 int age; //年龄
 String sex; //性别
 String telPhone;
 String name;//姓名
 String schoolName;//学校名字
 String subject;//科目
 @ToMany
 @JoinEntity(entity = StudentAndTeacherBean.class,sourceProperty = "teacherId",targetProperty = "studentId")
 List studentList;
 ……getter and setter ……
}

数据添加：

public void addData(){
 Student student = new Student();
 student.setStudentNo(i);
 int age = mRandom.nextInt(10) + 10;
 student.setAge(age);
 student.setTelPhone(RandomValue.getTel());
 String chineseName = RandomValue.getChineseName();
 student.setName(chineseName);
 if (i % 2 == 0) {
 student.setSex("男");
 } else {
 student.setSex("女");
 }
 student.setAddress(RandomValue.getRoad());
 student.setGrade(String.valueOf(age % 10) + "年纪");
 student.setSchoolName(RandomValue.getSchoolName());
 daoSession.insert(student);
 Collections.shuffle(teacherList);
 for (int j = 0; j < mRandom.nextInt(8) + 1; j++) {
 if(j < teacherList.size()){
 Teacher teacher = teacherList.get(j);
 StudentAndTeacherBean teacherBean = new StudentAndTeacherBean(student.getId(), teacher.getId());
 daoSession.insert(teacherBean);
 }
 }
 }

好了，成功;

GreenDao数据库加密

开发中对于存储于数据库中的敏感数据，我们可以通过对数据库加密来进行保护。GreenDao 可以通过 SQLCipher 来进行加密处理。下面我们简单讲解下加密过程：

• 步骤

导入加密库文件

implementation 'net.zetetic:android-database-sqlcipher:3.5.6'

修改 DaoSession 的生成方式

// MyDaoMaster helper = new MyDaoMaster(this, "aserbaos.db"); //数据库升级写法
 DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "aserbao.db");
 //SQLiteDatabase db = helper.getWritableDatabase(); //不加密的写法
 Database db = helper.getEncryptedWritableDb("aserbao"); //数据库加密密码为“aserbao"的写法
 DaoMaster daoMaster = new DaoMaster(db);
 daoSession = daoMaster.newSession();

总结

当前文章所有代码在AserbaosAndroid/app/src/main/java/com/aserbao/aserbaosandroid/functions/database/greenDao/relation目录下；（不过就我这脾气，可能在今后整理代码的过程中会修改！不过请放心，修改后会在github上进行说明的）

AserbaosAndroid项目地址如下所示：

https://github.com/aserbao/AserbaosAndroid

aserbao 的个人 Android 总结项目，希望这个项目能成为最全面的 Android 开发学习项目，这是个美好的愿景，项目中还有很多未涉及到的地方，有很多没有讲到的点，希望看到这个项目的朋友，如果你在开发中遇到什么问题，在这个项目中没有找到对应的解决办法，希望你能够提出来，给我留言或者在项目github地址提issues,我有时间就会更新项目没有涉及到的部分！项目会一直维护下去。当然，我希望是Aserbao’sAndroid 能为所有Android开发者提供到帮助！也期望更多Android开发者能参与进来，只要你熟悉Android某一块，都可以将你的代码pull上分支！

这篇文章写到这里，零零碎碎花了差不多两周时间，从十月八号开始到今天正式准备发布，也算是对 GreenDao 数据库的进一步认识！如文章开头所说，我 Android 开发之初，使用的是自己编写 SQLite 来实现数据库存储，到后来使用第三方存储 LitePal，最近，项目早期就使用了 GreenDao，所以就又得学习一番 GreenDao。对于开发者来说，我觉得无论是这三种中的哪一种，其实只要掌握一种我觉得就足够了！当然如果你有时间，可以多学习几种，多学无害嘛！