GreenDao3.0使用详解

随着移动端的业务量的增大和用户体验的提高，SQLite的需求很明显了，大大小小的项目几乎成了必备，用我们项目经理的话来说：

1、不用管他什么数据，为了体验，先缓存一下！

2、什么？网络不好导致的？看什么，缓存啊！！！

真不知道他是在哪里听到的这个词，唉！

在他看来，缓存是如此简单的一件事情，当然，缓存其实并不难，就是有点麻烦而已！

之前我一直是用Realm，目前Realm被人称为移动端的新一代王者，但是对于知识，哪有嫌多的呢。

一、GreenDao和Realm对比

我在网上找了一张图片，很能说明问题：

在小量数据的查询与删除等操作中，两者的差距基本可以忽略不计,超过同时插入、删除、查询1000条以上的数据分析得出。GreenDao在删除操作中，占明显优势，而Realm在添加与查询方面优于GreenDAO。各有千秋，看自己的选择。

二、GreenDao配置

1、导入相应的包

[java]  view plain  copy

1. compile'org.greenrobot:greendao:3.0.1'  
2. compile'org.greenrobot:greendao-generator:3.0.0'  

2、配置app的Gradle

[java]  view plain  copy

1. apply plugin: 'org.greenrobot.greendao'  
2.   
3. buildscript {  
4.     repositories {  
5.         mavenCentral()  
6.     }  
7.     dependencies {  
8.         classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'  
9.     }  
10. }  
11.   
12. greendao {  
13.     schemaVersion 1  
14.     daoPackage 'com.example.anonymous.greendao.gen'  
15.     targetGenDir 'src/main/java'  
16. }  

3、配置greenDao

[java]  view plain  copy

1. greendao {  
2.     schemaVersion 1  
3.     daoPackage 'com.example.anonymous.greendao'  
4.     targetGenDir 'src/main/java'  
5. }  

 schemaVersion---->指定数据库schema版本号，迁移等操作会用到
 daoPackage-------->通过gradle插件生成的数据库相关文件，这里我设置的文件路径是com.example.anonymous.greendao
 targetGenDir-------->这就是我们上面说到的自定义生成数据库文件的目录了，可以将生成的文件放到我们的java目录中，而不是build中，这样就不用额外的设置资源目录了

整体配置预览：

[java]  view plain  copy

1. apply plugin: 'com.android.application'  
2. apply plugin: 'org.greenrobot.greendao'  
3.   
4. buildscript {  
5.     repositories {  
6.         mavenCentral()  
7.     }  
8.     dependencies {  
9.         classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'  
10.     }  
11. }  
12.   
13. greendao {  
14.     schemaVersion 1  
15.     daoPackage 'com.example.anonymous.greendao'  
16.     targetGenDir 'src/main/java'  
17. }  
18.   
19. android {  
20.     compileSdkVersion 25  
21.     buildToolsVersion "25.0.2"  
22.     defaultConfig {  
23.         applicationId "com.example.anonymous.realmdemo"  
24.         minSdkVersion 15  
25.         targetSdkVersion 25  
26.         versionCode 1  
27.         versionName "1.0"  
28.         testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"  
29.     }  
30.     buildTypes {  
31.         release {  
32.             minifyEnabled false  
33.             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'  
34.         }  
35.     }  
36. }  
37.   
38. dependencies {  
39.     compile fileTree(dir: 'libs', include: ['*.jar'])  
40.     compile 'com.android.support:appcompat-v7:25.0.1'  
41.     compile'org.greenrobot:greendao:3.0.1'  
42.     compile'org.greenrobot:greendao-generator:3.0.0'  
43. }  

三、编写实体类（对应的是数据库的每张表）

[java]  view plain  copy

1. @Entity  
2. public class User {  
3.     @Id  
4.     private Long id;  
5.     private String name;  
6. }  

@Entity：将我们的java普通类变为一个能够被greenDAO识别的数据库类型的实体类
@Id：通过这个注解标记的字段必须是Long类型的，这个字段在数据库中表示它就是主键，并且它默认就是自增的

就这么简单含有两个字段的实体类

然后点击这个按钮

builder完之后会有两个地方发生了变化

这是GreenDao自动为你生成的，路径就是你在gradle中配置的路径

现在只有一个User表，如果再添加一个Age实体类，你在点击Make Project按钮，他还会把AgeDao自动生成出来

四、增、删、改、查

在增、删、改、查之前第一步做的就是需要对数据库进行初始化，不可能就这样直接对实体类操作，这样不太现实的，否则为什么GreenDao会自动生成这么多代码呢？

