在上一篇GreenDao详解一中有讲到，GreenDao在build的时候，会自动生成DaoMaster, DaoSession,xxDao三个文件，我们通过上一篇的知识了解到，插入一条数据可以这样写：
private void insertUser(User user){
//DaoMaster daoMaster = DbManager.getDaoMaster(mContext);
DaoMaster.DevOpenHelper mDevOpenHelper = new DaoMaster.DevOpenHelper(mContext, DB_NAME);
DaoMaster mDaoMaster = new DaoMaster(mDevOpenHelper.getWritableDb());
UserDao userDao = daoMaster.newSession().getUserDao();
userDao.insert(user);
}
先来理一理他们的调用关系：
DaoMaster中创建并获得DaoSession，而DaoSession创建和管理xxDao,而xxDao则对xxEntity进行数据的CRUD操作。为了直观，这里给出了一个关系图：
GreenDao_Generator.png
DaoMaster
DaoMaster是对数据库进行相关操作的一个封装类，内部包括了创建表，删除表的方法，还包括两个静态抽象类OpenHelper和DevOpenHelper，OpenHelper继承于SQLiteOpenHelper，通过源码我们看到最终会调用到createAllTabes方法来创建数据库中的表；而DevOpenHelper继承于OpenHelper，主要通过onUpgrade方法用于数据库的升级，另外，它还包含一个newSession()方法，在方法内返回一个DaoSession对象，DaoSession是连接GreenDao框架到SQLite数据库的桥梁，通过该对象我们可以得到一个与xxx表相关的操作对象xxxDao。
我们先来看看DaoMaster的源码:
public class DaoMaster extends AbstractDaoMaster {
public static final int SCHEMA_VERSION = 1;
/** Creates underlying database table using DAOs. */
public static void createAllTables(Database db, boolean ifNotExists) {
UserDao.createTable(db, ifNotExists);
}
/** Drops underlying database table using DAOs. */
public static void dropAllTables(Database db, boolean ifExists) {
UserDao.dropTable(db, ifExists);
}
/**
* WARNING: Drops all table on Upgrade! Use only during development.
* Convenience method using a {@link DevOpenHelper}.
*/
public static DaoSession newDevSession(Context context, String name) {
Database db = new DevOpenHelper(context, name).getWritableDb();
DaoMaster daoMaster = new DaoMaster(db);
return daoMaster.newSession();
}
public DaoMaster(SQLiteDatabase db) {
this(new StandardDatabase(db));
}
public DaoMaster(Database db) {
super(db, SCHEMA_VERSION);
registerDaoClass(UserDao.class);
}
public DaoSession newSession() {
return new DaoSession(db, IdentityScopeType.Session, daoConfigMap);
}
public DaoSession newSession(IdentityScopeType type) {
return new DaoSession(db, type, daoConfigMap);
}
/**
* Calls {@link #createAllTables(Database, boolean)} in {@link #onCreate(Database)} -
*/
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);
}
}
/** WARNING: Drops all table on Upgrade! Use only during development. */
public static class DevOpenHelper extends OpenHelper {
public DevOpenHelper(Context context, String name) {
super(context, name);
}
public DevOpenHelper(Context context, String name, CursorFactory factory) {
super(context, name, factory);
}
@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);
}
}
}
在DaoMaster构造函数中，会调用父类AbstractDaoMaster的构造函数和registerDaoClass方法：
public DaoMaster(Database db) {
super(db, SCHEMA_VERSION);
registerDaoClass(UserDao.class);
}
public AbstractDaoMaster(Database db, int schemaVersion) {
this.db = db;
this.schemaVersion = schemaVersion;
daoConfigMap = new HashMap<Class<? extends AbstractDao<?, ?>>, DaoConfig>();
}
protected void registerDaoClass(Class<? extends AbstractDao<?, ?>> daoClass) {
DaoConfig daoConfig = new DaoConfig(db, daoClass);
daoConfigMap.put(daoClass, daoConfig);
}
上面的代码中维护了一个daoConfigMap的集合，它是以daoClass为key，DaoConfig为Value的集合。
DaoConfig源码：
public final class DaoConfig implements Cloneable {
public final Database db;
public final String tablename;
public final Property[] properties;
public final String[] allColumns;
public final String[] pkColumns;
public final String[] nonPkColumns;
/** Single property PK or null if there's no PK or a multi property PK. */
public final Property pkProperty;
public final boolean keyIsNumeric;
public final TableStatements statements;
private IdentityScope<?, ?> identityScope;
public DaoConfig(Database db, Class<? extends AbstractDao<?, ?>> daoClass) {
this.db = db;
try {
this.tablename = (String) daoClass.getField("TABLENAME").get(null);
Property[] properties = reflectProperties(daoClass);
//省略部分代码
//pkColumns对应表中主键的集合，allColumns表中所有字段集合
statements = new TableStatements(db, tablename, allColumns, pkColumns);
//省略部分代码
} catch (Exception e) {
throw new DaoException("Could not init DAOConfig", e);
}
}
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) {
// There might be other fields introduced by some tools, just ignore them (see issue #28)
if ((field.getModifiers() & modifierMask) == modifierMask) {
Object fieldValue = field.get(null);
if (fieldValue instanceof Property) {
propertyList.add((Property) fieldValue);
}
}
}
Property[] properties = new Property[propertyList.size()];
for (Property property : propertyList) {
if (properties[property.ordinal] != null) {
throw new DaoException("Duplicate property ordinals");
}
properties[property.ordinal] = property;
}
return properties;
}
// //省略部分代码
}
DaoConfig主要通过传入的daoClass参数并通过反射去拿到对应表中的相应信息，并通过TableStatements(db, tablename, allColumns, pkColumns);创建一个TableStatements对象。而这个TableStatements对象注释上面有写是为特定表创建SQL语句的Help类，而该对象会在AbstractDao类中使用，以方便继承了AstractDao的类使用。
DaoSession
DaoSession用于获得能够操作数据库的XXDao对象，它建立了与SQLite数据库之间的连接(会话)，其中，getUserDao方法用于返回相UserDao的对象，我们在操作数据库的时候，通过XXDao对象去对数据库数据进行CRUD操作。
public class DaoSession extends AbstractDaoSession {
private final DaoConfig userDaoConfig;
private final UserDao userDao;
public DaoSession(Database db, IdentityScopeType type, Map<Class<? extends AbstractDao<?, ?>>, DaoConfig>
daoConfigMap) {
super(db);
userDaoConfig = daoConfigMap.get(UserDao.class).clone();
userDaoConfig.initIdentityScope(type);
userDao = new UserDao(userDaoConfig, this);
registerDao(User.class, userDao);
}
public void clear() {
userDaoConfig.clearIdentityScope();
}
public UserDao getUserDao() {
return userDao;
}
}
DaoSession 继承于AbstractDaoSession，而AbstractDaoSession里面实现了很多操作数据库表的方法，而这些方法最后会调用到AbstractDao中的相关方法，现在我们来看看AbstractDaoSession的实现：
public class AbstractDaoSession {
private final Database db;
private final Map<Class<?>, AbstractDao<?, ?>> entityToDao;
private volatile RxTransaction rxTxPlain;
private volatile RxTransaction rxTxIo;
public AbstractDaoSession(Database db) {
this.db = db;
this.entityToDao = new HashMap<Class<?>, AbstractDao<?, ?>>();
}
protected <T> void registerDao(Class<T> entityClass, AbstractDao<T, ?> dao) {
entityToDao.put(entityClass, dao);
}
/** Convenient call for {@link AbstractDao#insert(Object)}. */
public <T> long insert(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
return dao.insert(entity);
}
/** Convenient call for {@link AbstractDao#insertOrReplace(Object)}. */
public <T> long insertOrReplace(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
return dao.insertOrReplace(entity);
}
/** Convenient call for {@link AbstractDao#refresh(Object)}. */
public <T> void refresh(T entity) {
@SuppressWarnings("unchecked")
AbstractDao<T, ?> dao = (AbstractDao<T, ?>) getDao(entity.getClass());
dao.refresh(entity);
}
//省略部分代码
}
XXDao
XXDao通过GreenDao生成器生成的数据库操作类，它继承于AbstractDao，从而可以调用AbstractDao中对数据库表进行CRUD的方法。
public class UserDao extends AbstractDao<User, Long> {
public static final String TABLENAME = "USER";
/**
* Properties of entity User.<br/>
* Can be used for QueryBuilder and for referencing column names.
*/
public static class Properties {
public final static Property Id = new Property(0, Long.class, "id", true, "_id");
public final static Property Name = new Property(1, String.class, "name", false, "NAME");
public final static Property Grade = new Property(2, int.class, "grade", false, "GRADE");
public final static Property Age = new Property(3, Integer.class, "age", false, "AGE");
}
public UserDao(DaoConfig config) {
super(config);
}
public UserDao(DaoConfig config, DaoSession daoSession) {
super(config, daoSession);
}
/** Creates the underlying database table. */
public static void createTable(Database db, boolean ifNotExists) {
String constraint = ifNotExists? "IF NOT EXISTS ": "";
db.execSQL("CREATE TABLE " + constraint + "\"USER\" (" + //
"\"_id\" INTEGER PRIMARY KEY AUTOINCREMENT ," + // 0: id
"\"NAME\" TEXT," + // 1: name
"\"GRADE\" INTEGER NOT NULL ," + // 2: grade
"\"AGE\" INTEGER);"); // 3: age
}
/** Drops the underlying database table. */
public static void dropTable(Database db, boolean ifExists) {
String sql = "DROP TABLE " + (ifExists ? "IF EXISTS " : "") + "\"USER\"";
db.execSQL(sql);
}
@Override
protected final void bindValues(DatabaseStatement stmt, User entity) {
stmt.clearBindings();
Long id = entity.getId();
if (id != null) {
stmt.bindLong(1, id);
}
String name = entity.getName();
if (name != null) {
stmt.bindString(2, name);
}
stmt.bindLong(3, entity.getGrade());
Integer age = entity.getAge();
if (age != null) {
stmt.bindLong(4, age);
}
}
@Override
protected final void bindValues(SQLiteStatement stmt, User entity) {
stmt.clearBindings();
Long id = entity.getId();
if (id != null) {
stmt.bindLong(1, id);
}
String name = entity.getName();
if (name != null) {
stmt.bindString(2, name);
}
stmt.bindLong(3, entity.getGrade());
Integer age = entity.getAge();
if (age != null) {
stmt.bindLong(4, age);
}
}
//省略部分代码
}
xxDao里面提供了创建数据表的createTable方法，提供了dropTable方法，使用bindValues进行绑定。
现在我们再来看看AbstractDao的代码：
public abstract class AbstractDao<T, K> {
//省略部分代码
public long insert(T entity) {
return executeInsert(entity, statements.getInsertStatement(), true);
}
private long executeInsert(T entity, DatabaseStatement stmt, boolean setKeyAndAttach) {
long rowId;
if (db.isDbLockedByCurrentThread()) {
rowId = insertInsideTx(entity, stmt);
} else {
// Do TX to acquire a connection before locking the stmt to avoid deadlocks
db.beginTransaction();
try {
rowId = insertInsideTx(entity, stmt);
db.setTransactionSuccessful();
} finally {
db.endTransaction();
}
}
if (setKeyAndAttach) {
updateKeyAfterInsertAndAttach(entity, rowId, true);
}
return rowId;
}
private long insertInsideTx(T entity, DatabaseStatement stmt) {
synchronized (stmt) {
if (isStandardSQLite) {
SQLiteStatement rawStmt = (SQLiteStatement) stmt.getRawStatement();
bindValues(rawStmt, entity);
return rawStmt.executeInsert();
} else {
bindValues(stmt, entity);
return stmt.executeInsert();
}
}
}
//省略部分代码
}
我们看到AbstractDao类中定义了很多操作数据表的方法，在这里我们截取了insert方法，我们看到外部调用的insert方法实际调用的是executeInsert，而这个方法中还会继续调用insertInsideTx方法，方法内通过isStandardSQLite变量去判断是调用sqlite中的executeInsert还是greenDao中的executeInsert。走到这里基本就操作数据表中简单的看了一遍。
GreenDao的对数据表的CRUD操作GreenDao详解一已经简单说明了，在这里就不一一重复了。
