Android笔记之greenDao3.0学习总结

前言

本博文旨在记录greenDao3.0的基本用法以及基于greenDao3.0的数据库的升级策略。本文基于Window10下Android Studio环境操作使用。废话不多说，直入正题。

关于greenDao3.0

greenDao是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库，它能够让你操作数据库时更简单、更方便。如下图来之其官网的图片：



官网地址：http://greenrobot.org/greendao/

github地址：https://github.com/greenrobot/greenDAO

关于greenDao3.0之前的2.0、1.0版本，本人没有接触（现在似乎也没必要再去了解）过。据网上大神介绍，3.0之前需要通过新建GreenDaoGenerator工程生成Java数据对象（实体）和DAO对象，非常的繁琐而且也加大了使用成本。而GreenDao3.0最大的变化就是采用注解的方式通过编译方式生成Java数据对象和DAO对象。

greenDao3.0特点

greenDao3.0主要有以下特点：
·        1.性能高，号称Android最快的关系型数据库

          2.内存占用小

·        3.库文件比较小，小于100K，编译时间低，而且可以避免65K方法限制

·        4.支持数据库加密 greendao支持SQLCipher进行数据库加密

         5.简洁易用的API

greenDao3.0使用

greenDao3.0基本配置：

在项目的build.gradle添加如下配置：

dependencies {
classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'
}

这里添加的是greenDao插件路径。
在主工程下的build.gradle下添加如下配置：

apply plugin: 'org.greenrobot.greendao'

dependencies {
compile 'org.greenrobot:greendao:3.0.1'
}

如以上配置所示，greenDao3.0使用需要依赖greenDao插件配合使用。完成这些基本配置后我们同步编译（Sync Project），没毛病，接着往下。

greenDao基本使用：

现在我们就可以使用greenDao框架了，新建实体类：

@Entity
public class User {
@Id(autoincrement = true)
private Long id;
private String name;
private int age;
...
}

注意：因为我们要使用greenDao3.0框架，所以我们的实体类要添加greenDao3.0的注解@Entity，表示该实体类的相关数据要添加到数据库中。此外，我们还对实体类中id字段添加了注解@Id(autoincrement
= true)  表示将该字段设为主键并自动增长，需要注意的是，主键是Long型，不是long。

此外，定义实体类时对于字段还可以添加以下注解：
@Id :主键 Long型，可以通过@Id(autoincrement = true)设置自增长
@Property：设置一个非默认关系映射所对应的列名，默认是的使用字段名 举例：@Property (nameInDb="name")
@NotNul：设置数据库表当前列不能为空
@Transient ：添加次标记之后不会生成数据库表的列
再次同步编译，编译完成后，我们可以发现，User类中已经自动给我们添加了字段对应的setter、getter方法以及构造函数：

