GreenDao3.1用法详解

greenDAO是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库，它能够让你操作数据库时更简单、更方便。

GreenDao 优点：

1.性能高，号称Android最快的关系型数据库
2.内存占用小
3.库文件比较小，小于100K
4.支持数据库加密 greendao支持SQLCipher进行数据库加密
5.简洁易用的API

GreenDao 3.1改动：

GreenDao 3.0最大的变化就是采用注解的方式通过编译方式生成Java数据对象和DAO对象，3.0之前需要通过新建GreenDaoGenerator工程生成Java数据对象和DAO对象，非常的繁琐。

GreenDao 3.1使用方式：

第一步：在 项目 的Build.gradle中添加如下配置：

[java]  view plain  copy

1. buildscript {  
2.     repositories {  
3.         jcenter()  
4.         mavenCentral()  
5.     }  
6.     dependencies {  
7.         classpath 'com.android.tools.build:gradle:1.5.0'  
8.         classpath 'org.greenrobot:greendao-gradle-plugin:3.1.0'  
9.     }  
10. }  

第二步：导入

compile 'org.greenrobot:greendao:3.1.1'
compile 'org.greenrobot:greendao-generator:3.1.0'

第三步：添加配置

红色方框中字段解释：

schemaVersion： 数据库schema版本，也可以理解为数据库版本号
daoPackage：设置DaoMaster、DaoSession、Dao包名
targetGenDir：设置DaoMaster、DaoSession、Dao目录
targetGenDirTest：设置生成单元测试目录
generateTests：设置自动生成单元测试用例

第四步：写实体类

[java]  view plain  copy

1. @Entity  
2. public class User {  
3.     @Id(autoincrement = true)  
4.     private Long id;  
5.     private String name;  
6.     private int age;  
7.     private boolean isBoy;  
8. }  

make project后变成会自动帮你生成get/set方法，如下:

[java]  view plain  copy

1. @Entity  
2. public class User {  
3.     @Id(autoincrement = true)  
4.     private Long id;  
5.     private String name;  
6.     private int age;  
7.     private boolean isBoy;  
8.     public boolean getIsBoy() {  
9.         return this.isBoy;  
10.     }  
11.     public void setIsBoy(boolean isBoy) {  
12.         this.isBoy = isBoy;  
13.     }  
14.     public int getAge() {  
15.         return this.age;  
16.     }  
17.     public void setAge(int age) {  
18.         this.age = age;  
19.     }  
20.     public String getName() {  
21.         return this.name;  
22.     }  
23.     public void setName(String name) {  
24.         this.name = name;  
25.     }  
26.     public Long getId() {  
27.         return this.id;  
28.     }  
29.     public void setId(Long id) {  
30.         this.id = id;  
31.     }  
32.     @Generated(hash = 1724489812)  
33.     public User(Long id, String name, int age, boolean isBoy) {  
34.         this.id = id;  
35.         this.name = name;  
36.         this.age = age;  
37.         this.isBoy = isBoy;  
38.     }  
39.     @Generated(hash = 586692638)  
40.     public User() {  
41.     }  
42. }  

第五步：封装GreenDao调用方法：

[java]  view plain  copy

1. public class GreenDaoUtils {  
2.   
3.     private DaoMaster.DevOpenHelper mHelper;  
4.     private SQLiteDatabase db;  
5.     private DaoMaster mDaoMaster;  
6.     private DaoSession mDaoSession;  
7.   
8.     private static GreenDaoUtils greenDaoUtils;  
9.   
10.     private GreenDaoUtils(){}  
11.   
12.     public static GreenDaoUtils getSingleTon(){  
13.         if (greenDaoUtils==null){  
14.             greenDaoUtils=new GreenDaoUtils();  
15.         }  
16.         return greenDaoUtils;  
17.     }  
18.   
19.     private void initGreenDao(){  
20.         mHelper=new DaoMaster.DevOpenHelper(MyApplication.getApplication(),"test-db",null);  
21.         db=mHelper.getWritableDatabase();  
22.         mDaoMaster=new DaoMaster(db);  
23.         mDaoSession=mDaoMaster.newSession();  
24.     }  
25.   
26.     public DaoSession getmDaoSession() {  
27.         if (mDaoMaster==null){  
28.             initGreenDao();  
29.         }  
30.         return mDaoSession;  
31.     }  
32.   
33.     public SQLiteDatabase getDb() {  
34.         if (db==null){  
35.             initGreenDao();  
36.         }  
37.         return db;  
38.     }  
39.   
40. }  

第六步：执行增删改查

[java]  view plain  copy

1. UserDao dao=GreenDaoUtils.getSingleTon().getmDaoSession().getUserDao();  

[java]  view plain  copy

1. public void onClick(View v) {  
2.         switch (v.getId()){  
3.             case R.id.btn_c:  
4.                 User insertData=new User(null,edit_name.getText().toString(),21,false);  
5.                 dao.insert(insertData);  
6.                 break;  
7.             case R.id.btn_r:  
8.                 List<User> users = dao.loadAll();  
9.                 for (int i=0;i<users.size();i++){  
10.                     Log.i("woyaokk","结果："+users.get(i).toString());  
11.                 }  
12.                 break;  
13.             case R.id.btn_u:  
14.                 List<User> userss = dao.loadAll();  
15.                 User user=new User(userss.get(0).getId(),edit_name.getText().toString(),22,true);  
16.                 dao.update(user);  
17.                 break;  
18.             case R.id.btn_d:  
19.                 String s = edit_id.getText().toString();  
20.                 long l = Long.parseLong(s);  
21.                 dao.deleteByKey(l);  
22.                 break;  
23.         }  
24.     }  

