GreenDao 3.0 的使用
1. 背景
我们在Android开发的时候，经常会牵涉到数据的保存，相比SharedPreferences，数据库可以让我们保存种类更多的数据，而且很多时候我们需要增删改查大量数据，这个时候数据库的优势就体现出来了。在与数据库打交道时，我们当然可以使用SQLiteDatabase和SQLiteOpenHelper进行数据库的操作，但是我们要记住大量的sql语句，显然是不方便的。目前封装比较好的数据库操作框架有Ormlite和GreenDao，而GreenDao使用起来配合注解，显然更加符合现在开发，也较Ormlite方便，下面我们就开启GreenDao之旅。
2. GreenDao 3.0 的配置
2.1 在project的build.gradle中添加classpath
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'allprojects {
repositories {
jcenter()
mavenCentral()
}
}
2.2 在module的build.gradle应用插件和依赖
apply plugin: 'org.greenrobot.greendao'compile 'org.greenrobot:greendao:3.2.0'应用插件
添加依赖
在make project/make module时，插件会扫描项目中所有的@Entity文件（greenDAO中数据库的实体类添加的注解），根据实体类生成DaoSession、DaoMaster以及所有实体类的dao类，生成的文件默认目录为：build/generated/source/greendao，如果你想自定义这个路径，可以在module的build.gradle添加如下配置：
greendao {
schemaVersion 1
daoPackage 'com.zhang.greendaotest.greendao.gen'
targetGenDir 'src/main/java'
}
schemaVersion：指定数据库版本号
daoPackage：通过gradle插件生成的数据库相关文件的包名，默认为entity所在的包名
targetGenDir：自定义生成数据库文件的目录了，可以将生成的文件放到我们的Java目录中，而不是build中，这样就不用额外的设置资源目录了3. GreenDao 3.0 开发之路
在实体类上添加注解@Entity，GreenDao的插件会找到它生成代码
@Entity
public class User {
//注意：这里的id类型是Long/long
@Id(autoincrement = true)
private Long id;
@Property(nameInDb = "user_name")
private String name;
@Property(nameInDb = "tel_phone")
private String phone;
private int age;
@Transient
private String address;
}@Entity 实体类，GreenDao会映射成sqlite中的一个表
@Id 主键
@Property 属性在表中对应的列名称
@Transient 属性将不会映射到表中
更多注解：http://greenrobot.org/files/greendao-api/javadoc/current/
写好实体类，make project/make module后，会发现在“daoPackage”指定的目录下生成了如下代码文件：
这是自己写的实体类也会生成有参构造，set/get方法
下面就是数据库的最常见的增删改查，这里简单封装下工具类，实际开发时，可以利用Dagger2注入全局的DaoSession实例。
public class GreenDaoManager {
private DaoMaster mDaoMaster;
private DaoSession mDaoSession;
private GreenDaoManager() {
/**
* 初始化GreenDao
*/
DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(MyApp.getAppContext(), "user.db", null);
mDaoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());
mDaoSession = mDaoMaster.newSession();
}
private static class SingleInstance {
private static final GreenDaoManager INSTANCE = new GreenDaoManager();
}
public static GreenDaoManager getInstance() {
return SingleInstance.INSTANCE;
}
/**
* 得到DaoMaster实例
* @return
*/
public DaoMaster getmDaoMaster() {
return mDaoMaster;
}
/**
* 得到DaoSession实例
* @return
*/
public DaoSession getmDaoSession() {
return mDaoSession;
}
}在MyApp中初始化：
sDaoSession = GreenDaoManager.getInstance().getmDaoSession();准备工作已经完成，下面就是增删改查了
在使用时可以先得到UserDao实例，方便操作，例在MainActivity中
mUserDao = MyApp.sDaoSession.getUserDao();3.1 数据逐一添加：
//数据逐一添加
User user1 = new User(null, "greendao_1", "110", 20);
mUserDao.insert(user1);
User user2 = new User(null, "greendao_2", "111", 21);
mUserDao.insert(user2);3.2 查询数据
可以看出这里的代码风格是主流的响应式编程
List userList = mUserDao.queryBuilder()
//限定查询的条件
.where(UserDao.Properties.Id.notEq(10))
//设置按照排序方式
.orderAsc(UserDao.Properties.Id)
//限制查询个数
.limit(10)
.build().list(); 3.3 更新数据：先查后再改
User oldUser = mUserDao.queryBuilder()
.where(UserDao.Properties.Name.eq("greendao_1")).build().unique();
if (oldUser != null) {
oldUser.setName("greendao_0");
mUserDao.update(oldUser);
Log.d(TAG, "update: 修改成功");
} else {
Log.d(TAG, "update: 修改失败");
}3.5 删除数据：按照条件删除
User findUser = mUserDao.queryBuilder().where(UserDao.Properties.Name.eq("greendao_2")).build().unique();
if (findUser != null) {
mUserDao.deleteByKey(findUser.getId());
}3.6 GreenDao依然支持sql语句：
这里可以看出我们当初的表名和字段名
String sql = "delete from user where user_name='greendao_1'";
GreenDaoManager.getInstance().getmDaoSession().getDatabase().execSQL(sql);3.7 批量添加数据
users = Arrays.asList(new User(null, "greendao_100", "120", 20),
new User(null, "greendao_101", "121", 21),
new User(null, "greendao_102", "122", 22),
new User(null, "greendao_103", "123", 23),
new User(null, "greendao_104", "124", 24),
new User(null, "greendao_105", "125", 25),
new User(null, "greendao_106", "126", 26)
);
mUserDao.getSession().runInTx(new Runnable() {
@Override
public void run() {
for (int i = 0; i < users.size(); i++) {
User user = users.get(i);
mUserDao.insertOrReplace(user);
}
}
});3.8 删除全部数据
mUserDao.deleteAll();以上就是GreenDao的基本使用
4. GreenDao使用外部数据库文件
知晓了GreenDao 3.0 的基本使用，下面我们看下使用GreenDao 3.0 进行对外部数据库的操作。我们知道要使用外部数据库，例如city.db，需要把db文件放在AS的 res - >raw 目录下，如图
下面我们按照外部city.db文件中的字段编写javabean（注意这里类会映射成表名，所以我们需要打开db文件，查看表名）
@Entity
public class Tbl_province {
@Id(autoincrement = true)
private Long id;
@Property(nameInDb = "codeid")
private String code;
@Property(nameInDb = "parentid")
private String parent;
@Property(nameInDb = "cityName")
private String city;
}然后Make Module 一下，GreenDao会生成代码
下面我们查询一下
List cityList = mTbl_provinceDao.queryBuilder()
//条件
.where(Tbl_provinceDao.Properties.Id.notEq(100))
//排序
.orderAsc(Tbl_provinceDao.Properties.Id)
//限制查询个数
.limit(100)
.build().list();
mTv.setText(cityList.toString()); 这是发现，查询不到结果。这是因为GreenDao在初始化的时候，默认是创建新表的。
具体看下GreenDao初始化过程
DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(MyApp.getAppContext(), "city.db", null);看下这个DevOpenHelper帮助类，是 extends OpenHelper的，而这个OpenHelper如下
public static abstract class OpenHelper extends DatabaseOpenHelper {
public OpenHelper(Context context, String name) {
super(context, name, SCHEMA_VERSION);
}
public OpenHelper(Context context, String name, CursorFactory factory) {
super(context, name, factory, SCHEMA_VERSION);
}
@Override
public void onCreate(Database db) {
Log.i("greenDAO", "Creating tables for schema version " + SCHEMA_VERSION);
createAllTables(db, false);
}
}也就是在创建的时候会走下面这句代码，传入的是false
createAllTables(db, false);看下具体实现，这里的ifNotExists值时false
public static void createAllTables(Database db, boolean ifNotExists) {
Tbl_provinceDao.createTable(db, ifNotExists);
UserDao.createTable(db, ifNotExists);
}再往下看
public static void createTable(Database db, boolean ifNotExists) {
String constraint = ifNotExists? "IF NOT EXISTS ": "";
db.execSQL("CREATE TABLE " + constraint + "\"TBL_PROVINCE\" (" + //
"\"_id\" INTEGER PRIMARY KEY AUTOINCREMENT ," + // 0: id
"\"codeid\" TEXT," + // 1: code
"\"parentid\" TEXT," + // 2: parent
"\"cityName\" TEXT);"); // 3: city
}看到这里，大家就明白了，由于ifNotExists默认传入的是false，在这里就会创建新的表，同时在这里我们还可以看到具体表的字段，那么我们要使用外部的db数据库的话。那么我们要使用外部的数据库的时候，就不能用这个创建的新表，而是需要将外部数据库复制到应用包中，具体步骤如下：
①复制外部DB数据库：res -> raw 到 data ->data … ->databases目录下
public static String sDBPath; //数据库存入手机的路径
public void writeDB() {
FileOutputStream fout = null;
InputStream inputStream = null;
sDBPath = getFilesDir() + "\\databases\\" + "city.db";
try {
inputStream = getResources().openRawResource(city);
fout = new FileOutputStream(new File(sDBPath));
byte[] buffer = new byte[128];
int len = 0;
while ((len = inputStream.read(buffer)) != -1) {
fout.write(buffer, 0, len);
}
buffer = null;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fout != null) {
try {
fout.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}注意 设置要复制的目录要写在GreenDao初始化前面，因为初始化的时候要用到这个路径，这里我把整个方法都写在了GreenDao初始化前面
sDBPath = getFilesDir() + "\\databases\\" + "city.db";② 将复制的数据库赋给DaoMaster，在GreenDaoManager中再设置个mNewDaoMaster和mNewDaoSession，具体如下：
SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(MyApp.sDBPath, null);
mNewDaoMaster = new DaoMaster(database);
mNewDaoSession = mNewDaoMaster.newSession();这个可以看到，我们没有使用DevOpenHelper去得到SQLiteDatabase实例，而是通过SQLiteDatabase.openOrCreateDatabase()方法拿到复制的DB数据库实例，然后复制给mNewDaoMaster
另外提供得到mNewDaoSession的get方法
public DaoSession getmNewDaoSession() {
return mNewDaoSession;
}③ 在MyApp中初始化，得到全局的sNewDaoSession
sNewDaoSession = GreenDaoManager.getInstance().getmNewDaoSession();④ 在MainActivity中使用
mTbl_provinceDao = MyApp.sNewDaoSession.getTbl_provinceDao();对数据库的操作和之前的一样
List cityList = mTbl_provinceDao.queryBuilder()
//条件
.where(Tbl_provinceDao.Properties.Id.notEq(100))
//排序
.orderAsc(Tbl_provinceDao.Properties.Id)
//限制查询个数
.limit(100)
.build().list();
mTv.setText(cityList.toString()); 5. 数据库更新表
使用GreenDao进行数据库更新表，例如在User中增加一个字段pwd
@Entity
public class User {
@Id(autoincrement = true)
private Long id;
@Property(nameInDb = "user_name")
private String name;
@Property(nameInDb = "tel_phone")
private String phone;
private int age;
//注意添加的字段须是String，其他类型可能报错
private String pwd;
@Transient
private String address;
}make module之后，GreenDao为User生成代码之后，在User中添加之前的有参构造，防止之前的代码报错
public User(Long id, String name, String phone, int age) {
this.id = id;
this.name = name;
this.phone = phone;
this.age = age;
}下面就是数据库表更新的操作，网上有一个很好用的类帮助我们进行数据库更新操作：MigrationHelper，实现的逻辑就是：创建临时表–>删除原表–>创建新表–>复制临时表数据到新表并删除临时表；这样数据库表的更新就完成了，下面看下具体代码：
public class MigrationHelper {
private static final String CONVERSION_CLASS_NOT_FOUND_EXCEPTION = "MIGRATION HELPER - CLASS DOESN'T MATCH WITH THE CURRENT PARAMETERS";
private static MigrationHelper instance;
public static MigrationHelper getInstance() {
if (instance == null) {
instance = new MigrationHelper();
}
return instance;
}
public void migrate(Database db, Classextends AbstractDao>... daoClasses) {
generateTempTables(db, daoClasses);
DaoMaster.dropAllTables(db, true);
DaoMaster.createAllTables(db, false);
restoreData(db, daoClasses);
}
/**
* 生成临时列表
*
* @param db
* @param daoClasses
*/
private void generateTempTables(Database db, Classextends AbstractDao>... daoClasses) {
for (int i = 0; i < daoClasses.length; i++) {
DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
String divider = "";
String tableName = daoConfig.tablename;
String tempTableName = daoConfig.tablename.concat("_TEMP");
ArrayList properties = new ArrayList<>();
StringBuilder createTableStringBuilder = new StringBuilder();
createTableStringBuilder.append("CREATE TABLE ").append(tempTableName).append(" (");
for (int j = 0; j < daoConfig.properties.length; j++) {
String columnName = daoConfig.properties[j].columnName;
if (getColumns(db, tableName).contains(columnName)) {
properties.add(columnName);
String type = null;
try {
type = getTypeByClass(daoConfig.properties[j].type);
} catch (Exception exception) {
exception.printStackTrace();
}
createTableStringBuilder.append(divider).append(columnName).append(" ").append(type);
if (daoConfig.properties[j].primaryKey) {
createTableStringBuilder.append(" PRIMARY KEY");
}
divider = ",";
}
}
createTableStringBuilder.append(");");
db.execSQL(createTableStringBuilder.toString());
StringBuilder insertTableStringBuilder = new StringBuilder();
insertTableStringBuilder.append("INSERT INTO ").append(tempTableName).append(" (");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(") SELECT ");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(" FROM ").append(tableName).append(";");
db.execSQL(insertTableStringBuilder.toString());
}
}
/**
* 存储新的数据库表 以及数据
*
* @param db
* @param daoClasses
*/
private void restoreData(Database db, Classextends AbstractDao>... daoClasses) {
for (int i = 0; i < daoClasses.length; i++) {
DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
String tableName = daoConfig.tablename;
String tempTableName = daoConfig.tablename.concat("_TEMP");
ArrayList properties = new ArrayList();
for (int j = 0; j < daoConfig.properties.length; j++) {
String columnName = daoConfig.properties[j].columnName;
if (getColumns(db, tempTableName).contains(columnName)) {
properties.add(columnName);
}
}
StringBuilder insertTableStringBuilder = new StringBuilder();
insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(") SELECT ");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
StringBuilder dropTableStringBuilder = new StringBuilder();
dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
db.execSQL(insertTableStringBuilder.toString());
db.execSQL(dropTableStringBuilder.toString());
}
}
private String getTypeByClass(Class type) throws Exception {
if (type.equals(String.class)) {
return "TEXT";
}
if (type.equals(Long.class) || type.equals(Integer.class) || type.equals(long.class)) {
return "INTEGER";
}
if (type.equals(Boolean.class)) {
return "BOOLEAN";
}
Exception exception = new Exception(CONVERSION_CLASS_NOT_FOUND_EXCEPTION.concat(" - Class: ").concat(type.toString()));
exception.printStackTrace();
throw exception;
}
private List getColumns(Database db, String tableName) {
List columns = new ArrayList<>();
Cursor cursor = null;
try {
cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 1", null);
if (cursor != null) {
columns = new ArrayList<>(Arrays.asList(cursor.getColumnNames()));
}
} catch (Exception e) {
Log.v(tableName, e.getMessage(), e);
e.printStackTrace();
} finally {
if (cursor != null)
cursor.close();
}
return columns;
}
} 数据库更新表的方法是DaoMaster.OpenHelper类中的onUpgrade方法，而DaoMaster是插件生成的，我们即使改了，编译一下还会还原的，我们这里采用的方法是写一个类MyOpenHelper继承DaoMaster.OpenHelper，重写onUpgrade方法，使用时也使用我们写的MyOpenHelper。
public class MyOpenHelper extends DaoMaster.OpenHelper {
public MyOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}
/**
* 数据库升级
* @param db
* @param oldVersion
* @param newVersion
*/
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
MigrationHelper.getInstance().migrate(db,UserDao.class);
}
}这样就完成了数据库表的更新，现在我们要做的就是使用我们的MyOpenHelper代替DaoMaster.OpenHelper，我们还是在GreenDaoManager中进行操作：
/**
* 得到DaoMaster实例
* @return
*/
public DaoMaster getmDaoMaster(Context context) {
MyOpenHelper helper = new MyOpenHelper(context,DB_NAME,null);
mDaoMaster = new DaoMaster(helper.getWritableDatabase());
return mDaoMaster;
}在MyApp中得到可以更新数据库表的DaoMaster：
sDaoSession = GreenDaoManager.getInstance().getmDaoMaster(sContext).newSession();我们在MainActivity中拿到UserDao就可以对新的表进行操作了，和之前的一样，这里就不在赘述了。
最后，在app的build.gradle中更新版本号
greendao {
schemaVersion 2
daoPackage 'com.zhang.greendaotest.greendao.gen'
targetGenDir 'src/main/java'
}这样就完成了数据库表的更新。
6. GreenDao的代码混淆配置
混淆打包时，我们需要在proguard-rules.pro文件下添加：
-keepclassmembersclass*extendsde.greenrobot.dao.AbstractDao {
publicstaticjava.lang.String TABLENAME;
}
-keepclass**$Properties
以上就是我对GreenDao 3.0 的使用
奉上demo地址：https://github.com/Mr-zhang0101/GreenDaoTest