public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
@Generated(hash = 1309193360)
public User(Long id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
@Generated(hash = 586692638)
public User() {
}

这些都是greenDao3.0插件为我们自动生成的代码。此外，我们还可以在app/build/generated/source目录下新增了一个greendao目录，里面有三个java文件分别是DaoMaster、DaoSession、UserDao。没错，这些文件也是greenDao3.0插件为我们自动生成的。这些类就是我们后面操作数据库主要依赖的类。



那么问题来了，如果我想让这些文件放到其它目录下该怎么办？good question！
这时我们就可以在主工程下的build.gradle添加相应的辅助配置（比如我想将这些文件放在src/mian/java目录下）：

greendao {
targetGenDir 'src/main/java'
}

这时，我们重新编译，就会发现这些文件已经转移到这个目录下了。



这里的greendao，我们还可以添加下面一些数据库的基本属性配置
schemaVersion： 数据库schema版本，也可以理解为数据库版本号
daoPackage：设置DaoMaster 、DaoSession、Dao包名
targetGenDir：设置DaoMaster 、DaoSession、Dao目录
targetGenDirTest：设置生成单元测试目录
generateTests：设置自动生成单元测试用例
现在，我们就可以进行greendao数据库的实在操作了。

greenDao简单操作

借助上面生成的DaoMaster、DaoSession、UserDao三个类，我们可以创建一个数据库工具类DBManager
-------------------------------------------------------明天接着写


。。。一天后，继续……

-------------------------------------------------------
首先明确我们这个工具类的功能。很明显，对于数据库的操作，无非就是增、删、改、查，也就是说，我们要在DBManager这个类里实现实现数据库增删改查的功能。
1.声明一个数据库管理者DBManager单例public class DBManager {
private static final String dbName = "my_test_db";
private static DBManager mInstance;
private DaoMaster.DevOpenHelper mOpenHelper;
private Context mContext;

public DBManager(Context context){
this.mContext = context;
mOpenHelper = new DaoMaster.DevOpenHelper(mContext,dbName,null);
}

/**
* 获取单例引用
*
* @param context
* @return
*/
public static DBManager getInstance(Context context) {
if (mInstance == null){
synchronized (DBManager.class){
if (mInstance == null){
mInstance = new DBManager(context);
}
}
}
return mInstance;
}
}

2.获取可写、可读数据库/**
* 获取可读数据库
* @return
*/
private SQLiteDatabase getReadableDatabase(){
if (mOpenHelper == null){
mOpenHelper = new DaoMaster.DevOpenHelper(mContext,dbName,null);
}
SQLiteDatabase db = mOpenHelper.getReadableDatabase();
return db;
}

/**
* 获取可写数据库
* @return
*/
private SQLiteDatabase getWritableDatabase(){
if (mOpenHelper == null){
mOpenHelper = new DaoMaster.DevOpenHelper(mContext,dbName,null);
}
SQLiteDatabase db = mOpenHelper.getWritableDatabase();
return db;
}3.增删改查系列方法
通过greenDao插件给我们自动生成的这三个工具类，我们可以很轻易的实现增删改查系列方法
/**
* 插入一条记录
* @param user
*/
public void insertUser(User user){
DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.insert(user);
}

/**
* 插入用户集合
*
* @param users
*/
public void insertUserList(List<User> users) {
if (users == null || users.isEmpty()) {
return;
}
DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.insertInTx(users);
}

/**
* 删除一条记录
*
* @param user
*/
public void deleteUser(User user) {
DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.delete(user);
}

/**
* 清空所有记录
*/
public void clearUser(){
DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.deleteAll();
}

/**
* 批量删除
* @param list
*/
public void deleteUsers(List<User> list){
DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.deleteInTx(list);
}

/**
* 更新一条记录
*
* @param user
*/
public void updateUser(User user) {
DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.update(user);
}

/**
* 查询用户列表
*/
public List<User> queryUserList() {
DaoMaster daoMaster = new DaoMaster(getReadableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
QueryBuilder<User> qb = userDao.queryBuilder();
List<User> list = qb.list();
return list;
}

/**
* 根据条件查询用户列表
*/
public List<User> queryUserList(int age) {
DaoMaster daoMaster = new DaoMaster(getReadableDatabase());
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
QueryBuilder<User> qb = userDao.queryBuilder();
qb.where(UserDao.Properties.Age.gt(age)).orderAsc(UserDao.Properties.Age);
List<User> list = qb.list();
return list;
}至此，我们可以真正测试操作数据库了
public class MainActivity extends AppCompatActivity {

private static final String TAG = "MainActivity";

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initData();
}

private void initData(){
DBManager dbManager = DBManager.getInstance(this);
for (int i = 0;i<6;i++){
User user = new User("测试数据"+i,10+i);
dbManager.insertUser(user);
}

List<User> users = dbManager.queryUserList();
for (User user : users){
Log.i(TAG,user.toString()+"\n");
}

}
}运行结果：



初步测试，没毛病。其它增删改查功能，大家自己可以测试下，这里就不做示例了。接下来，我们讨论下一个问题：数据库升级。

数据库升级

应用上线之后，app的更新或多或少涉及到数据库的版本升级。可能要给某张表添加一个字段，也可能要新增一张表等等此类情况。那么，这里数据库更新可以有两种方案：
方案一：删除旧的数据库，创建新的数据库和数据库表
这种方案，简单粗暴，一般也不会出什么Bug，但也出在一个很明显的问题，就是在已经上线的应用，更新app升级数据库时删除了用户原有的数据，对于用户体验来说是很不友好的。
方案二：保留原有数据库数据，并在此基础上添加新的字段或新表。这种方案也就是为了解决方案一存在的问题。
那么，greenDao3.0在升级数据库上是怎么做的呢？
通过调查源码发现，我们操作的对象mOpenHelper对应的类DevOpenHelper重写了一个方法onUpgrade()，没错，这就是数据库版本升级时要调用的方法，看内容：
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by dropping all tables");
dropAllTables(db, true);
onCreate(db);
}通过源码我们发现：

dropAllTables(db,true);//删除当前数据库所有表单；

onCreate(db);//新建当前所有表