以上即为GreenDao的简单使用方法，接下来详细讲解其中的一些API。

API：

1.）实体@Entity注解

schema：告知GreenDao当前实体属于哪个schema
active：标记一个实体处于活动状态，活动实体有更新、删除和刷新方法
nameInDb：在数据中使用的别名，默认使用的是实体的类名
indexes：定义索引，可以跨越多个列
createInDb：标记创建数据库表**

2.）基础属性注解

@Id :主键 Long型，可以通过@Id(autoincrement = true)设置自增长
@Property：设置一个非默认关系映射所对应的列名，默认是的使用字段名举例：@Property (nameInDb="name")
@NotNul：设置数据库表当前列不能为空
@Transient：添加次标记之后不会生成数据库表的列

3.)索引注解

@Index：使用@Index作为一个属性来创建一个索引，通过name设置索引别名，也可以通过unique给索引添加约束
@Unique：向数据库列添加了一个唯一的约束

4.）关系注解

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

在建立数据库时，每一个实体类会建立一张数据表，代表一个关系，而不同实体之间必然存在一定的关系，反映到数据表上也需要建立关系。
比如一个用户的账户都有对应的头像picture，且假设每个用户的头像Picture对象都不同，因此每个picture也对应一个用户，这就是一对一的关系，而在网上购物可以下订单，每个用户可以有多个订单Oder，而每个Oder都对应一个用户User，这是一对多的关系。在数据表的关系中可以通过外键表示这种一对一和一对多的关系。除此以外还有多对多的关系，在对象的结构中每个Oder包含多个物品Item，而每个Item也可能包含在多个Oder中，因此这是多对多的关系，在数据表中需要额外的表表示对应关系，如Oder_Item表，表示一个Oder与一个Item具有关系。
在greenDao中，使用@ToOne表示一对一的关系，使用@ToMany表示一对多的关系，而多对多的关系支持度不够好，目前还不完善，使用较为复杂。

• 1. @ToOne
     比如每个用户都有一个对应Picture属性，需要一个pictureId代表这个Picture属性，通过@ToOne(joinProperty = "XXXX")指定pictureId，在数据表中则会有pictureId这一列作为外键，与Picture数据表建立联系，如果你没有指定pictureId, greenDAO也会在数据表中生成一列属性其作用与指定的pictureId相同，而实体类中则可以使用User的Picture属性，代码如下：

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    private Long pictureId;
    @ToOne(joinProperty = "pictureId")
    private Picture picture;

    ....
}

当然greenDAO会为我们生成其他的代码，如构造器，getter和setter等，在代码中可以直接使用user.getPicture()和setPicture，而在数据表中则是pictureId是指向Picture数据表的外键。Picture的实体类如下：

@Entity
public class Picture {
    @Id
    private long pictureId;

    ...
}

• 1. @ToMany
     一对多的关系，定义了一个实体对象对应着多个实体对象，比如一个用户对应多个Order, 在建立数据表示会在目标实体（即一对多的那个多的实体类）的数据表中建立外键，指向源实体类（一对多中的一那个实体类）的数据表。目标数据表中的外键属性由@ToMany(referencedJoinProperty = "XXXX")指定。

如User中添加List<Order> orders属性：

@Entity
public class User {
    @Id
    private Long id;
    private String name;
    private Long pictureId;
    @ToOne(joinProperty = "pictureId")
    private Picture picture;
    @ToOne
    private Picture thumbnailPicture;
    @ToMany(referencedJoinProperty = "ownerId")
    private List<Order> oders;

    ...
}

Order的实例代码为：

@Entity
public class Order {
    @Id
    private long id;
    private long ownerId;

    ...
}

在build->Make Project之后会生成对应代码，此时在代码中可以使用User#getOrders()获取user的所有对应的order的List. 在这种情况下， ownerId是在Order中的外键，指向User的主键Id。

5.）排序算法

[java]  view plain  copy

1. List<User> userList = userDao.queryBuilder()    
2.        .where(UserDao.Properties.Id.notEq(999))    
3.        .orderAsc(UserDao.Properties.Id)    
4.        .limit(5)    
5.        .build().list();  

[java]  view plain  copy

1. QueryBuilder qb = userDao.queryBuilder();  
2. qb.where(Properties.FirstName.eq("Joe"),  
3. qb.or(Properties.YearOfBirth.gt(1970),  
4. qb.and(Properties.YearOfBirth.eq(1970), Properties.MonthOfBirth.ge(10))));  
5. List youngJoes = qb.list();  

当然，也可以通过纯SQL语句去查询，但不推荐。

先通过queryBuilder生成查找构造器，然后写相应条件进行查询

where 条件判断

orderAsc 排序
limit 查询条数
list() 查询结果为一个集合

unique()或uniqueOrThrow()，返回单个结果，如果没有满足条件的结果，前者返回null， 后者抛出异常