Android框架学习之GreenDao（一）

Giuthub:https://github.com/greenrobot/greenDAO
greenDao官网：http://greenrobot.org/greendao/
greenDao2的引入地址（Github上面已经更新到greenDao3）

一，添加依赖

1. 在as中导入相关的包

compile'org.greenrobot:greendao:3.0.1'
compile'org.greenrobot:greendao-generator:3.0.0'

2.在build.gradle中进行配置：

apply plugin: 'org.greenrobot.greendao'
buildscript { 
    repositories { 
        mavenCentral()    
}    
dependencies {
    classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'    
    }
}

3.自定义路径

greendao {
    schemaVersion 1
    daoPackage 'com.anye.greendao.gen'
    targetGenDir 'src/main/java'
}

schemaVersion–> 指定数据库schema版本号，迁移等操作会用到;
daoPackage –> dao的包名，包名默认是entity所在的包；
targetGenDir –> 生成数据库文件的目录;
在创建实体类后make工程，相关的master类和session类和dao类都会生成在这个文件下

二，greendao中的注解

(一) @Entity 定义实体
@nameInDb 在数据库中的名字，如不写则为实体中类名
@indexes 索引
@createInDb 是否创建表，默认为true,false时不创建
@schema 指定架构名称为实体
@active 无论是更新生成都刷新
(二) @Id
(三) @NotNull 不为null
(四) @Unique 唯一约束
(五) @ToMany 一对多
(六) @OrderBy 排序
(七) @ToOne 一对一
(八) @Transient 不存储在数据库中
(九) @generated 由greendao产生的构造函数或方法

本文将从 数据库基础接口抽离，greenDao知识，greenDao的个性化基类封装和一个简单示例 为序向各位读者说明一下作者的思路以及实践。

数据库操作基础接口

数据库操作无非就是 增、删、改、查、事务，好接下来就可以细化了

• 插入 INSERT
  
• 删除 DELETE
  
• 改 UPDATE
  
• 查询 SELECT
  
• 事务 Transaction
  事务 runInTx(Runnable runnable)

三，使用

public interface IDataBase{

    boolean insert(T t);

    boolean delete(T t);

    boolean deleteByKey(K k);

    boolean deleteList(List mList);

    boolean deleteByKeyInTx(K... keys);
    //采用事务操作，删除key[ ]中每个key所对应的实体，并返回一个空的Observable

    boolean deleteAll();

    boolean insertOrReplace(@NonNull T t);

    boolean update(T t);

    boolean updateInTx(T... t);

    boolean updateList(List mList);

    T selectByPrimaryKey(K key);

    List loadAll();

    boolean refresh(T t);

    /**
     * 清理缓存
     */
    void clearDaoSession();

    /**
     * Delete all tables and content from our database
     */
    boolean dropDatabase();

    /**
     * 事务
     */
    void runInTx(Runnable runnable);

    /**
     * 添加集合
     *
     * @param mList
     */
    boolean insertList(List mList);

    /**
     * 添加或更新集合
     *
     * @param mList
     */
    boolean insertOrReplaceList(List mList);

    /**
     * 自定义查询
     *
     * @return
     */
    QueryBuilder getQueryBuilder();

    /**
     * @param where
     * @param selectionArg
     * @return
     */
    List queryRaw(String where, String... selectionArg);
}

public abstract class AbstractDatabaseManager implements IDataBase {

    private static final String DEFAULT_DATABASE_NAME = Constants.DEFAULT_DB_NAME;

    /**
     * The Android Activity reference for access to DatabaseManager.
     */
    private static DaoMaster.DevOpenHelper mHelper;
    protected static DaoSession daoSession;

    /**
     * 初始化OpenHelper
     * @param context
     */
    public static void initOpenHelper(@NonNull Context context) {
        mHelper = getOpenHelper(context, DEFAULT_DATABASE_NAME);
        openWritableDb();
    }

