安卓GreenDao 3.0使用和源码分析
2017-10-10 本文已影响516人
miss2008
（一）GreenDao简介
GreenDao是一个对象关系映射（ORM）的开源框架，目前最主流的安卓数据库操作框架。
- 首先说说什么是对象关系映射ORM：Object Relational Mapping，是一种将对象层次结构映射成关系型结构的方法。
Object：即对象，java是一门面向对象的编程语言，对开发者而言，更习惯以对象的角度看待某个问题，或
者说通过面向对象的方式处理某个问题，对java程序员来说更能理解。
Relational：关系，SQLite是一种关系型数据库，其关系模型就是指二维表格模型,因而一个关系型数据库
就是由二维表及其之间的联系组成的一个数据组织，它是从数学理论发展而来的(百度百科的定
义)，这种关系型数据库与面向对象的思想是冲突的。开发人员需要时时去面对表单和数据库的
操作，特别是当表结构复杂时，会在这些数据的处理上花费大量时间。
Mapping：映射(可以通过Map来理解)，一种对应关系，用面向对象的方式来处理关系型结构的数据库。简单
的理解是一张表按照统一规则映射成一个java实体类，对表的操作可以转换对成开发者更熟悉
的对实体对象的操作。
- 通过上面的简单分析，来说说ORM框架的优缺点：
优点：
1，开发起来简单，ORM框架将我们的对象模型转化为SQL语句，只需要掌握一些api就能够操作数据库，
不用亲自处理sql语句了(下面greendao和原生Sqlite开发案例可以对比)。
2，当面对一个复杂的程序时，其内部较多的数据处理，sql语句大量的硬编码，会让代码显得混乱和不
易维护，ORM框架能让结构更清晰。
缺点：
1，虽然ORM框架开发起来简单，但是我们需要掌握的东西却更多了，框架需要去学习，SQL原生操作需
要去掌握。
2，在一些复杂的数据库操作(如多表关联查询)时，ORM语法会变得十分复杂。直接用SQL语句会更清晰
，更直接。
-
给出GreenDao的ORM体现图：
GreenDao的ORM体现.png
（二）GreenDao的简单使用
1，版本说明：作为演示，本文中会用到目前最新的版本greenDao3.2.2，更多的信息可以去github看看greenDao
2，在build.grade中配置插件信息并引入依赖包
- 2.1，声明添加的脚本类型和设置脚本运行环境
apply plugin: 'org.greenrobot.greendao'
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
}
}
- 2.2，添加依赖库
compile 'org.greenrobot:greendao:3.2.2'
- 2.3，自定义greendao的版本和路径
greendao {
schemaVersion 1
daoPackage 'com.example.android_db_biz.greedao'
targetGenDir 'src/main/java'
}
- 2.4，编译项目，引入Greendao
最后给出完整的build.gradle文件，里面有详细说明，这里在编译时会出现一个问题，具体解决办法可以借鉴这篇博文greenDao3.2.2配置出现的问题，这里面需要下载的文件我会在结束时给出。
apply plugin: 'com.android.library'
//1，声明添加的插件类型
apply plugin: 'org.greenrobot.greendao'
//2,设置脚本的运行环境(如果用在app启动模块，直接加3,4步,在lib模块整个需要加进去)
buildscript {
repositories {
//3，支持java 依赖库管理（maven/ivy）,用于项目的依赖。
mavenCentral() // add repository
}
dependencies {
//4，依赖包的定义。支持maven/ivy，远程，本地库，也支持单文件
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
}
}
//6，自定义Greendao版本和生成路径
greendao {
//数据库版本号，数据库修改后这里一定要记得修改，否则会报错no such table
schemaVersion 1
//通过gradle插件生成的数据库相关文件的包名，默认为你的entity所在的包名
daoPackage 'com.example.android_db_biz.greendao'
//这就是我们上面说到的自定义生成数据库文件的目录了，可以将生成的文件放到我们的java目录中
，而不是build中，这样就不用额外的设置资源目录了
targetGenDir 'src/main/java'
}
android {
compileSdkVersion 25
buildToolsVersion "25.0.2"
defaultConfig {
minSdkVersion 15
targetSdkVersion 25
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt')
, 'proguard-rules.pro'
}
}
}
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
androidTestCompile('com.android.support.test.espresso:espresso-core:2.2.2', {
exclude group: 'com.android.support', module: 'support-annotations'
})
compile 'com.android.support:appcompat-v7:25.3.1'
//5，添加依赖库
compile 'org.greenrobot:greendao:3.2.2'
testCompile 'junit:junit:4.12'
}
3，创建一个实体类，实体类添加@Entity注解
@Entity
public class Song {
@Id(autoincrement = true)
private Long id;
private String songName;
private Integer songId;
private String songDesc;
private String cover;
private Integer singerCode;
private String singerName;
private String createTime;
private String updateTime;
}
这里自增长的id类型一定是Long/long类型，否则会报如下错误：
Error:Execution failed for task ':android-db-biz:greendao'.
> Can't add field `Variable(type=VariableType(name=int, isPrimitive=true
, originalName=int, typeArguments=null), name=id)` for entity Song due
to: AUTOINCREMENT is only available to primary key properties of
type long/Long
4，build(Build->Make Project)项目
会自动生成一些数据库相关类，这些类在build.gradle里设置的目录下，而且实体类里面也会自动生成get/set方法
image.png
这里有多少个@Entity注释的实体类就会生成多少个相关的XXXDao类，XXXDao类里提供对实体类对应的表单的CRUD的操作方法，即ORM里提供以面向对象的方式来处理关系型数据库，不需要我们去写sql语句。
5，greenDao的简单使用
- 首先获取操作类DaoSession，默认数据库表存储在内存里，看看下面的DaoSessionManager ：
public class DaoSessionManager {
private final String DB_NAME = "android.db";
private DaoMaster daoMaster;
private DaoSession daoSession;
private DaoSessionManager() {
}
public static DaoSessionManager mInstance = new DaoSessionManager();
public static DaoSessionManager getInstace() {
return mInstance;
}
public DaoMaster getDaoMaster(Context mContext) {
DaoMaster.DevOpenHelper mHelper = new DaoMaster
.DevOpenHelper(mContext, DB_NAME, null);
daoMaster = new DaoMaster(mHelper.getWritableDatabase());
return daoMaster;
}
public DaoSession getDaoSession(Context mContext) {
if (daoSession == null) {
if (daoMaster == null) {
getDaoMaster(mContext);
}
daoSession = daoMaster.newSession();
}
return daoSession;
}
}
- 通过DaoSession获取上面实体类Song对应的表单操作类SongDao，并进行简单的CURD操作，具体复杂的SQL操作(如多表关联)，这里就不说明了：
//获取Song这张表的操作类SongDao
DaoSession daoSession = DaoSessionManager.getInstace()
.getDaoSession(getApplicationContext());
SongDao songDao = daoSession.getSongDao();
//创建一个对象
Song song = new Song();
song.setSingerCode(111);
//增加
songDao.insert(song);
//改
song.setSingerName("miss08");
songDao.update(song);
//查
Song query = songDao.queryBuilder().where(SongDao.Properties.SingerCode.eq(111))
.list().get(0);
//删
songDao.delete(song);
可以看出，在进行增删改查的操作并不需要我们去写相应的sql语句，只需要调用songDao的相关API就行。
6，数据库设置存储为本地路径
- 我现在调试用的小米手机，无法root所以没办法看到data/data目录下的数据情况，所有现在把数据库表单存储在手机本地目录下，方便查看数据库数据，对上面的DaoSessionManager的getDaoMaster方法进行修改(记得添加文件的读写权限)
//本地存储目录
private final String DB_PATH = "AndroidDevelopment/nc/miss08/database";
public DaoMaster getDaoMaster(Context mContext, final String path) {
DaoMaster.DevOpenHelper mHelper = new VersionChangeHelper
(new ContextWrapper(mContext) {
@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode,
SQLiteDatabase.CursorFactory factory) {
return SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
}
@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode,
SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
return SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
}
@Override
public File getDatabasePath(String name) {
File file = FileUtils.buildDataBasePath(path, name);
return file != null ? file : super.getDatabasePath(name);
}
}, DB_NAME);
daoMaster = new DaoMaster(mHelper.getWritableDatabase());
return daoMaster;
}
-
修改后，运行项目，在指定目录找到数据库文件android.db：
greendao的数据库文件.png
- 执行一次insert操作后，打开数据库查看Song表数据
sqlite数据库.png
7，数据库的版本升级
-
在上面基础上，不更新数据库的表单，只增加数据库的版本号，会发现数据库里所有数据被清空，下面通过源码分析下。
只修改版本信息.png
在基本数据库操作里，Sqlite的数据库更新是在SQLiteOpenHelper里的onUpgrade里进行的，在GreenDao框架里肯定会继承它来定制自己框架的需求，在DaoMaster里我们找到了GreenDao用来处理版本升级的类DevOpenHelper
/** WARNING: Drops all table on Upgrade! Use only during development. */
public static class DevOpenHelper extends OpenHelper {
...
@Override //数据库版本升级会触发这个方法
public void onUpgrade(Database db, int oldVersion, int newVersion) {
dropAllTables(db, true);
onCreate(db);
}
}
在其onUpgrade方法里会通过dropAllTables方法删除项目里所有的数据库，通过所有表单操作类XXXDao来删除所有表单。
/** Drops underlying database table using DAOs. */
public static void dropAllTables(Database db, boolean ifExists) {
//项目里所有实体类操作Dao，都会在此删除表单，当前项目里只有一张表
SongDao.dropTable(db, ifExists);
}
//找到SongDao的dropTable方法，就是执行一条删除表单的sql语句
public static void dropTable(Database db, boolean ifExists) {
String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"SONG\"";
db.execSQL(sql);
}
删除完成后，调用onCreate(db)方法创建所有表单，onCreate方法存在于DaoMaster里的OpenHelper类里，它是上面DevOpenHelper的父类
public static abstract class OpenHelper extends DatabaseOpenHelper {
...
@Override //数据库创建时触发的方法
public void onCreate(Database db) {
Log.i("greenDAO"
, "Creating tables for schema version " + SCHEMA_VERSION);
createAllTables(db, false);
}
}
//所有Dao都在此创建
public static void createAllTables(Database db, boolean ifNotExists) {
SongDao.createTable(db, ifNotExists);
}
故，GreenDao默认在版本升级时会删除所有表单然后再创建，如果用户想自己控制版本升级的情况，就需要自己实现OpenHelper。
-
项目每次编译运行时，DaoMaster里的内容都会恢复成默认状态，所以不要在DaoMaster的DevOpenHelper里进行业务操作。
-
数据库升级需要用户自定义DaoMaster.OpenHelper，在其onUpgrade实现方法里进行版本对比更新。这里借用一个开源解决办法MigrationHelper类，来完成数据库的升级，有现成的我们就直接拿来用，里面代码也挺清晰的，如果不想用也可以自己通过DaoMaster来处理，或者更直接的使用sql语句来处理。
-
MigrationHelper在我的demo里与greenDao不兼容，故直接把源码拿来用，其github目录为MigrationHelper解决greenDao版本升级，大家可以直接去这里找符合你greenDao的版本，这里先给出用法，后面会进行分析。
通过MigrationHelper进行版本升级
- 1，还是结合上面的例子，我们删除之前的本地数据库目录，并在之前的表单基础上再添加一张歌单表MenuInfo，这样项目中就存在两张表。
@Entity
public class MenuInfo {
@Id(autoincrement = true)
private Long id;
private String menuCode;
private String menuName;
private String createTime;
private String updateTime;
}
-
2，build项目，在两张表里都添加两条数据。此时数据库的schemaVersion版本号为1
menuInfo表创建.png
song表创建.png
-
3，如果我们在下个版本需要对MenuInfo的字段做在线更改，增加一个menuDesc字段，改为如下：
public class MenuInfo {
@Id(autoincrement = true)
private Long id;
private String menuCode;
private String menuName;
//增加的字段
private String menuDesc;
private String createTime;
private String updateTime;
}
- 4，版本升级，自定义DaoMaster.OpenHelper，然后在build.gradle里将schemaVersion版本改为2
public class VersionChangeHelper extends DaoMaster.DevOpenHelper {
public VersionChangeHelper(Context context, String name) {
this(context, name, null);
}
public VersionChangeHelper(Context context, String name, SQLiteDatabase
.CursorFactory factory) {
super(context, name, factory);
}
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
super.onUpgrade(db, oldVersion, newVersion);
Log.e("miss08", "oldVersion = " + oldVersion + "newVersion = " + newVersion);
MigrationHelper.migrate(db, new MigrationHelper.ReCreateAllTableListener() {
@Override
public void onCreateAllTables(Database db, boolean ifNotExists) {
Log.e("dongyiming", "onCreateAllTables");
//DaoMaster.createAllTables(db, ifNotExists);
}
@Override
public void onDropAllTables(Database db, boolean ifExists) {
Log.e("dongyiming", "onDropAllTables");
//DaoMaster.dropAllTables(db, ifExists);
}
}, MenuInfoDao.class);
}
}
}
同时修改其引用的地方DaoSessionManager的getDaoMaster方法：
DevOpenHelper mHelper = new VersionChangeHelper(new ContextWrapper(mContext)
- 5，运行项目，查看日志和数据库如下：
版本改变后，VersionChangeHelper的update方法被调用
10-08 18:22:07.797 22536-22536/com.example.pver.androiddevelopment E/miss08:
oldVersion = 1_newVersion = 2
表单信息为：
menuInfo表修改数据.png
song表没有更新.png
发现两张表都是空表，这是因为我们在上面onUpgrade方法里super.onUpgrade(db, oldVersion, newVersion)会先执行父类DaoMaster.DevOpenHelper里的删除所有表单数据的方法，这个上面有分析，现在我们去掉super.onUpgrade后，再假设重复上面的操作，就只有我们做过更新的MenuInfo表为空，其他表单还是有原始的数据。
menuInfo表修改数据.png
song表没有更新.png
MigrationHelper的简单分析
- 先看看MigrationHelper的migrate方法，它有三个重载方法，我们使用的那个方法有三个参数，分别为database，一个ReCreateAllTableListener回调，一个继承AbstractDao的class对象的可变参数类型。
public static void migrate(SQLiteDatabase db
, Class<? extends AbstractDao<?, ?>>... daoClasses) {
printLog("【The Old Database Version】" + db.getVersion());
Database database = new StandardDatabase(db);
migrate(database, daoClasses);
}
public static void migrate(Database database
, ReCreateAllTableListener listener
, Class<? extends AbstractDao<?, ?>>... daoClasses) {
weakListener = new WeakReference<>(listener);
migrate(database, daoClasses);
}
AbstractDao作为所有表单操作类(如MenuInfoDao)的父类，项目中有多少表单在当前版本进行了修改，我们调用migrate方法，就需要传多少进去。
MigrationHelper.migrate(db，listener，xxDao.class，xxDao.class，xxDao.class...);
也可调用没有listener的migrate方法，即不用回调给我们来处理数据库，其使用一样：
MigrationHelper.migrate(db，xxDao.class，xxDao.class，xxDao.class...);
- 在上面带listener的migrate方法里，首先用弱引用指向listener，后调用migrate另一个重载方法，传入database和修改的表单，方法如下。
public static void migrate(Database database
, Class<? extends AbstractDao<?, ?>>... daoClasses) {
//轮询daoClasses，看对应的表单是否存在，并创建临时表
generateTempTables(database, daoClasses);
//获取接口对象，在最初调用时会new WeakReference()，所以这里的listener不为空
ReCreateAllTableListener listener = weakListener.get();
if (listener != null) {
//执行回调
listener.onDropAllTables(database, true);
printLog("【Drop all table by listener】");
listener.onCreateAllTables(database, false);
printLog("【Create all table by listener】");
} else {
dropAllTables(database, true, daoClasses);
createAllTables(database, false, daoClasses);
}
printLog("【Restore data】start");
restoreData(database, daoClasses);
printLog("【Restore data】complete");
}
-
当 listener = null 时，会删除传入的Dao对应的那张表单，然后又重新创建这张表单，如果有新的数据就会存入更新后的表单里。
-
当 listener != null 时，会通过listener回调给用户自己处理，更加的灵活。
-
看看listener = null时删除和重新创建的方法，不管是创建还是删除最终会调用如下方法：
private static void reflectMethod(Database db, String methodName, boolean
isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
if (daoClasses.length < 1) {
return;
}
try {
for (Class cls : daoClasses) {
Method method = cls.getDeclaredMethod(methodName, Database.class
, boolean.class);
method.invoke(null, db, isExists);
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
reflectMethod方法里，会对daoClasses进行轮询，通过反射获取我们我们传入的daoClasses(本例中只有一个为MenuInfoDao)里的名为methodName的方法对象，然后通过invoke执行MenuInfoDao类中的该方法，展示我们需要调用的两个方法dropTable和createTable。
//传入的false
/** Creates the underlying database table. */
public static void createTable(Database db, boolean ifNotExists) {
String constraint = ifNotExists? "IF NOT EXISTS ": "";
db.execSQL("CREATE TABLE " + constraint + "\"MENU_INFO\" (" + //
"\"_id\" INTEGER PRIMARY KEY AUTOINCREMENT ," + // 0: id
"\"MENU_CODE\" TEXT," + // 1: menuCode
"\"MENU_NAME\" TEXT," + // 2: menuName
"\"MENU_DESC\" TEXT," + // 3: menuDesc
"\"CREATE_TIME\" TEXT," + // 4: createTime
"\"UPDATE_TIME\" TEXT);"); // 5: updateTime
}
//传入的true
/** Drops the underlying database table. */
public static void dropTable(Database db, boolean ifExists) {
String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "")
+ "\"MENU_INFO\"";
db.execSQL(sql);
}
这里会销毁之前的那张表然后重新创建一张新表，所以表里原有数据是不会存在的，这里只有传入的XXXDao.class做删除和重建的工作，其他表单是不会受影响的，有回调的就得看用户自己的需求了。
上面的例子演示了MigrationHelper对一个/多个表字段的更新(增删都一样)，现在我们来演示在线增加一张/多张表。
- 首先在项目里添加一张表Singer，然后build项目，现在整个项目中就存在三张表
@Entity
public class Singer {
@Id(autoincrement = true)
private Long id;
private String singerCode;
private String singerName;
}
- 数据库版本加1，修改VersionChangeHelper方法如下，这里演示没有listener回调的方法，然后运行项目
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
super.onUpgrade(db, oldVersion, newVersion);
Log.e("miss08", "oldVersion = " + oldVersion + "_newVersion = " + newVersion);
MigrationHelper.migrate(db, SingerDao.class);
}
- 项目运行时会出现一个问题，MigrationHelper里migrate对listener的非空判断，这里修改一下然后重新运行
public static void migrate(Database database
, Class<? extends AbstractDao<?, ?>>... daoClasses) {
printLog("【Generate temp table】start");
generateTempTables(database, daoClasses);
printLog("【Generate temp table】complete");
//添加非空判断
ReCreateAllTableListener listener = null;
if (weakListener != null) {
listener = weakListener.get();
}
if (listener != null) {
...省略
}
}
-
项目运行成功后，发现确实出现了三张表，这里只展示第三张表：
数据库里所有表单.png
singer表创建.png
最后说说更新版本时删除表操作
- 实现方式挺多的，提供几种建议（前提是自己的helper里不要有super父类更新方法），这里我只用第一种方案试过并成功，其他几种就不演示了。
1,不使用MigrationHelper直接通过SingerDao里的dropTable(db, true)方法完成
2,不使用MigrationHelper直接通过sql语句完成
3,使用MigrationHelper，对里面代码简单修改下，通过reflectMethod来处理传入的daoClasses
（三）GreenDao源码的简单分析
说明：
要查看具体源码，可以到github下载greenDao，里面有它的源码和操作demo。
-
1，用户可操作的几个类的关系图如下：
GreenDao类图.png
- 2，DaoGenerator：通过给定的模板Schema和路径生成相应的实体类和Dao相关的类。Schema的关系图如下：
Schema.png
Schema的操作方式如下，包含了数据库的相关信息：
//版本和包名
Schema schema = new Schema(1, "org.greenrobot.greendao.daotest2");
Entity keepEntity = schema2.addEntity("KeepEntity");
keepEntity .addIdProperty();
keepEntity .addStringProperty("count");
keepEntity .addStringProperty("select");
keepEntity .addStringProperty("sum");
keepEntity .addStringProperty("avg");
keepEntity .addStringProperty("join");
再来看看DaoGenerator里生成实体类和Daos的方法generateAll
/** Generates all entities and DAOs for the given schema. */
public void generateAll(Schema schema, String outDir, String outDirEntity
, String outDirTest) throws Exception {
List<Entity> entities = schema.getEntities();
for (Entity entity : entities) {
generate(templateDao, outDirFile, entity.getJavaPackageDao()
, entity.getClassNameDao(), schema, entity);
}
generate(templateDaoMaster, outDirFile, schema.getDefaultJavaPackageDao(),
schema.getPrefix() + "DaoMaster", schema, null);
generate(templateDaoSession, outDirFile, schema.getDefaultJavaPackageDao(),
schema.getPrefix() + "DaoSession", schema, null);
}
- 3，DaoMaster：插件生成的daos的最顶层，可以看它的注释(如下)
Master of DAO (schema version 16): knows all DAOs.
包含项目所有表单的创建工作createAllTables和升级处理（先dropAllTables再createAllTables）
public static void createAllTables(Database db, boolean ifNotExists) {
SingerDao.createTable(db, ifNotExists);
MenuInfoDao.createTable(db, ifNotExists);
SongDao.createTable(db, ifNotExists);
}
public static void dropAllTables(Database db, boolean ifExists) {
SingerDao.dropTable(db, ifExists);
MenuInfoDao.dropTable(db, ifExists);
SongDao.dropTable(db, ifExists);
}
还有DaoSession的创建方法，创建时会传入daoConfigMap，这个daoConfigMap是项目所有表单操作类XXXDao的class对象缓存，它是在创建DaoMaster时创建和存入class的。
public DaoSession newSession() {
return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);
}
看看DaoMaster的构造方法，通过registerDaoClass方法把当前项目里所有的XXXDao的class对象缓存起来(这里不是实例对象，是class对象，一般用来搞反射)。
public DaoMaster(SQLiteDatabase db) {
this(new StandardDatabase(db));
}
public DaoMaster(Database db) {
super(db, SCHEMA_VERSION);
registerDaoClass(SingerDao.class);
registerDaoClass(MenuInfoDao.class);
registerDaoClass(SongDao.class);
}
在DaoMaster的父类中AbstractDaoMaster缓存起来，
protected final Map<Class<? extends AbstractDao<?, ?>>, DaoConfig> daoConfigMap;
protected void registerDaoClass(Class<? extends AbstractDao<?, ?>> daoClass) {
DaoConfig daoConfig = new DaoConfig(db, daoClass);
daoConfigMap.put(daoClass, daoConfig);
}
registerDaoClass方法缓存数据前，会创建一个DaoConfig，DaoConfig里面存储了很多Dao的基本数据，如下
public final Database db;
public final String tablename;
public final Property[] properties;
public final String[] allColumns;
public final String[] pkColumns;
public final String[] nonPkColumns;
我们再看看DaoConfig的这个构造方法，通过reflectProperties方法获取到Property数组。Property里的数据描述了映射到数据库里列的属性。用于创建查询构建器使用的对象(包含所有select查询用到的条件操作)。
public DaoConfig(Database db, Class<? extends AbstractDao<?, ?>> daoClass) {
this.db = db;
try {
this.tablename = (String) daoClass.getField("TABLENAME").get(null);
Property[] properties = reflectProperties(daoClass);
allColumns = new String[properties.length];
List<String> pkColumnList = new ArrayList<String>();
List<String> nonPkColumnList = new ArrayList<String>();
Property lastPkProperty = null;
for (int i = 0; i < properties.length; i++) {
Property property = properties[i];
String name = property.columnName;
allColumns[i] = name;
if (property.primaryKey) {
pkColumnList.add(name);
lastPkProperty = property;
} else {
nonPkColumnList.add(name);
}
}
}
}
reflectProperties这个方法里，通过反射获取AbstractDao类的内部类Properties里所有的静态字段和public字段，然后再通过field.get(null)获取所有字段的属性值，存储这些属性值。
private static Property[] reflectProperties(Class<? extends AbstractDao<?, ?>>
daoClass) throws ClassNotFoundException, IllegalArgumentException
, IllegalAccessException {
Class<?> propertiesClass = Class.forName(daoClass.getName() + "$Properties");
Field[] fields = propertiesClass.getDeclaredFields();
ArrayList<Property> propertyList = new ArrayList<Property>();
final int modifierMask = Modifier.STATIC | Modifier.PUBLIC;
for (Field field : fields) {
if ((field.getModifiers() & modifierMask) == modifierMask) {
Object fieldValue = field.get(null);
if (fieldValue instanceof Property) {
propertyList.add((Property) fieldValue);
}
}
}
}
以SingerDao为例，看看其内部类的字段和属性：属性值就是一个Property对象，包含实体类的字段名，对应的数据库里的列名，以及类型
public class SingerDao extends AbstractDao<Singer, Long> {
public static class Properties {
public final static Property Id = new Property(0, Long.class
, "id", true, "_id");
public final static Property SingerCode = new Property(1, String.class
, "singerCode", false, "SINGER_CODE");
public final static Property SingerName = new Property(2, String.class
, "singerName", false, "SINGER_NAME");
public final static Property SingerDesc = new Property(3, String.class
, "singerDesc", false, "SINGER_DESC");
}
}
- 4，DaoSession：在构造里创建出XXXDao的实例对象。
public DaoSession(Database db, IdentityScopeType type, Map<Class<?
extends AbstractDao<?, ?>>, DaoConfig> daoConfigMap) {
super(db);
singerDaoConfig = daoConfigMap.get(SingerDao.class).clone();
singerDaoConfig.initIdentityScope(type);
menuInfoDaoConfig = daoConfigMap.get(MenuInfoDao.class).clone();
menuInfoDaoConfig.initIdentityScope(type);
songDaoConfig = daoConfigMap.get(SongDao.class).clone();
songDaoConfig.initIdentityScope(type);
singerDao = new SingerDao(singerDaoConfig, this);
menuInfoDao = new MenuInfoDao(menuInfoDaoConfig, this);
songDao = new SongDao(songDaoConfig, this);
registerDao(Singer.class, singerDao);
registerDao(MenuInfo.class, menuInfoDao);
registerDao(Song.class, songDao);
}
构造方法里，首先从传入的daoConfigMap里获取DaoConfig，通过原型模式创建DaoConfig对象，然后创建XXXDao的实例，DaoConfig对象做为Dao的构参传入，最后在DaoSession的父类里用Map<Class<?>, AbstractDao<?, ?>>集合缓存实例类和它的操作类对象。
接下来看看DaoSession的父类AbstractDaoSession，在AbstractDaoSession提供基本增删改查的方法，但是数据库真正的执行者确是AbstractDao，从上面的缓存里获取的AbstractDao。
public <T> long insert(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
return dao.insert(entity);
}
public <T> long insertOrReplace(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
return dao.insertOrReplace(entity);
}
public <T> void update(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
dao.update(entity);
}
public <T> void delete(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
dao.delete(entity);
}
public <T, K> List<T> queryRaw(Class<T> entityClass, String where
, String... selectionArgs) {
@SuppressWarnings("unchecked")
AbstractDao<T, K> dao = (AbstractDao<T, K>) getDao(entityClass);
return dao.queryRaw(where, selectionArgs);
}
public <T> QueryBuilder<T> queryBuilder(Class<T> entityClass) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entityClass);
return dao.queryBuilder();
}
还有支持数据库的Rx方式（没用过，这里不分析）
@Experimental
public RxTransaction rxTx() {
if (rxTxIo == null) {
rxTxIo = new RxTransaction(this, Schedulers.io());
}
return rxTxIo;
}
@Experimental
public RxTransaction rxTxPlain() {
if (rxTxPlain == null) {
rxTxPlain = new RxTransaction(this);
}
return rxTxPlain;
}
接下来看看数据库的真实操作类XXXDao
- 5，XXXDao：数据库提供的真实操作类：提供所有数据库的操作方式。这里就只通过查询语句来分析一下它的操作过程（以Singer表为例）。
GreenDao查询语句
singerDao.queryBuilder().where(Properties.SingerCode.eq("111")).orderAsc(Properties.SINGER_NAME).list();
对比下sqlite的查询的两种方式
1，db.rawQuery(sql)
select * from SINGER where SINGER_CODE = ‘111’ order by SINGER_NAME asc；
2，db.query(...)
query(String table, String[] columns, String selection,String[] selectionArgs
, String groupBy, String having,String orderBy, String limit)
query("Singer",null,"SINGER_CODE = ?",new String[]{"111"},"null","null"
,"SINGER_NAME asc")
下面分析GreenDao的查询，在XXXDao的父类AbstractDao里找到queryBuilder方法，该方法里会创建一个QueryBuilder对象，我们来看看QueryBuilder的描述：
Builds custom entity queries using constraints and parameters and without SQL
(QueryBuilder creates SQL for you)
使用约束条件和参数来构造实体对象的查询，而不使用SQL语句（QueryBuilder 为我们生成SQL语句）
QueryBuilder的where方法，使用一个类WhereCondition来收集所有的条件，这个在下面的build方法里会被用到。
public QueryBuilder<T> where(WhereCondition cond, WhereCondition... condMore) {
whereCollector.add(cond, condMore);
return this;
}
接着看QueryBuilder类的orderAsc方法，实际会调用下面这个方法，分析见里面注释。
private void orderAscOrDesc(String ascOrDescWithLeadingSpace, Property... properties)
{
for (Property property : properties) {
//获取StringBuilder对象拼接字符串，没有就创建，存在就append(",")
checkOrderBuilder();
//首先判断排序的字段属于Singer表里字段，然后拼装该columnName
append(orderBuilder, property);
//字段是String类型并且stringOrderCollation不为空，
if (String.class.equals(property.type) && stringOrderCollation != null) {
//拼接stringOrderCollation = " COLLATE NOCASE"
orderBuilder.append(stringOrderCollation);
}
//拼装ASC
orderBuilder.append(ascOrDescWithLeadingSpace);
}
}
最终会创建一个orderBuilder，里面包含“SINGER_NAME asc”
最后看QueryBuilder类的list方法，list方法里先执行build方法，然后执行build方法返回对象的list方法。
public List<T> list() {
return build().list();
}
先找到build方法，build里会做很多拼接工作。
public Query<T> build() {
//创建一个StringBuilder对象，拼接工作下面分析
StringBuilder builder = createSelectBuilder();
//判断是否有LIMIT和OFFSET条件，如果有则拼接上
int limitPosition = checkAddLimit(builder);
int offsetPosition = checkAddOffset(builder);
String sql = builder.toString();
checkLog(sql);
//返回一个Query对象，查询操作返回的结果(实体类或游标)，values是position的值
return Query.create(dao, sql, values.toArray(), limitPosition, offsetPosition);
}
重点看看上面build方法里执行的createSelectBuilder方法，他会拼接返回完整的用于查询条件的select语句
private StringBuilder createSelectBuilder() {
//创建一个StringBuilder，拼接“SELECT FROM tablename”
String select = SqlUtils.createSqlSelect(dao.getTablename(), tablePrefix
, dao.getAllColumns(), distinct);
StringBuilder builder = new StringBuilder(select);
//如果上面的whereCollector条件集合有值，拼接“WHERE”和条件
appendJoinsAndWheres(builder, tablePrefix);
//orderBuilder如果存在则拼接“ORDER BY ”和orderBuilder,这个在上面分析过
if (orderBuilder != null && orderBuilder.length() > 0) {
builder.append(" ORDER BY ").append(orderBuilder);
}
//返回最终拼装的StringBuilder
return builder;
}
再看最后的list方法调用，这个方法在类Query里，找到了我们最熟悉的Sqlite操作dao.getDatabase().rawQuery，查询传入我们上面拼接的sql语句和传入的参数值，得到游标，轮询就能返回结果。
public List<T> list() {
checkThread();
Cursor cursor = dao.getDatabase().rawQuery(sql, parameters);
return daoAccess.loadAllAndCloseCursor(cursor);
}
最后说明
在分析完GreenDao的查询流程后，发现XXXDao对数据库的操作最终还是Sqlite里对sql语句的操作。体现了ORM面向对象操作和关系数据表操作的映射，所以要想熟练使用GreenDao对数据库的操作，必须得先掌握SQLite里对数据库的操作和常用的SQL语句的书写。
（四）Sqlite数据库的使用案例：
下面这个案例是之前的公司项目在迭代Orimlite框架前，对数据库的操作，对比下GreenDao的使用方式，这里就直接给出代码，就不做多余的分析，最终的demo里也会给出完整代码。
- 1，创建基类
public class Singer {
private int id;
private String singerCode;
private String singerName;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getSingerCode() {
return singerCode;
}
public void setSingerCode(String singerCode) {
this.singerCode = singerCode;
}
public String getSingerName() {
return singerName;
}
public void setSingerName(String singerName) {
this.singerName = singerName;
}
}
- 2，自定义SqliteOpenHelper，设置版本号，数据库名称，完成初始化表格的创建和更新的操作
public class DBHelper extends SQLiteOpenHelper {
//数据库名
private static final String DB_NAME = "android2.db";
//版本号
private static final int VERSION_CODE = 1;
//创建table的sql语句
private static final String SQL_CREATE_TABLE = String.format
("create table %s ( " +
"%s integer primary key autoincrement" +
",%s text" +
",%s text)"
, ISingerRepository.TABLE
, ISingerRepository.ID
, ISingerRepository.SINGER_CODE
, ISingerRepository.SINGER_NAME);
public DBHelper(Context mContext) {
super(mContext, DB_NAME, null, VERSION_CODE);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(SQL_CREATE_TABLE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
//增加一列
String sql = String.format("alter table %s add %s text", ISingerRepository
.TABLE, ISingerRepository.SINGER_DESC);
db.execSQL(sql);
}
}
- 3，把表单存储到sd卡里，需要自定义ContextWrapper，在构建helper时传入这个context即可
public class DataBaseContext extends ContextWrapper {
private static final String DB_PATH = "AndroidDevelopment/nc/miss08/database";
public DataBaseContext(Context base) {
super(base);
}
@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode
, SQLiteDatabase.CursorFactory factory) {
return SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
}
@Override
public SQLiteDatabase openOrCreateDatabase(String name, int mode
, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
return SQLiteDatabase.openOrCreateDatabase(getDatabasePath(name), null);
}
@Override
public File getDatabasePath(String name) {
File file = FileUtils.buildDataBasePath(DB_PATH, name);
return file != null ? file : super.getDatabasePath(name);
}
}
- 4，把数据库操作的一些公共方法放到一个BaseRepository中
public class BaseRepository<T> {
public final DBHelper dbHelper;
public BaseRepository(Context mContext) {
DataBaseContext context = new DataBaseContext(mContext);
this.dbHelper = new DBHelper(context);
}
public long insert(String table, String nullColumnHack, ContentValues values) {
long ret = 0L;
SQLiteDatabase database = this.dbHelper.getWritableDatabase();
database.beginTransaction();
try {
ret = database.insert(table, nullColumnHack, values);
database.setTransactionSuccessful();
} catch (RuntimeException var11) {
Log.e("miss08", "exception : " + var11);
} finally {
database.endTransaction();
}
return ret;
}
public <T> List<T> query(String table, String[] columns, String selection
, String[] selectionArgs, String groupBy, String having, String orderBy
, Integer limit) {
Object results = new ArrayList();
Cursor cursor = null;
try {
if (limit != null) {
cursor = this.dbHelper.getReadableDatabase().query(table, columns
, selection , selectionArgs, groupBy, having, orderBy, limit + "");
} else {
cursor = this.dbHelper.getReadableDatabase().query(table, columns
, selection, selectionArgs, groupBy, having, orderBy);
}
results = this.queryResult(cursor);
} catch (RuntimeException var15) {
Log.e("miss08", "exception : " + var15);
} finally {
if (cursor != null) {
cursor.close();
}
}
return (List) results;
}
public <T> List<T> query(String table, String[] columns, String selection
, String[] selectionArgs, String groupBy, String having, String orderBy) {
return this.query(table, columns, selection, selectionArgs, groupBy, having
, orderBy, (Integer) null);
}
public <T> List<T> queryResult(Cursor cursor) {
throw new RuntimeException("Please overwrite method.");
}
public int update(String table, ContentValues values, String whereClause
, String[] whereArgs) {
int ret = 0;
SQLiteDatabase database = this.dbHelper.getWritableDatabase();
database.beginTransaction();
try {
ret = database.update(table, values, whereClause, whereArgs);
database.setTransactionSuccessful();
} catch (RuntimeException var11) {
Log.e("miss08", "exception : " + var11);
} finally {
database.endTransaction();
}
return ret;
}
public int delete(String table, String whereClause, String[] whereArgs) {
int ret = 0;
SQLiteDatabase database = this.dbHelper.getWritableDatabase();
database.beginTransaction();
try {
ret = database.delete(table, whereClause, whereArgs);
database.setTransactionSuccessful();
} catch (RuntimeException var10) {
Log.e("miss08", "exception : " + var10);
} finally {
database.endTransaction();
}
return ret;
}
}
- 5，创建Singer表的操作类SingerRepository
public class SingerRepository extends BaseRepository<Singer>
implements ISingerRepository<Singer, Integer> {
public SingerRepository(Context mContext) {
super(mContext);
}
@Override
public long add(Singer singer) {
ContentValues cv = getContentValues(singer);
long res = insert(TABLE, null, cv);
return res;
}
@Override
public int update(Singer singer) {
ContentValues cv = getContentValues(singer);
String whereClause = String.format("%s = ?", SINGER_CODE);
update(TABLE, cv, whereClause, new String[]{singer.getSingerCode()});
return 0;
}
@Override
public Singer queryById(Integer id) {
String sql = String.format("%s = ?", ID);
List<Singer> singerList = query(TABLE, null, sql
, new String[]{String.valueOf(id)}, null, null, null);
if (singerList != null) {
return singerList.get(0);
}
return null;
}
@Override
public List<Singer> queryForAll() {
return query(TABLE, null, null, null, null, null, null);
}
@Override
public int delete(Integer id) {
String sql = String.format("delete from %s where %s = ?", TABLE, ID);
dbHelper.getWritableDatabase()
.execSQL(sql, new String[]{String.valueOf(id)});
return 0;
}
public ContentValues getContentValues(Singer singer) {
ContentValues contentValues = new ContentValues();
contentValues.put(SINGER_CODE, singer.getSingerCode());
contentValues.put(SINGER_NAME, singer.getSingerName());
return contentValues;
}
//查询需要对cursor遍历，父类需要的方法
public List<Singer> queryResult(Cursor cursor) {
List<Singer> list = new ArrayList<>();
while (cursor.moveToNext()) {
Singer singer = new Singer();
singer.setId(cursor.getInt(cursor.getColumnIndex(ID)));
singer.setSingerName(
cursor.getString(cursor.getColumnIndex(SINGER_NAME)));
singer.setSingerCode(
cursor.getString(cursor.getColumnIndex(SINGER_CODE)));
list.add(singer);
}
return list;
}
}
- 6，在接口里统一Singer表的名称和字段以及方法
public interface ISingerRepository<T, ID> {
public static final String TABLE = "singer";
public static final String COLUMN_PREFIX = TABLE.concat("_");
public static final String ID = "_id";
public static final String SINGER_CODE = COLUMN_PREFIX + "code";
public static final String SINGER_NAME = COLUMN_PREFIX + "name";
public static final String SINGER_DESC = COLUMN_PREFIX + "desc";
//只给出简单的增删改查
public long add(T var1);
public int update(T var1);
T queryById(ID var1);
List<T> queryForAll();
int delete(ID var1);
}
- 7，在MainActivity里操作数据库
SingerRepository singerRepository = new SingerRepository(this);
Singer singer = new Singer();
singer.setSingerCode("112");
singer.setSingerName("张三");
singerRepository.add(singer);
- 8，上面Demo自测表的创建成功，而且对表的所有操作方法都通过验证。
总结：
上面就是所有对GreenDao的简单分析，由于公司使用的是ORMLite框架，所以GreenDao里比较复杂的一些操作(多表关联/事物的处理/版本跳级更新/融合Rxjava等)这里都没演示，一是使用不熟练，二是目前确实没时间慢慢弄，文章里所有demo都是自己操作成功的，如果有什么其他问题和建议可留言。
其他：
本文所有demo的github地址（gradle-3.5-all在项目根目录下，解压使用）：GreenDao和SQLite的使用