即greenDao默认的升级方法就是我们的方案一，简单粗暴，问题也突出。
然而，我们还是先来调查一下它什么时候会调用onUpgrade()方法。
查看源码，发现在执行mOpenHelper.getWritableDatabase()和mOpenHelper.gerReadableDatabase()的时候会比较数据库的版本号和app设置的数据库版本号（即所谓的数据库的旧版本号和新版本号），如果不同者会执行升级（onUpgrade()）或降级（onDowngrde()）数据库操作，看源码：
final int version = db.getVersion();
if (version != mNewVersion) {
if (db.isReadOnly()) {
throw new SQLiteException("Can't upgrade read-only database from version " +
db.getVersion() + " to " + mNewVersion + ": " + mName);
}

db.beginTransaction();
try {
if (version == 0) {
onCreate(db);
} else {
if (version > mNewVersion) {
onDowngrade(db, version, mNewVersion);
} else {
onUpgrade(db, version, mNewVersion);
}
}
db.setVersion(mNewVersion);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
}很明显的，这里的version就是从当前数据库中获取的版本号（即旧版本号），而mNewVersion，我们通过追踪，发现它是从DaoMaster类里传过来的，也就是SCHEMA_VERSION
public class DaoMaster extends AbstractDaoMaster {
public static final int SCHEMA_VERSION = 1;
...
}换言之，我们要升级数据库，就要改变这个值，但是我们都知道这是greenDao框架自动生成的，不能手动修改：
// THIS CODE IS GENERATED BY greenDAO, DO NOT EDIT.

是的，即使我们非要手动修改，你会发现编译之后它又还原了。这是，我们就要用到上面提到的greendao{}辅助配置
我们添加配置schemaVersion，这就是设置新数据库的版本号：
greendao {
schemaVersion 2
...
}编译，我们发现，DaoMaster的变成了SCHEMA_VERSION我们设置的值了
/**
* Master of DAO (schema version 2): knows all DAOs.
*/
public class DaoMaster extends AbstractDaoMaster {
public static final int SCHEMA_VERSION = 2;
。。。
}Ok，现在就可以升级数据库了，运行：



查看打印信息，我们知道，它确实执行了onUpgrade()方法，也就是完成了数据库的升级
知道了如何执行数据库升级，现在就还剩下最后一个问题，如何实现方案二？
这里我通过网上查阅资料，看到了某大神提供的方法，合并（MigrationHelper），其核心思路如下：

1 把旧表改为临时表
2 建立新表
3 临时表数据写入新表，删除临时表
看MigrationHelper.java核心方法：
public class MigrationHelper {
/**
* 调用升级方法
* @param db
* @param daoClasses 一系列dao.class
*/
public static void migrate(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
//1 新建临时表
generateTempTables(db, daoClasses);
//2 创建新表
createAllTables(db, false, daoClasses);
//3 临时表数据写入新表，删除临时表
restoreData(db, daoClasses);
}
...
}所以我们需要新建一个类MyDBOpenHelper继承DaoMaster.DevOpenHelper，重写onUpgrade()方法，里面调用MigrationHelper.migrate()方法就行了。
public class MyDbOpenHelper extends DaoMaster.DevOpenHelper {

public MyDbOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}

@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
MigrationHelper.migrate(db, UserDao.class);
}
}
现在，我们修改SCHEMA_VERSION为3，给User添加新字段number，将DBManager中的DaoMaster.DevOpenHelper替换成MyDBOpenHelper，以及修改其他对应代码，编译运行：



我们发现数据库确实保存了原来的数据，并添加了新的字段number。至此，我们终于实现了方案二，完美


BUT，我们新增表能行吗？这里，我们测试下添加一个实体类News
@Entity
public class News {
private int id;
private String newsInfo;
...
}同步编译，同样在DBManager.java里添加增删改查方法，并在onUpgrade()方法里添加NewsDao.class
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
MigrationHelper.migrate(db, UserDao.class, NewsDao.class);
}在MainActivity里添加代码
private void initData(){
...
for (int i = 0;i<6;i++){
News user = new News(i,"测试数据"+i);
dbManager.insertNews(user);
}

List<News> newsList = dbManager.queryNewsList();
for (News user : newsList){
Log.i(TAG,user.toString()+"\n");
}
}修改SCHEMA_VERSION为4，运行，发现提示错误
E/SQLiteLog: (1) no such table: NEWS即没有创建NEWS表
所以大神的MigrationHelper这个类的功能似乎也稍有欠缺，呐，现在我们又有了新的目标，当旧数据库里不存在某表时，我们创建该表。
怎么做呢？是的，greenDao框架怎么做，我们就怎么做。
greenDao是怎么做的呢，通过研究代码发现，greenDao是通过DaoMaster调用createAllTables(Database db, boolean ifNotExists)方法创建表的
public class DaoMaster extends AbstractDaoMaster {
public static final int SCHEMA_VERSION = 4;

/** Creates underlying database table using DAOs. */
public static void createAllTables(Database db, boolean ifNotExists) {
UserDao.createTable(db, ifNotExists);
NewsDao.createTable(db, ifNotExists);
}
...
}

/** Creates the underlying database table. */
public static void createTable(Database db, boolean ifNotExists) {
String constraint = ifNotExists? "IF NOT EXISTS ": "";
db.execSQL("CREATE TABLE " + constraint + "\"NEWS\" (" + //
"\"ID\" INTEGER NOT NULL ," + // 0: id
"\"NEWS_INFO\" TEXT);"); // 1: newsInfo
}

这就好办了，我们直接使用该方法，研究里面方法里面的sql语句发现，我们要将ifNotExists设为true，即表不存在才创建。
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
DaoMaster.createAllTables(db,true);//如果表不存在，则创建
MigrationHelper.migrate(db, UserDao.class,NewsDao.class);
}

重新编译运行



是的，成功，没毛病

！
至此，我们基于greenDao的数据库升级就基本搞定啦。
示例源码链接