GreenDao是一个对象关系型框架，也就是我们常说的ORM框架，使用它可以通过操作对象的方式去操作数据库。从而不用手写sql代码，简化开发。
本文针对GreenDao3.2.2版本进行操作，为什么需要强调版本号? 因为GreenDao2和GreenDao3有比较大的差别，3.0以后相比较之前的版本操作更加的方便。
添加依赖
1，在bulid.gradle文件下的dependencies下添加所需依赖
compile 'org.greenrobot:greendao-generator:3.2.2'
compile 'org.greenrobot:greendao:3.2.2' // add library
2，在bulid.gradle下进行配置
apply plugin: 'org.greenrobot.greendao'
greendao{
schemaVersion 2 //升级greenDao版本号
daoPackage '生成文件包名' // 一般为app包名+生成文件的文件夹名
targetGenDir 'src/main/java' //生成的路径
}
3，在project下的build.gradle配置
dependencies {
//其他省略
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
}
上面的配置也就算完了。
我们先明确一下需求：创建一个名为test.db的数据库，而数据库中有一张表user，需要使用greenDao对user表进行CRUD操作，数据库升级等常用的操作。
创建实体类
先需要定义个User类并标明@Entity注解和数据库中的表进行对应
@Entity
public class User {
@Id(autoincrement = true)
private Long id;
private String name;
private int grade;
@Transient//Transient表示该字段不参与序列化操作，不作为表中列名
private int tempUsageCount;
//…set(),get()方法省略
public Integer age;
@Generated(hash = 1097688115)
public User(Long id, String name, int grade, Integer age) {
this.id = id;
this.name = name;
this.grade = grade;
this.age = age;
}
@Generated(hash = 586692638)
public User() {
}
}
需要注意的是@Id：通过这个注解标记的字段必须是包装类型Long类型，表示该字段为主键，并且它默认就是自增。否则在升级/降级数据库的时候，会报错。
生成数据库操作类
成功构建工程之后，GreenDao会生成UserDao,DaoSession,DaoMaster三个文件。自动生成的Dao，Session，Master官方是不建议直接修改这些文件的代码，因为当数据库需要升级/降级的时候使用生成器重新生成将会覆盖之前修改过的代码
为方便操作，我们先封装一个DBManager类：
public class DBManager {
private static final String DB_NAME = "test.db";
private static DBManager mDbManager;
private static DaoMaster.DevOpenHelper mDevOpenHelper;
private static volatile DaoMaster mDaoMaster;
private static volatile DaoSession mDaoSession;
private Context mContext;
private DBManager(Context context) {
this.mContext = context;
// 初始化数据库信息
mDevOpenHelper = new DaoMaster.DevOpenHelper(context, DB_NAME);
getDaoMaster(context);
getDaoSession(context);
}
public static DBManager getInstance(Context context) {
if (null == mDbManager) {
synchronized (DBManager.class) {
if (null == mDbManager) {
mDbManager = new DBManager(context);
}
}
}
return mDbManager;
}
/**
* 获取可读数据库
*
* @param context
* @return
*/
public static SQLiteDatabase getReadableDatabase(Context context) {
if (null == mDevOpenHelper) {
getInstance(context);
}
return mDevOpenHelper.getReadableDatabase();
}
/**
* 获取可写数据库
*
* @param context
* @return
*/
public static SQLiteDatabase getWritableDatabase(Context context) {
if (null == mDevOpenHelper) {
getInstance(context);
}
return mDevOpenHelper.getWritableDatabase();
}
/**
* 获取DaoMaster
*
* 判断是否存在数据库，如果没有则创建数据库
*
* @param context
* @return
*/
public static DaoMaster getDaoMaster(Context context) {
if (null == mDaoMaster) {
synchronized (DbManager.class) {
if (null == mDaoMaster) {
mDevOpenHelper = new DaoMaster.DevOpenHelper(context, DB_NAME);
mDaoMaster = new DaoMaster(mDevOpenHelper.getWritableDb());
}
}
}
return mDaoMaster;
}
/**
* 获取DaoSession
*
* @param context
* @return
*/
public static DaoSession getDaoSession(Context context) {
if (null == mDaoSession) {
synchronized (DBManager.class) {
mDaoSession = getDaoMaster(context).newSession();
}
}
return mDaoSession;
}
}
对数据表的进行操作
添加User表数据
/**
* 向User表中添加一条记录
*/
private void addData() {
DaoMaster daoMaster = DBManager.getDaoMaster(mContext);
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
mUser = new User();
mUser.setName("Hubery" + System.currentTimeMillis());
mUser.setAge(15);
userDao.insert(mUser);
}
/**
* 更新一条记录
* @param user
*/
public void updateUser(User user) {
DaoMaster daoMaster = DBManager.getDaoMaster(mContext);
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.update(user);
}
/**
* 删除一条记录
*
* @param user
*/
public void deleteUser(User user) {
DaoMaster daoMaster = DBManager.getDaoMaster(mContext);
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
userDao.delete(user);
}
/**
* 查询用户列表
*/
public User queryUserModel(String curName) {
DaoMaster daoMaster = DBManager.getDaoMaster(mContext);
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
QueryBuilder qb = userDao.queryBuilder();
qb.where(UserDao.Properties.Name.like("%" + curName + "%")).build();
List list = qb.list();
if (list != null && list.size() > 0) {
Toast.makeText(mContext, list.get(0).getName(), Toast.LENGTH_LONG).show();
return list.get(0);
} else {
return null;
}
}
/**
* 查询用户列表
*/
public List queryUserList() {
DaoMaster daoMaster = DBManager.getDaoMaster(mContext);
DaoSession daoSession = daoMaster.newSession();
UserDao userDao = daoSession.getUserDao();
QueryBuilder qb = userDao.queryBuilder();
List list = qb.list();
return list;
}
当然GreenDao为我们封装的对表的操作还不仅仅是这些，包括表一对多等复杂操作，感兴趣的可以自行去查阅相关文档。
数据库中表升级/降级
说完GreenDao对数据表的基本操作之后，再来看看数据库的升级，数据库的升级需要继承android.database.sqlite包中的SQLiteOpenHelper类，升级/降级的操作需要在onUpgrade()方法中执行。
/**
* 数据库升级
* Created by hubery on 2018/2/9.
*/
public class OpenHelper extends DaoMaster.OpenHelper {
public OpenHelper(Context context, String name) {
super(context, name);
}
public OpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
//判断条件
//操作数据库的更新 有几个表升级都可以传入到下面
MigrationHelper.getInstance().migrate(db,UserDao.class);
}
}
当然在这里我们只是做一个功能的演示，并没有拿oldVersion和newVersion版本号去控制升级/降级。现在我们把升级/降级的操作都放到MigrationHelper中去，先来看看这个类：
**
* Created by hubery on 2018/2/8.
*/
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, Class>... daoClasses) {
generateTempTables(db, daoClasses);
DaoMaster.dropAllTables(db, true);// 重新创建新的数据库表
DaoMaster.createAllTables(db, false);
restoreData(db, daoClasses);
}
/**
* 生成临时列表
*
* @param db
* @param daoClasses
*/
private void generateTempTables(Database db, Class>... 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, Class>... 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;
}
}
public void migrate(Database db, Class>... daoClasses) {
generateTempTables(db, daoClasses);
restoreData(db, daoClasses);
}
这里升级的步骤：先创建一张临时表，把表中数据插入到临时表中，然后新建一个新的表，把临时表的数据拷贝到新表里面去，最后删除临时表。
性能效率对比
因为GreenDao框架对表进行CRU操作的时候，由于其本身底层使用的不是反射，而是编译时期生成的代码，而不是反射的机制，所以相对比其他的ORM关系型数据库而言，效率会高很多。
这是官网的一张对比截图以及官网的一段描述：
所有的ORM关系型数据库中，greendao是最快的。greendao不作任何妥协的性能。数据库非常适合存储大量数据，因此速度很快。使用greendao，大多数实体可以插入，更新，以每秒几千单位率加载。
另外提一下ObjectBox:ObjectBox是移动端数据库框架，灵感来自于NoSql，速度非常快，号称是市面上最快的移动端数据库框架。目前非关系行数据库也就只有Realm 能与之相比。
本文主要讲解了一下greendao的基本使用，包括引入greendao,greendao对于单表的CRUD操作，以及数据库升级，性能对比等。
GreenDao详解二