    /**
     * 初始化OpenHelper     *
     * @param context
     * @param dataBaseName
     */
    public static void initOpenHelper(@NonNull Context context, @NonNull String dataBaseName) {
        mHelper = getOpenHelper(context, dataBaseName);
        openWritableDb();
    }

    public static DaoSession getDaoSession() {
        return daoSession;
    }

    /**     * Query for readable DB     */
    protected static void openReadableDb() throws SQLiteException {
        daoSession = new DaoMaster(getReadableDatabase()).newSession();
    }

    /**     * Query for writable DB     */
    protected static void openWritableDb() throws SQLiteException {
        daoSession = new DaoMaster(getWritableDatabase()).newSession();
    }

    private static SQLiteDatabase getWritableDatabase() {
        return mHelper.getWritableDatabase();
    }

    private static SQLiteDatabase getReadableDatabase() {
        return mHelper.getReadableDatabase();
    }


    /**     * 在applicaiton中初始化DatabaseHelper     */
    private static DaoMaster.DevOpenHelper getOpenHelper(@NonNull Context context, @Nullable String dataBaseName) {
        closeDbConnections();//关闭数据库
        return new DaoMaster.DevOpenHelper(context, dataBaseName, null);//初始化数据库
    }

    /**
     * 只关闭helper就好,看源码就知道helper关闭的时候会关闭数据库
     */
    public static void closeDbConnections() {
        if (mHelper != null) {
            mHelper.close();
            mHelper = null;
        }
        if (daoSession != null) {
            daoSession.clear();
            daoSession = null;
        }
    }

    @Override
    public boolean insert(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().insert(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean delete(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().delete(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteByKey(K k) {
        try {
            if (TextUtils.isEmpty(k.toString()))
                return false;
            openWritableDb();
            getAbstractDao().deleteByKey(k);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteList(List mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().deleteInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteByKeyInTx(K... keys) {
        try {
            openWritableDb();
            getAbstractDao().deleteByKeyInTx(keys);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean deleteAll() {
        try {
            openWritableDb();
            getAbstractDao().deleteAll();
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertOrReplace(@NonNull T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().insertOrReplace(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean update(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().update(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean updateInTx(T... t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().updateInTx(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean updateList(List mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().updateInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public T selectByPrimaryKey(K key) {
        try {
            openReadableDb();
            return getAbstractDao().load(key);
        } catch (SQLiteException e) {
            return null;
        }
    }

    @Override
    public List loadAll() {
        openReadableDb();
        return getAbstractDao().loadAll();
    }

    @Override
    public boolean refresh(T t) {
        try {
            if (t == null)
                return false;
            openWritableDb();
            getAbstractDao().refresh(t);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public void clearDaoSession() {
        if (daoSession != null) {
            daoSession.clear();
            daoSession = null;
        }
    }

    @Override
    public boolean dropDatabase() {
        try {
            openWritableDb();
            // DaoMaster.dropAllTables(database, true); // drops all tables
            // mHelper.onCreate(database); // creates the tables
//          daoSession.deleteAll(BankCardBean.class); // clear all elements
            // from
            // a table
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    @Override
    public void runInTx(Runnable runnable) {
        try {
            openWritableDb();
            daoSession.runInTx(runnable);
        } catch (SQLiteException e) {
        }
    }

    @Override
    public boolean insertList(List mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().insertInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public boolean insertOrReplaceList(List mList) {
        try {
            if (mList == null || mList.size() == 0)
                return false;
            openWritableDb();
            getAbstractDao().insertOrReplaceInTx(mList);
        } catch (SQLiteException e) {
            return false;
        }
        return true;
    }

    @Override
    public QueryBuilder getQueryBuilder() {
        openReadableDb();
        return getAbstractDao().queryBuilder();
    }

    @Override
    public List queryRaw(String where, String... selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRaw(where, selectionArg);
    }

    public Query queryRawCreate(String where, Object... selectionArg) {
        openReadableDb();
        return getAbstractDao().queryRawCreate(where, selectionArg);
    }

    public Query queryRawCreateListArgs(String where, Collection