GreenDAO 完美解决数据库升级数据丢失问题

安卓开发框架（MVP+主流框架+基类+工具类）--- GreenDAO

IP地址：http://blog.csdn.net/ljy_programmer/article/details/78257528?locationNum=10&fps=1

github 源码地址：https://github.com/yuweiguocn/GreenDaoUpgradeHelper/blob/master/app/src/main/java/com/github/yuweiguocn/demo/greendao/db/MySQLiteOpenHelper.java

原创 2017年10月17日
10:23:42

177

学习/参考地址： 
http://www.jianshu.com/p/4e6d72e7f57a 
http://blog.csdn.net/qq_30379689/article/details/54410838 
http://blog.csdn.net/shineflowers/article/details/53405644

前言

在以前选择数据库框架的时候，接触过GreenDAO，但由于那时的GreenDAO配置起来很繁琐，需要自己创建java库，所以就没使用它。 

但如今在3.0版本后，GreenDAO大大简化了使用流程，加上其本身存取快、体积小、支持缓存、支持加密等优点，使得它成为了一个更受欢迎的ORM解决方案。
附上一张官方提供的，GreenDAO、OrmLite、ActiveAndroid的对比图

介绍

下面分为 配置、建库建表、增删改查、加密、升级、混淆 这几个部分来介绍。

1. 配置

1.1 添加依赖

Project下的build.gradle文件加入

dependencies {
//greendao配置
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
}

1
2
3
4
Module下的build.gradle文件加入

apply plugin: 'org.greenrobot.greendao'

dependencies {
//greenDAO配置
compile 'org.greenrobot:greendao:3.2.0'
}

1
2
3
4
5
6

1.2 设置版本号、生成路径

android {
//greendao配置
greendao {
//数据库版本号，升级时修改
schemaVersion 1
//生成的DAO，DaoMaster和DaoSession的包路径。默认与表实体所在的包路径相同
daoPackage 'com.dev.base.model.db'
//生成源文件的路径。默认源文件目录是在build目录中的(build/generated/source/greendao)
targetGenDir 'src/main/java'
}
}

1
2
3
4
5
6
7
8
9
10
11

2. 建库建表

2.1 创建数据库

//DaoMaster为后面创建表实体后自动生成的类。
DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "test.db", null);

1
2

2.2 创建数据表

GreenDAO通过ORM（Object Relation Mapping 对象关系映射）的方式创建数据表。即创建一个实体类，将该实体结构映射成数据表的结构。 

下面演示如何创建一个”电影收藏”数据表。分两步：创建表实体，Make Project生成代码。

2.2.1 创建表实体

@Entity
public class MovieCollect {

@Id
private Long id;
private String movieImage;
private String title;
private int year;

}

1
2
3
4
5
6
7
8
9
10
注解介绍：（参考自http://www.jianshu.com/p/4e6d72e7f57a）
@Entity 

用来声明类实体，表示它将映射为数据表 

@Entity（）括号内可加入更详细的设置，如： 

nameInDb =“TABLE_NAME” ——> 声明该表的表名，默认取类名 

createInDb = true ——> 是否创建表，默认为true 

generateConstructors = true ——> 是否生成含所有参数的构造函数，默认为true 

generateGettersSetters = true ——> 是否生成getter/setter，默认为true
@Id 

用来声明某变量为表的主键，类型使用Long 

@Id（）括号可加入autoincrement = true表明自增长
@Unique 

用来声明某变量的值需为唯一值
@NotNull 

用来声明某变量的值不能为null
@Property 

@Property(nameInDb = “URL”) 用来声明某变量在表中的实际字段名为URL
@Transient 

用来声明某变量不被映射到数据表中
@ToOne、@ToMany 

用来声明”对一”和“对多”关系，下面举例说明：
学生与学校之间一对多的关系（一个学生对应一个学校，一个学校对应有多个学生）

@Entity
class Student{
//...省略其他变量
private long fk_schoolId;//外键

@ToOne(joinProperty = "fk_schoolId")
private School school;
}

