GreenDao源碼簡要分析

1、AbstractDaoMaster抽象類的作用

AbstractDaoMaster 的主要作用為：

SQLiteDatabase相關操作： 所有Table 的創建、刪除、升級
AbstractDao的信息獲取和存儲： AbstractDao主要作用就是提供操作Table的各種接口
AbstractDaoSession的創建 ：創建AbstractDao，提供簡單的操作表的接口

1.1、SQLiteDatabase的相關操作

Table的創建，刪除，升級操作，是在AbstractDaoMaster子類DaoMaster里面實現的，代碼很簡單，不做過多解釋，相關代碼如下：

public static void createAllTables(SQLiteDatabase db, boolean ifNotExists) {
        NoteDao.createTable(db, ifNotExists);
    }

public static void dropAllTables(SQLiteDatabase db, boolean ifExists) {
        NoteDao.dropTable(db, ifExists);
    }

public static class DevOpenHelper extends OpenHelper {
        public DevOpenHelper(Context context, String name, CursorFactory factory) {
            super(context, name, factory);
        }

        @Override
        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
            Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion + " by dropping all tables");
            dropAllTables(db, true);
            onCreate(db);
        }
    }

1.2 AbstractDao的信息獲取和存儲

public DaoMaster(SQLiteDatabase db) {
        super(db, SCHEMA_VERSION);
        registerDaoClass(NoteDao.class);
    }

protected void registerDaoClass(Class<? extends AbstractDao<?, ?>> daoClass) {
        DaoConfig daoConfig = new DaoConfig(db, daoClass);
        daoConfigMap.put(daoClass, daoConfig);
    }

每個AbstractDao對應著一個DaoConfig，然后保存在Map< Class<? extends AbstractDao<?, ?>>, DaoConfig> daoConfigMap中，DaoConfig這個類的作用，一是通過反射的方式獲取到AbstractDao對應的表名、表中所有字段（主鍵、非主鍵greendao中用Property對象來保存一個字段的信息）等相關信息，然后利用這些信息創建了輔助類TableStatements的一個實例，TableStatements這個類的作用是創建操作table的SQL語句；二是獲取該表對應的緩存處理實例。DaoConfig 和TableStatements 的相關代碼都很簡單，這里不再貼出來了。

1.3 AbstractDaoSession：創建AbstractDao，提供簡單的操作表的接口

AbstractDaoSession的作用，一是提供獲取AbstractDao的接口，從而操作各個表：

DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "notes-db", null);
db = helper.getWritableDatabase();
daoMaster = new DaoMaster(db);
daoSession = daoMaster.newSession();
noteDao = daoSession.getNoteDao();

這里為啥子要通過AbstractDaoSession來創建AbstractDao然后提供給client端使用，而不是直接在AbstractDaoMaster創建出AbstractDao然后提供給client端使用呢？看AbstractDaoSession里面也提供了操作數據庫的簡單接口（當然最終都是通過對應的AbstractDao來完成的），難道就為了這個玩意？？？？？

2、table操作

理清了關鍵幾個類的作用后，下面分析table的相關操作就比較簡單了。

2.1 insert 操作

通過DaoConfig獲取到TableStatements，然后由TableStatements得到SQLiteStatement

public long insert(T entity) {// statements = config.statements;
        return executeInsert(entity, statements.getInsertStatement());
    }

public SQLiteStatement getInsertStatement() {
        if (insertStatement == null) {
            String sql = SqlUtils.createSqlInsert("INSERT INTO ", tablename, allColumns);
            insertStatement = db.compileStatement(sql);
        }
        return insertStatement;
    }

根據表名、字段生成一條SQL語句

public static String createSqlInsert(String insertInto, String tablename, String[] columns) {
        StringBuilder builder = new StringBuilder(insertInto);
        builder.append('"').append(tablename).append('"').append(" (");
        appendColumns(builder, columns);
        builder.append(") VALUES (");
        appendPlaceholders(builder, columns.length);
        builder.append(')');
        return builder.toString();
    }

執行insert操作

private long executeInsert(T entity, SQLiteStatement stmt) {
        long rowId;
        if (db.isDbLockedByCurrentThread()) {// database被當前線程給鎖住了
            synchronized (stmt) {
                bindValues(stmt, entity);
                rowId = stmt.executeInsert();
            }
        } else {
            // Do TX to acquire a connection before locking the stmt to avoid deadlocks
            db.beginTransaction();
            try {
                synchronized (stmt) {
                    bindValues(stmt, entity);
                    rowId = stmt.executeInsert();
                }
                db.setTransactionSuccessful();
            } finally {
                db.endTransaction();
            }
        }
        updateKeyAfterInsertAndAttach(entity, rowId, true);
        return rowId;
    }

給操作的bean更新字段_id的值

protected void updateKeyAfterInsertAndAttach(T entity, long rowId, boolean lock) {
        if (rowId != -1) {
            K key = updateKeyAfterInsert(entity, rowId);
            attachEntity(key, entity, lock);
        } else {
            // TODO When does this actually happen? Should we throw instead?
            DaoLog.w("Could not insert row (executeInsert returned -1)");
        }
    }

緩存操作：IdentityScope鍵值對，key為表中主鍵，value為bean

protected final void attachEntity(K key, T entity, boolean lock) {
        attachEntity(entity);
        if (identityScope != null && key != null) {
            if (lock) {
                identityScope.put(key, entity);
            } else {
                identityScope.putNoLock(key, entity);
            }
        }
    }

2.2 query操作

public T load(K key) {
        assertSinglePk();
        if (key == null) {
            return null;
        }
        if (identityScope != null) {// 如果有緩存，直接從緩存中取值
            T entity = identityScope.get(key);
            if (entity != null) {
                return entity;
            }
        }
        String sql = statements.getSelectByKey();
        String[] keyArray = new String[] { key.toString() };
        Cursor cursor = db.rawQuery(sql, keyArray);
        return loadUniqueAndCloseCursor(cursor);
    }