我们在Android开发的时候,经常会牵涉到数据的保存,相比SharedPreferences,数据库可以让我们保存种类更多的数据,而且很多时候我们需要增删改查大量数据,这个时候数据库的优势就体现出来了。在与数据库打交道时,我们当然可以使用SQLiteDatabase和SQLiteOpenHelper进行数据库的操作,但是我们要记住大量的sql语句,显然是不方便的。目前封装比较好的数据库操作框架有Ormlite和GreenDao,而GreenDao使用起来配合注解,显然更加符合现在开发,也较Ormlite方便,下面我们就开启GreenDao之旅。
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中,这样就不用额外的设置资源目录了
在实体类上添加注解@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的基本使用
知晓了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());
使用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, Class extends 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, Class extends 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, Class extends 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'
}
这样就完成了数据库表的更新。
混淆打包时,我们需要在proguard-rules.pro文件下添加:
-keepclassmembersclass*extendsde.greenrobot.dao.AbstractDao {
publicstaticjava.lang.String TABLENAME;
}
-keepclass**$Properties
以上就是我对GreenDao 3.0 的使用
奉上demo地址:https://github.com/Mr-zhang0101/GreenDaoTest