@Entity
class School{
//...省略其他变量
@ToMany(referencedJoinProperty = "fk_schoolId")
private List<Student> students;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
学生与课程之间“多对多”的关系（一个学生对应有多门课程，一门课程对应有多个学生）

@Entity
class Student{
//...省略其他变量
@ToMany
@JoinEntity(
entity = StudentWithCourse.class,
sourceProperty = "sId",
targetProperty = "cId"
)
private List<Course> courses;
}

@Entity
class Course{
//...省略其他变量
@ToMany
@JoinEntity(
entity = StudentWithCourse.class,
sourceProperty = "cId",
targetProperty = "sId"
)
private List<Course> courses;
}

@Entity
class StudentWithCourse{
@Id
private Long id;
private Long sId;
private Long cId;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

2.2.2 Make Project

利用上面注解写好表实体后，通过Build—>Make Project重新编译项目， 将会在表实体中自动生成构造方法和getter/setter方法，另外在指定（或默认）的包中生成DaoMaster、DaoSession以及表实体对应的Dao（如MovieCollectDao）。
其中， 

DaoMaster：用于创建数据库以及获取DaoSession 

DaoSession：用于获取各个表对应的Dao类 

各个表对应的Dao：提供了对表进行增删改查的方法

3. 增删改查

要对数据表进行增删改查，需要获取该表对应的Dao类，而获取Dao类需要DaoSession。 

创建一个DaoManager用于初始化数据库以及提供DaoSession。

//DaoManager中代码

//获取DaoSession，从而获取各个表的操作DAO类
public DaoSession getDaoSession() {
if (mDaoSession == null) {
initDataBase();
}
return mDaoSession;
}

//初始化数据库及相关类
private void initDataBase(){
setDebugMode(true);//默认开启Log打印
mSQLiteOpenHelper = new DaoMaster.DevOpenHelper(MyApplication.getInstance(), DB_NAME, null);//建库
mDaoMaster = new DaoMaster(mSQLiteOpenHelper.getWritableDatabase());
mDaoSession = mDaoMaster.newSession();
mDaoSession.clear();//清空所有数据表的缓存
}

//是否开启Log
public void setDebugMode(boolean flag) {
MigrationHelper.DEBUG = true;//如果查看数据库更新的Log，请设置为true
QueryBuilder.LOG_SQL = flag;
QueryBuilder.LOG_VALUES = flag;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
通过DaoSeesion获取目标数据表对应的Dao，然后就可开始进行增删改查的操作了。

MovieCollectDao mMovieCollectDao = DaoManager.getInstance().getDaoSession().getMovieCollectDao();

1

3.1 增

插入单个数据

MovieCollect movieCollect;
mMovieCollectDao.insert(movieCollect);

1
2
插入一组数据

List<MovieCollect> listMovieCollect;
mMovieCollectDao.insertInTx(listMovieCollect);

1
2
插入或替换数据

//插入的数据如果已经存在表中，则替换掉旧数据（根据主键来检测是否已经存在）

MovieCollect movieCollect;
mMovieCollectDao.insertOrReplace(movieCollect);//单个数据

List<MovieCollect> listMovieCollect;
mMovieCollectDao.insertOrReplace(listMovieCollect);//一组数据

1
2
3
4
5
6
7
8

3.2 删

删除单个数据

MovieCollect movieCollect;
mMovieCollectDao.delete(movieCollect);

1
2
删除一组数据

List<MovieCollect> listMovieCollect;
mMovieCollectDao.deleteInTx(listMovieCollect）;

1
2
删除所有数据

mMovieCollectDao.deleteAll();

1

3.3 改

修改单个数据

MovieCollect movieCollect;
mMovieCollectDao.update(movieCollect);

1
2
修改一组数据

List<MovieCollect> listMovieCollect;
mMovieCollectDao.updateInTx(listMovieCollect）;

1
2

3.4 查

查询全部数据

List<MovieCollect> listMovieCollect = mMovieCollectDao.loadAll();

1
查询数量

int count = mMovieCollectDao.count();

1
条件查询
精确查询（where）

//查询电影名为“肖申克的救赎”的电影
MovieCollect movieCollect =
mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Title.eq("肖申克的救赎")).unique();

//查询电影年份为2017的电影
List<MovieCollect> movieCollect =
mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.eq(2017)).list();

1
2
3
4
5
6
7
模糊查询（like）

//查询电影名含有“传奇”的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Title.like("传奇")).list();

//查询电影名以“我的”开头的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Title.like("我的%")).list();

1
2
3
4
5
区间查询

//大于
//查询电影年份大于2012年的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.gt(2012)).list();

//大于等于
//查询电影年份大于等于2012年的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.ge(2012)).list();

//小于
//查询电影年份小于2012年的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.lt(2012)).list();

//小于等于
//查询电影年份小于等于2012年的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.le(2012)).list();

//介于中间
//查询电影年份在2012-2017之间的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.between(2012,2017)).list();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
升序降序

//查询电影年份大于2012年的电影，并按年份升序排序
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.gt(2012)).orderAsc(MovieCollectDao.Properties.Year).list();

//查询电影年份大于2012年的电影，并按年份降序排序
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().where(MovieCollectDao.Properties.Year.gt(2012)).orderDesc(MovieCollectDao.Properties.Year).list();

1
2
3
4
5
and/or

//and
//查询电影年份大于2012年且电影名以“我的”开头的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().and(MovieCollectDao.Properties.Year.gt(2012), MovieCollectDao.Properties.Title.like("我的%")).list();

//or
//查询电影年份小于2012年或者大于2015年的电影
List<MovieCollect> movieCollect = mMovieCollectDao.queryBuilder().or(MovieCollectDao.Properties.Year.lt(2012), MovieCollectDao.Properties.Year.gt(2015)).list();

1
2
3
4
5
6
7
SQL语句

//查询名字为“羞羞的铁拳”的电影

//使用Dao.queryBuilder().where() 配合 WhereCondition.StringCondition() 实现SQL查询
Query query =
mMovieCollectDao.queryBuilder()
.where(new WhereCondition.StringCondition("TITLE = ?", "羞羞的铁拳")).build();
List<MovieCollect> movieCollect = query.list();

//使用Dao.queryRawCreate() 实现SQL查询
Query query = mMovieCollectDao.queryRawCreate("WHERE TITLE = ?", "羞羞的铁拳");
List<MovieCollect> movieCollect = query.list();

1
2
3
4
5
6
7
8
9
10
11
缓存问题
由于GreenDao默认开启了缓存，所以当你调用A查询语句取得X实体，然后对X实体进行修改并更新到数据库，接着再调用A查询语句取得X实体，会发现X实体的内容依旧是修改前的。其实你的修改已经更新到数据库中，只是查询采用了缓存，所以直接返回了第一次查询的实体。 

解决方法：查询前先清空缓存，清空方法如下

//清空所有数据表的缓存数据
DaoSession daoSession = DaoManager.getInstance().getDaoSession();
daoSession .clear();

//清空某个数据表的缓存数据
MovieCollectDao movieCollectDao = DaoManager.getInstance().getDaoSession().getMovieCollectDao();
movieCollectDao.detachAll();

1
2
3
4
5
6
7

4. 加密

注意： 加密需要添加sqlcipher库，而该库体积庞大，使用后apk大小会增加大概5M，所以如果你的应用对安全性要求不高，不建议使用。
加密数据库的步骤： 
第一步： 

Module下的build.gradle中添加一个库依赖，用于数据库加密。

compile 'net.zetetic:android-database-sqlcipher:3.5.7'//使用加密数据库时需要添加

1
第二步： 

获取DaoSession的过程中，使用getEncryptedWritableDb(“你的密码”)来获取操作的数据库，而不是getWritableDatabase()。

mSQLiteOpenHelper = new MySQLiteOpenHelper(MyApplication.getInstance(), DB_NAME, null);//建库
mDaoMaster = new DaoMaster(mSQLiteOpenHelper.getEncryptedWritableDb("你的密码"));//加密
//mDaoMaster = new DaoMaster(mSQLiteOpenHelper.getWritableDatabase());
mDaoSession = mDaoMaster.newSession();

1
2
3
4
第三步： 

使用上面步骤得到的DaoSession进行具体的数据表操作。 

如果运行后报无法加载有关so库的异常，请对项目进行clean和rebuild。

5. 升级

在版本迭代时，我们经常需要对数据库进行升级，而GreenDAO默认的DaoMaster.DevOpenHelper在进行数据升级时，会把旧表删除，然后创建新表，并没有迁移旧数据到新表中，从而造成数据丢失。 

这在实际中是不可取的，因此我们需要作出调整。下面介绍数据库升级的步骤与要点。
第一步： 

新建一个类，继承DaoMaster.DevOpenHelper，重写onUpgrade(Database db, int oldVersion, int newVersion)方法，在该方法中使用MigrationHelper进行数据库升级以及数据迁移。 

网上有不少MigrationHelper的源码，这里采用的是https://github.com/yuweiguocn/GreenDaoUpgradeHelper中的MigrationHelper，它主要是通过创建一个临时表，将旧表的数据迁移到新表中，大家可以去看下源码。

public class MyOpenHelper extends DaoMaster.OpenHelper {
public MyOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}

@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {

//把需要管理的数据库表DAO作为最后一个参数传入到方法中
MigrationHelper.migrate(db, new MigrationHelper.ReCreateAllTableListener() {

@Override
public void onCreateAllTables(Database db, boolean ifNotExists) {
DaoMaster.createAllTables(db, ifNotExists);
}

@Override
public void onDropAllTables(Database db, boolean ifExists) {
DaoMaster.dropAllTables(db, ifExists);
}
},  MovieCollectDao.class);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
然后使用MyOpenHelper替代DaoMaster.DevOpenHelper来进行创建数据库等操作

mSQLiteOpenHelper = new MyOpenHelper(MyApplication.getInstance(), DB_NAME, null);//建库
mDaoMaster = new DaoMaster(mSQLiteOpenHelper.getWritableDatabase());
mDaoSession = mDaoMaster.newSession();

1
2
3
第二步： 

在表实体中，调整其中的变量（表字段），一般就是新增/删除/修改字段。注意： 

1）新增的字段或修改的字段，其变量类型应使用基础数据类型的包装类，如使用Integer而不是int，避免升级过程中报错。 

2）根据MigrationHelper中的代码，升级后，新增的字段和修改的字段，都会默认被赋予null值。
第三步： 

将原本自动生成的构造方法以及getter/setter方法删除，重新Build—>Make Project进行生成。
第四步： 

修改Module下build.gradle中数据库的版本号schemaVersion ，递增加1即可，最后运行app

greendao {
//数据库版本号，升级时进行修改
schemaVersion 2

daoPackage 'com.dev.base.model.db'
targetGenDir 'src/main/java'
}

1
2
3
4
5
6
7

6. 混淆

在proguard-rules.pro文件中添加以下内容进行混淆配置

# greenDAO开始
-keepclassmembers class * extends org.greenrobot.greendao.AbstractDao {
public static java.lang.String TABLENAME;
}
-keep class **$Properties
# If you do not use SQLCipher:
-dontwarn org.greenrobot.greendao.database.**
# If you do not use RxJava:
-dontwarn rx.**
# greenDAO结束

# 如果按照上面介绍的加入了数据库加密功能，则需添加一下配置
#sqlcipher数据库加密开始
-keep  class net.sqlcipher.** {*;}
-keep  class net.sqlcipher.database.** {*;}
#sqlcipher数据库加密结束

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
详细代码请看demo，地址：https://github.com/LJYcoder/DevBase 

demo的内容流程，请看《安卓开发框架（MVP+主流框架+基类+工具类）— 开篇》