阅读 180

【迁移博客】GreenDao源码

GreenDao源码

简述

DaoMaster、具体的Dao 和 DaoSession对象为greedao生成的代码 从平时的使用可以看出他们的作用

  • DaoMaster GreenDao的总入口,负责整个库的运行,实现了SqliteOpenHelper
  • DaoSession 会话层,操作Dao的具体对象,包括DAO对象的注册
  • xxEntity 实体类,和表内容一一对应
  • xxDao 生成的DAO对象,进行具体的数据库操作

这几个类的关系如下UML图:

GreenDAO.png

Dao对象需要依赖DaoConfig对象

public DaoConfig(Database db, Class<? extends AbstractDao<?, ?>> daoClass) 
复制代码

DaoConfig对象需要传入具体的DaoClass类型

reflectProperties(Class<? extends AbstractDao<?, ?>> daoClass))
复制代码

获取DAO里面的Properties 所有static或者public字段

pkProperty = pkColumns.length == 1 ? lastPkProperty : null;
            statements = new TableStatements(db, tablename, allColumns, pkColumns);

            if (pkProperty != null) {
                Class<?> type = pkProperty.type;
                keyIsNumeric = type.equals(long.class) || type.equals(Long.class) || type.equals(int.class)
                        || type.equals(Integer.class) || type.equals(short.class) || type.equals(Short.class)
                        || type.equals(byte.class) || type.equals(Byte.class);
            } else {
                keyIsNumeric = false;
            }
复制代码

这里会获取所有的数据库字段,顺便判断表主键是否是数字类型

数据库加密

GreenDAO创建会话的时候我们一般会调用如下代码获取DaoSession对象:

DevOpenHelper helper = new DevOpenHelper(this, ENCRYPTED ? "notes-db-encrypted" : "notes-db");
Database db = ENCRYPTED ? helper.getEncryptedWritableDb("super-secret") : helper.getWritableDb();
daoSession = new DaoMaster(db).newSession();
复制代码

在AbstractDAO类中,有一个db字段,最终的数据库操作以及事务的开启都会通过这个对象开启。GreenDAO中存在Database和DatabaseStatement2个接口 这2个接口分别存在2个子类StandardDatabase、EncryptedDatabase 和 StandardDatabaseStatement 、EncryptedDatabaseStatement,这几个类其实都是一个代理模式

public class StandardDatabaseStatement implements DatabaseStatement {
    private final SQLiteStatement delegate;
    public StandardDatabaseStatement(SQLiteStatement delegate) {
        this.delegate = delegate;
    }

    @Override
    public void execute() {
        delegate.execute();
    }
}
复制代码
public class EncryptedDatabase implements Database {
    private final SQLiteDatabase delegate;
    public EncryptedDatabase(SQLiteDatabase delegate) {
        this.delegate = delegate;
    }

    @Override
    public Cursor rawQuery(String sql, String[] selectionArgs) {
        return delegate.rawQuery(sql, selectionArgs);
    }
}
复制代码

这里会发现GreenDAO调用了一个三方库叫做sqlcipher.,提供了Sqlite的数据库加密功能。所以GreenDAO在创建一次会话的时候可以指定数据库是否加密。如果没加密,会使用Android的Sqlite API去操作数据库,如果加密,则使用sqlcipher提供发API去操作数据库。

GreenDAO的增删改查

GreenDAO通过AbstractDAO类实现数据库的增删改查逻辑,此处分析几个常用的方法

  • insert 插入数据
public long insert(T entity) {
        return executeInsert(entity, statements.getInsertStatement(), true);
    }
复制代码

内部逻辑伪代码:

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);
        }
复制代码
  • update 更新数据
public void update(T entity) 
复制代码

update的源码大概为

