greenDAO数据库之封装

传送门-->索引
一、简单介绍一下greenDAO是如何使用

上图是上一篇文章中我们配置好greenDAO，编写好实体类，Make Project后生成的dao文件夹。简单分析一下这些自动生成的文件的作用：

首先明确一点，每个有@Entity注解的实体类，就相当于greenDao数据库中的一张表格。比如我写了一个User实体类并且make project，当我创建greenDAO数据库的时候，数据库里面自动会创建USER这个表，用来存储user的信息。
UserDao : 这个文件是User的Dao文件，它继承了AbstractDao这个类，可以实现对数据库中USER表的操作（增删改查）
DaoMaster：实现数据库的创建或者打开
DaoSession：可以获取BeanDao的实例

二、封装一个DaoManager

DaoManager的作用：
1、管理数据库（打开或关闭、升级、存储位置）
2、获取daoSession

/**
 * Creator: Jowney  (~._.~)
 * Date: 2018/5/13/20:18
 * Description:
 */

public class DaoManager {
    private static final String DB_NAME = "jDatabase.db";//数据库名称
    private static DaoManager mDaoManager;
    private DaoMaster.DevOpenHelper mHelper;
    private DaoMaster mDaoMaster;
    private DaoSession mDaoSession;
    private Context context;
    public DaoManager(Context context) {
        this.context = context;
    }

    /**
     * 使用单例模式获得操作数据库的对象
     *
     * @return
     */
    public static DaoManager getInstance(Context context) {
        if (mDaoManager == null) {
            synchronized (DaoManager.class) {
                if (mDaoManager == null) {
                    mDaoManager = new DaoManager(context);
                }
            }
        }
        return mDaoManager;
    }

    /**
     * 获取DaoSession
     *
     * @return
     */
    public synchronized DaoSession getDaoSession() {
        if (null == mDaoSession) {
            mDaoSession = getDaoMaster().newSession();
        }
        return mDaoSession;
    }

    /**
     * 设置debug模式开启或关闭，默认关闭
     *
     * @param flag
     */
    public  void setDebug(boolean flag) {
        QueryBuilder.LOG_SQL = flag;
        QueryBuilder.LOG_VALUES = flag;
    }



    /**
     * 关闭数据库
     */
    public synchronized void closeDataBase() {
        closeHelper();
        closeDaoSession();
    }

    /**
     * 判断数据库是否存在，如果不存在则创建
     *
     * @return
     */
    private DaoMaster getDaoMaster() {
        if (null == mDaoMaster) {
             mHelper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
             mDaoMaster = new DaoMaster(mHelper.getWritableDb());
        }
        return mDaoMaster;
    }

    private void closeDaoSession() {
        if (null != mDaoSession) {
            mDaoSession.clear();
            mDaoSession = null;
        }
    }

    private void closeHelper() {
        if (mHelper != null) {
            mHelper.close();
            mHelper = null;
        }
    }
}

三、BaseBeanManager
BaseBeanManager就相当AbstractDao，只是把里面常用的方法给提取出来，用起来方便。


/**
 * Creator: Jowney  (~._.~)
 * Date: 2018/5/13/23:01
 * Description:
 */

public class BaseBeanManager<T, K> {
    private AbstractDao<T, K> mDao;


    public BaseBeanManager(AbstractDao dao) {
        mDao = dao;
    }


    public  void save(T item) {
        mDao.insert(item);
    }

    public void save(T... items) {
        mDao.insertInTx(items);
    }

    public void save(List<T> items) {
        mDao.insertInTx(items);
    }

    public void saveOrUpdate(T item) {
        mDao.insertOrReplace(item);
    }

    public void saveOrUpdate(T... items) {
        mDao.insertOrReplaceInTx(items);
    }

    public void saveOrUpdate(List<T> items) {
        mDao.insertOrReplaceInTx(items);
    }

    public void deleteByKey(K key) {
        mDao.deleteByKey(key);
    }

    public void delete(T item) {
        mDao.delete(item);
    }

    public void delete(T... items) {
        mDao.deleteInTx(items);
    }

    public void delete(List<T> items) {
        mDao.deleteInTx(items);
    }

    public void deleteAll() {
        mDao.deleteAll();
    }


    public void update(T item) {
        mDao.update(item);
    }

    public void update(T... items) {
        mDao.updateInTx(items);
    }

    public void update(List<T> items) {
        mDao.updateInTx(items);
    }

    public T query(K key) {
        return mDao.load(key);
    }

    public  List<T> queryAll() {
        return mDao.loadAll();
    }

    public List<T> query(String where, String... params) {

        return mDao.queryRaw(where, params);
    }

    public QueryBuilder<T> queryBuilder() {

        return mDao.queryBuilder();
    }

    public long count() {
        return mDao.count();
    }

    public void refresh(T item) {
        mDao.refresh(item);

    }

    public void detach(T item) {
        mDao.detach(item);
    }
}

四、BeanManager 数据库中表的管理者
每创建一个Bean类就需要创建一个BeanManager，用于管理数据库中的表


/**
 * Creator: Jowney  (~._.~)
 * Date: 2018/5/13/21:27
 * Description:
 */

public class StudentManager extends BaseBeanManager<Student, Long> {
    public StudentManager(AbstractDao dao) {
        super(dao);
    }
}

五、ManagerFactory 创建一个工厂将所有表的管理者放在一起方便管理

/**
 * Created by Jowney on 2018/5/14.
 */

public class ManagerFactory {
    /**
     * 每一个BeanManager都管理着数据库中的一个表，我将这些管理者在ManagerFactory中进行统一管理
     */
    StudentManager studentManager;

    TeacherManager teacherManager;

    private static ManagerFactory mInstance = null;

        /**
         * 获取DaoFactory的实例
         *
         * @return
         */
        public static ManagerFactory getInstance() {
            if (mInstance == null) {
                synchronized (ManagerFactory.class) {
                    if (mInstance == null) {
                        mInstance = new ManagerFactory();
                    }
                }
            }
            return mInstance;
        }

    public synchronized StudentManager getStudentManager() {
            if (studentManager == null){
              studentManager = new StudentManager(DaoManager.getInstance(MyApp.getContext()).getDaoSession().getStudentDao());
            }
        return studentManager;
    }

    public synchronized TeacherManager getTeacherManager(){
            if (teacherManager == null){
                teacherManager = new TeacherManager(DaoManager.getInstance(MyApp.getContext()).getDaoSession().getTeacherDao());
            }
            return teacherManager;
    }
}