[java]  view plain  copy

1. DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(MyApplication.getContext(), "my-db", null);    
2. DaoMaster daoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());    
3. DaoSession daoSession = daoMaster.newSession();    
4. UserDao userDao = daoSession.getUserDao();    

my-db是数据库的名字，自己随便写就行。

通过GreenDao生成的代码，我们可以获取到实体类的实例，也就是数据库表的实例，这样我们才能操作数据库

1、增加

[java]  view plain  copy

1. User user1 = new User(null,"zhangsan");  
2. userDao.insert(user1);  

2、删除

[java]  view plain  copy

1. User findUser = userDao.queryBuilder().where(UserDao.Properties.Name.eq("zhangsan")).build().unique();    
2. if(findUser != null){    
3.     userDao.deleteByKey(findUser.getId());    
4. }    

3、修改

[java]  view plain  copy

1. User findUser = userDao.queryBuilder().where(UserDao.Properties.Name.eq("zhangsan")).build().unique();    
2. if(findUser != null) {    
3.     findUser.setName("lisi");    
4.     userDao.update(findUser);    
5.     Toast.makeText(MyApplication.getContext(), "修改成功", Toast.LENGTH_SHORT).show();    
6. } else {    
7.     Toast.makeText(MyApplication.getContext(), "用户不存在", Toast.LENGTH_SHORT).show();    
8. }    

把zhangsan改成lisi

4、查询

[java]  view plain  copy

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

查询语句是数据库操作最多的，语句也比较复杂，具体的语句请去看官网

简单封装

其实这样写代码，作为程序员并不能满足，最起码的重用还是需要的，所以简单的封装一下吧

我们需要添加几个类来负责代码的重用工作，先看一下整体的工程结构：

1、MyApplication：返回Context对象

2、DaoManager：初始化数据库，获取相应的操作对象

3、EntityManager：对数据库表的初始化，获取实体类的操作对象

[java]  view plain  copy

1. public class MyApplication extends Application {  
2.     private static Context mContext;  
3.   
4.     @Override  
5.     public void onCreate() {  
6.         super.onCreate();  
7.         mContext = getApplicationContext();  
8.     }  
9.   
10.     public static Context getContext() {  
11.         return mContext;  
12.     }  
13. }  

[java]  view plain  copy

1. /** 
2.  *  greenDao管理类 
3.  */  
4. public class DaoManager {  
5.     private static DaoManager mInstance;  
6.     private DaoMaster mDaoMaster;  
7.     private DaoSession mDaoSession;  
8.   
9.     private DaoManager() {  
10.         DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(MyApplication.getContext(), "my-db", null);  
11.         DaoMaster mDaoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());  
12.         mDaoSession = mDaoMaster.newSession();  
13.     }  
14.   
15.     public DaoMaster getMaster() {  
16.         return mDaoMaster;  
17.     }  
18.   
19.     public DaoSession getSession() {  
20.         return mDaoSession;  
21.     }  
22.   
23.     public static DaoManager getInstance() {  
24.         if (mInstance == null) {  
25.             mInstance = new DaoManager();  
26.         }  
27.         return mInstance;  
28.     }  
29. }  

[java]  view plain  copy

1. public class EntityManager {  
2.     private static EntityManager entityManager;  
3.     public UserDao userDao;  
4.   
5.     /** 
6.      * 创建User表实例 
7.      * 
8.      * @return 
9.      */  
10.     public UserDao getUserDao(){  
11.         userDao = DaoManager.getInstance().getSession().getUserDao();  
12.         return userDao;  
13.     }  
14.   
15.     /** 
16.      * 创建单例 
17.      * 
18.      * @return 
19.      */  
20.     public static EntityManager getInstance() {  
21.         if (entityManager == null) {  
22.             entityManager = new EntityManager();  
23.         }  
24.         return entityManager;  
25.     }  
26. }  

三个东西一看便知，但是这个东西怎么用呢？

[java]  view plain  copy

1. // TODO: 2017/1/1 一句话就把相应的数据库表的实例返回，进行操作    
2. UserDao userDao = EntityManager.getInstance().getUserDao();  
3. User user1 = new User(null,"zhangsan");  
4. userDao.insert(user1);  

DaoManager和EntityManager主要作用是对数据库和表的初始化工作抽出来作为复用，在Activity中使用的时候，我们可以直接操作表，不需要在初始化工作了，这篇文章作为我的学习笔记，希望也能为看到的朋友提供帮助！