assertSinglePk();  //判断是否只有一个主键
DatabaseStatement stmt = statements.getUpdateStatement();
if (db.isDbLockedByCurrentThread()) {
            synchronized (stmt) {
                if (isStandardSQLite) {
                    updateInsideSynchronized(entity, (SQLiteStatement) stmt.getRawStatement(), true);
                } else {
                    updateInsideSynchronized(entity, stmt, true);
                }
            }
        } else {
            // Do TX to acquire a connection before locking the stmt to avoid deadlocks
            db.beginTransaction();
            try {
                synchronized (stmt) {
                    updateInsideSynchronized(entity, stmt, true);
                }
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
        }
复制代码

关注updateInsideSynchronized方法

bindValues(stmt, entity);
        int index = config.allColumns.length + 1;
        K key = getKey(entity);
        if (key instanceof Long) {
            stmt.bindLong(index, (Long) key);
        } else if (key == null) {
            throw new DaoException("Cannot update entity without key - was it inserted before?");
        } else {
            stmt.bindString(index, key.toString());
        }
        stmt.execute();
        attachEntity(key, entity, lock);
复制代码

和insert方法类似,添加了主键判断必须存在key的逻辑 其中添加了

int index = config.allColumns.length + 1;
复制代码

这个index bind的字段是update的条件语句,和id进行绑定 换成sql语句就是

where id = '?'
复制代码
  • select 查询操作 查询的代码和insert、update大致流程一致 会通过QueryBuilder构造查询条件,在QueryBuilder中list方法获取数据
public List<T> list() {
	return build().list();
}
复制代码
public List<T> list() {
   checkThread();
   Cursor cursor = dao.getDatabase().rawQuery(sql, parameters);
   return daoAccess.loadAllAndCloseCursor(cursor);
}
复制代码

会走到AbstractDao类的loadAllFromCursor方法

if (cursor.moveToFirst()) {
            if (identityScope != null) {
                identityScope.lock();
                identityScope.reserveRoom(count);
            }

            try {
                if (!useFastCursor && window != null && identityScope != null) {
                    loadAllUnlockOnWindowBounds(cursor, window, list);
                } else {
                    do {
                        list.add(loadCurrent(cursor, 0, false));
                    } while (cursor.moveToNext());
                }
            } finally {
                if (identityScope != null) {
                    identityScope.unlock();
                }
            }
        }
复制代码

会走到loadCurrent方法

 final protected T loadCurrent(Cursor cursor, int offset, boolean lock) 
复制代码

此处可以关于IdentityScope的代码

T entity = lock ? identityScopeLong.get2(key) : identityScopeLong.get2NoLock(key);
            if (entity != null) {
                return entity;
            } else {
                entity = readEntity(cursor, offset);
                attachEntity(entity);
                if (lock) {
                    identityScopeLong.put2(key, entity);
                } else {
                    identityScopeLong.put2NoLock(key, entity);
                }
                return entity;
            }
复制代码
  • delete 删除的逻辑和增改查大致一样

GreenDAO缓存

在上面query的源码中可以发现GreenDAO对于数据做了一次内存的缓存,每次写数据库的时候会从IdentityScope的map 中put一次数据。每次读数据库的时候会从IdentityScope的map中get一次数据。如果map中缓存拿到了,就使用缓存作为查询的结果。

在查询和更新数据的时候会执行

attachEntity(K key, T entity, boolean lock)
复制代码

方法,具体逻辑如下

if (identityScope != null && key != null) {
            if (lock) {
                identityScope.put(key, entity);
            } else {
                identityScope.putNoLock(key, entity);
            }
        }
复制代码

关于数据库缓存的特性,我们需要视业务情况而定,在网上还是能搜到GreenDAO查询数据没有拿到最新结果的bug, 如果出现这个bug且需要拿到最新的数据库信息,可以使用DaoSession的clear方法删除缓存,源码如下

//DaoSession
public void clear() {
   noteDaoConfig.clearIdentityScope();
}
复制代码
//DaoConfig
public void clearIdentityScope() {
        IdentityScope<?, ?> identityScope = this.identityScope;
        if(identityScope != null) {
            identityScope.clear();
        }
    }
复制代码

GreenDAO的异步操作

有些时候,我们希望异步的操作数据库,GreenDAO给我们提供了异步的方法。 大致用法为:

AsyncSession asyncSession = daoSession.startAsyncSession();
asyncSession.setListener(new AsyncOperationListener() {
   @Override
   public void onAsyncOperationCompleted(AsyncOperation operation) {
       AsyncOperation.OperationType type = operation.getType();
       Log.e(TAG, type.name());
   }
});
asyncSession.insert(note);
复制代码

我们获取一个AsyncSession对象进行异步的数据库操作,并且可以设置AsyncOperation对异步操作进行监听。但是为什么所有的异步操作是同一个Listener回调呢?我们可以在源码中找到答案。

查看AsyncSession的insert方法

public AsyncOperation insert(Object entity) {
    return insert(entity, 0);
}
复制代码

最后可以走到enqueEntityOperation方法

AbstractDao<?, ?> dao = daoSession.getDao(entityClass);
AsyncOperation operation = new AsyncOperation(type, dao, null, param, flags | sessionFlags);
executor.enqueue(operation);
return operation;
复制代码

可以发现有一个异步操作的Executor,AsyncOperationExecutor 查看enqueue方法

operation.sequenceNumber = ++lastSequenceNumber;
queue.add(operation);
countOperationsEnqueued++;
if (!executorRunning) {
   executorRunning = true;
   executorService.execute(this);
}
复制代码

可以看到它把异步加入到一个队列里面排队等待。在线程池中执行这些操作。

查看run方法

//线程池run方法代码
while (true) {
   AsyncOperation operation = queue.poll(1, TimeUnit.SECONDS);
   if (operation == null) {
      synchronized (this) {
	      // Check again, this time in synchronized to be in sync with enqueue(AsyncOperation)
	      operation = queue.poll();
	      if (operation == null) {
	          // set flag while still inside synchronized
	          executorRunning = false;
	          return;
	       }
	    }
	}
    if (operation.isMergeTx()) {
        // Wait some ms for another operation to merge because a TX is expensive
        AsyncOperation operation2 = queue.poll(waitForMergeMillis, TimeUnit.MILLISECONDS);
        if (operation2 != null) {
             if (operation.isMergeableWith(operation2)) {
                  mergeTxAndExecute(operation, operation2);
              } else {
                   // Cannot merge, execute both
	             executeOperationAndPostCompleted(operation);
                 executeOperationAndPostCompleted(operation2);
              }
              continue;
         }
   }
   executeOperationAndPostCompleted(operation);
}
复制代码

这段代码我们可以看到,每次从队列中拿一个异步操作对象执行逻辑。这也解释了为什么外层只需要set一个Listener。GreenDAO的异步操作是所有的数据库操作在一个子线程中进行同步操作。

最终代码会走到executeOperation方法

switch (operation.type) {
    case Delete:
        operation.dao.delete(operation.parameter);
        break;
    default:
	    break;
}
复制代码

这里会执行具体的DAO对象的数据库操作方法。

和ReactiveX的结合

GreenDAO提供了API与rxjava结合使用,代码如下:

RxDao<xxEntity, Long> xxDao = daoSession.getXXDao().rx();
xxDao.insert(xxEntity)
	.observerOn(AndroidSchedules.mainThread())
	.subscribe(new Action1<xxEntity>() {
		@Override
		public void call(xxEntity entity) {
			// insert success
		}
	})
复制代码

我们来简单分析下源码看看RxJava是如何和GreenDAO结合的 查看AbstractDAO的rx()

public RxDao<T, K> rx() {
	if (rxDao == null) {
	    rxDao = new RxDao<>(this, Schedulers.io());
	}
    return rxDao;
}
复制代码

查看RxDAO的构造方法

public RxDao(AbstractDao<T, K> dao, Scheduler scheduler) {
	super(scheduler);
    this.dao = dao;
}
复制代码

包含了Dao对象和线程调度Scheduler对象,这里是io线程,即在异步线程执行 查看insert方法

public Observable<T> insert(final T entity) {
        return wrap(new Callable<T>() {
            @Override
            public T call() throws Exception {
                dao.insert(entity);
                return entity;
            }
        });
    }
复制代码

查看wrap方法, wrap方法里面也调用了一个重载的wrap方法。 参数为一个Callable对象,里面执行了数据库插入的逻辑,返回了实体类对象。

protected <R> Observable<R> wrap(Callable<R> callable) {
	return wrap(RxUtils.fromCallable(callable));
}
复制代码
if (scheduler != null) {
	return observable.subscribeOn(scheduler);
} else {
    return observable;
}
复制代码

这里的第二个wrap方法的参数observable是通过RxUtils.fromCallable获得的,查看这个方法的源码

static <T> Observable<T> fromCallable(final Callable<T> callable) {
	return Observable.defer(new Func0<Observable<T>>() {
		@Override
		public Observable<T> call() {
			T result;
			try {
				result = callable.call();
			} catch (Exception e) {
				return Observable.error(e);
			}
			return Observable.just(result);
		}
	});
}
复制代码

这里使用了defer操作符创建一个Observable对象。延迟创建,确保Observable被订阅后才执行。

以上就是rxjava和GreenDAO的结合使用的原理。和rx'java结合使用,会使GreenDAO尤其是异步操作写起来更加的优雅。

GreenDAO代码生成

我们在GreenDAO使用的时候,会自动生成DaoMaster,DAO对象等等java文件。大致翻阅了DaoGenerator这个Module里面的代码。发现有模板引擎的库依赖:

compile 'org.freemarker:freemarker:2.3.23'
复制代码

并且发现了freemarker的模板文件 在DaoGenerator/src-template里面,有很多的.ftl文件。GreenDAO的文件就是通过freemarker模板生成的Java文件。具体的原理下次分析后会单独再写一篇博客。

总结

通过对GreenDAO的源码分析,可以发现GreenDAO号称自己是性能最好的ORM库也是有原因的,GreenDAO的特点总结为以下:

  • 使用了静态代码生成,不通过反射运行时生成代理类,提升了性能
  • 使用了SQLiteStatement
  • 同时提供了同步和异步的数据库操作方式
  • 数据库提供内存缓存,更高效的查询
  • 基于sqlcipher提供加密数据库
  • 提供RxJava的API,异步操作更高效
关注下面的标签,发现更多相似文章
评论