由於在進行資料庫的增刪改查時，是需要一部分執行時間的，而我們需要的是在資料庫更新操作完成之後操作UI，如果資料庫未讀寫完畢，我們就進行了UI資料操作，則達不到我們的業務需求，也會產生一定的BUG，所以採用 Rxjava輔助GreenDao資料庫。

常用API

      rx.Observable<T>                 unique()：唯一查詢，返回含有該實體的Observable
      rx.Observable<java.util.List<T>>     list()：獲取實體集合，，返回含有該實體集合的Observable

基本使用

public class StudentDaoOpeRx {
    /**
     * @desc 新增資料至資料庫
     **/
    public static Observable<Student> insertData(Context context, Student stu) {
 
        return DbManager.getDaoSession(context).getStudentDao().rx().insert(stu);
    }
 
    /**
     * @desc 將資料實體通過事務新增至資料庫
     **/
    public static Observable<Iterable<Student>> insertData(Context context, List<Student> list) {
        if (null == list || list.size() <= 0) {
            return Observable.error(new Throwable("null"));
        }
        return DbManager.getDaoSession(context).getStudentDao().rx().insertInTx(list);
    }
 
    /**
     * @desc 新增資料至資料庫，如果存在，將原來的資料覆蓋
     **/
    public static Observable<Student> saveData(Context context, Student student) {
        return DbManager.getDaoSession(context).getStudentDao().rx().save(student);
    }
 
 
    /**
     * @desc 查詢所有資料
     **/
    public static Observable<List<Student>> queryAll(Context context) {
        RxQuery<Student> rxQuery = DbManager.getDaoSession(context).getStudentDao().queryBuilder().rx();
 
        return rxQuery.list();
    }
 
    /**
     * @desc 刪除資料
     **/
    public static Observable<Void> deleteData(Context context, Student student) {
        return DbManager.getDaoSession(context).getStudentDao().rx().delete(student);
    }
 
    /**
     * @desc 刪除全部資料
     **/
    public static Observable<Void> deleteAll(Context context) {
        return DbManager.getDaoSession(context).getStudentDao().rx().deleteAll();
    }
 
    /**
     * @desc 更新資料
     **/
    public static Observable<Student> updateData(Context context, Student student) {
        return DbManager.getDaoSession(context).getStudentDao().rx().update(student);
    }
}

 

不熟悉RxJava，可以看下RxJava操作符的基本使用，RxJava操作符相關介紹

資料庫操作類完成之後在activity中的呼叫：

//拿到observer，在activity中訂閱 .subscribe   插入
Observable<Student> observer=StudentDaoOpeRx.insertData(mContext,stu);
observer.observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<Student>() {
                            @Override
                            public void call(Student student) {
                                  //進行UI更新操作
                            }
                        });
//拿到observer，在activity中訂閱 .subscribe   查詢
Observable<List<Student>> observer=StudentDaoOpeRx.queryAll(mContext);
observer.observeOn(AndroidSchedulers.mainThread())//在主執行緒中呼叫
                .subscribe(new Action1<Student>() {
                    @Override
                    public void call(Student student) {
                       //進行UI更新操作
                    }
                });
 //拿到observer，在activity中訂閱 .subscribe   更新
Observable<Student> observer=StudentDaoOpeRx.updateData(mContext,stu);
observer.observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<Student>() {
                            @Override
                            public void call(Student student) {
                                  //進行UI更新操作
                            }
                        });
 //拿到observer，在activity中訂閱 .subscribe   刪除
Observable<Student> observer=StudentDaoOpeRx.deleteData(mContext,stu);
observer .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Action1<Void>() {
                            @Override
                            public void call(Void aVoid) {
                              //進行UI更新操作
                            }
                        });
 

最後在avtivity中別忘了呼叫

obserable.unsubscribeOn(AndroidSchedulers.mainThread());

避免出現記憶體洩漏

RxDao 常用api

    rx.Observable<java.lang.Long>     count()：返回一個含有資料庫資料個數的Observable
 
    rx.Observable<java.lang.Void>     delete(T entity)：從資料庫中刪除資料，並返回一個空的Observable
    rx.Observable<java.lang.Void>     deleteAll()：從資料庫中刪除資料，並返回一個空的Observable
    rx.Observable<java.lang.Void>     deleteByKey(K key)：將資料庫中主鍵為key的資料刪除，，並返回一個空的Observable
    rx.Observable<java.lang.Void>     deleteByKeyInTx(java.lang.Iterable<K> keys)：使用事務操作，將資料庫中，刪除key集合中每個key所對應的實體，並返回一個空的Observable
    rx.Observable<java.lang.Void>     deleteByKeyInTx(K... keys)：使用事務操作，將資料庫中，刪除key[ ]中每個key所對應的實體，並返回一個空的Observable
    rx.Observable<java.lang.Void>     deleteInTx(java.lang.Iterable<T> entities)：使用事務操作，將資料庫中，刪除實體集合中每個實體所對應的實體，並返回一個空的Observable
    rx.Observable<java.lang.Void>     deleteInTx(T... entities)：使用事務操作，將資料庫中，刪除實體集合中每個實體[ ]所對應的實體，並返回一個空的Observable
 
    rx.Scheduler     getScheduler()：返回當前排程器
    rx.Observable<T>                         insert(T entity)：將實體插入資料庫，並返回包含此實體的Observable
    rx.Observable<java.lang.Iterable<T>>     insertInTx(java.lang.Iterable<T> entities)：使用事務操作將實體插集合入資料庫，並返回包含此實體集合的Observable
    rx.Observable<java.lang.Object[]>        insertInTx(T... entities)：使用事務操作將實體[ ]插入資料庫，並返回包含此實體陣列的Observable
    rx.Observable<T>                         insertOrReplace(T entity)：將實體插入資料庫，若此實體的Key已存在，將原來的資料覆蓋，並返回包含此實體的Observable
    rx.Observable<java.lang.Iterable<T>>     insertOrReplaceInTx(java.lang.Iterable<T> entities)：將實體集合插入資料庫，若某個實體的Key已存在，將原來的資料覆蓋，
                                                                                                  並返回包含此實體集合的Observable
    rx.Observable<java.lang.Object[]>        insertOrReplaceInTx(T... entities)：將實體[ ]插入資料庫，若某個實體的Key已存在，將原來的資料覆蓋，
                                                                                 並返回包含此實體[ ]的Observable
                                                                                                                    
    rx.Observable<T>                             load(K key)：將主鍵為Key的實體載入至記憶體，並返回包含此實體的Observable
    rx.Observable<java.util.List<T>>     loadAll()：將所有實體載入至記憶體，並返回包含此實體集合的Observable
    rx.Observable<T>     refresh(T entity)：更新實體，並返回包含此實體的Observable
    rx.Observable<T>                         save(T entity)：：將實體插入資料庫，若此實體的Key已存在，將原來的資料覆蓋，並返回包含此實體的Observable
    rx.Observable<java.lang.Iterable<T>>     saveInTx(java.lang.Iterable<T> entities)：將實體集合插入資料庫，若某個實體的Key已存在，將原來的資料覆蓋，
                                                                                       並返回包含此實體集合的Observable
    rx.Observable<java.lang.Object[]>        saveInTx(T... entities)：將實體[ ]插入資料庫，若某個實體的Key已存在，將原來的資料覆蓋，
                                                                                                                    並返回包含此實體[ ]的Observable
                                                                                                                    
    rx.Observable<T>                         update(T entity)：將實體更新，並返回包含此實體的Observable
    rx.Observable<java.lang.Iterable<T>>     updateInTx(java.lang.Iterable<T> entities)：使用事務操作將實體集合更新，並返回包含此實體集合的Observable
    rx.Observable<java.lang.Object[]>        updateInTx(T... entities)：使用事務操作將實體[ ]更新，並返回包含此實體陣列的Observable</span>

普通操作與Rx響應式操作

package com.xxxxx.greendao;

import android.content.Context;
import android.util.Log;

import org.greenrobot.greendao.rx.RxQuery;

import java.util.List;

import rx.Observable;

public class UserHandDao {

    private final GreenDaoManager daoManager;
    private static UserHandDao mUserDao;

    public UserHandDao() {
        daoManager = GreenDaoManager.getInstance();
    }

    public static UserHandDao getInstance() {
        if (mUserDao == null) {
            mUserDao = new UserHandDao();
        }
        return mUserDao;
    }

    /**
     * 插入資料 若未建表則先建表
     *
     * @param userInfo
     * @return
     */
    public boolean insertUserData(UserInfo userInfo) {
        boolean flag = false;
        flag = getUserInfoDao().insert(userInfo) == -1 ? false : true;
        return flag;
    }

    /**
     * 新增資料至資料庫，如果存在，將原來的資料覆蓋
     * @param userInfo
     */
    public  Observable<UserInfo> saveDataRx(UserInfo userInfo) {
        return getUserInfoDao().rx().save(userInfo);
    }

    /**
     * 觀察者模式 插入資料
     * @param userInfo
     * @return
     */
    public  Observable<UserInfo> insertUserDataRx(UserInfo userInfo) {
        return getUserInfoDao().rx().insert(userInfo);
    }

    /**
     * 插入或替換資料
     *
     * @param userInfo
     * @return
     */
    public boolean insertOrReplaceData(UserInfo userInfo) {
        boolean flag = false;
        try {
            flag = getUserInfoDao().insertOrReplace(userInfo) == -1 ? false : true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 觀察者模式 插入或替換資料
     * @param userInfo
     */
    public  Observable<UserInfo> insertOrReplaceDataRx(UserInfo userInfo) {
        return getUserInfoDao().rx().insertOrReplace(userInfo);
    }
    /**
     * 插入多條資料  子執行緒完成
     *
     * @param list
     * @return
     */
    public boolean insertOrReplaceMultiData(final List<UserInfo> list) {
        boolean flag = false;
        try {
            getUserInfoDao().getSession().runInTx(new Runnable() {
                @Override
                public void run() {
                    for (UserInfo userInfo : list) {
                        daoManager.getDaoSession().insertOrReplace(userInfo);
                    }
                }
            });
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }


    /**
     * 插入多條資料  觀察者模式
     *
     * @param list
     * @return
     */
    public  Observable<Iterable<UserInfo>> insertOrReplaceMultiDataRx( List<UserInfo> list) {
        if (null == list || list.size() <= 0) {
            return Observable.error(new Throwable("null"));
        }        return getUserInfoDao().rx().insertInTx(list);
    }

    /**
     * 更新資料
     * @param userInfo
     * @return
     */
    public boolean updateUserData(UserInfo userInfo) {
        boolean flag = false;
        try {
            getUserInfoDao().update(userInfo);
            getUserInfoDao().updateInTx();
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 觀察者模式 更新資料
     *
     * @param userInfo
     */
    public  Observable<UserInfo> updateUserDataRx(UserInfo userInfo) {
        return  getUserInfoDao().rx().update(userInfo);
    }

    /**
     * 觀察者模式update 通過uid更新使用者興趣
     *
     * @param uidString,
     * @param interests
     * @return
     */
    public Observable<UserInfo> updateUserInterest(String uidString,String interests) {
        boolean flag = false;
        UserInfo userInfo=getUserInfoDao().queryBuilder().where(UserInfoDao.Properties.Uid.eq(uidString)).list().get(0);
        userInfo.setUserInfoInterests(interests);
        if(userInfo!=null){
            Log.d("MyInfo","queryUserInfo!!!!======null");
        }else{
            Log.d("MyInfo","queryUserInfo======null");
        }
        return getUserInfoDao().rx().update(userInfo);
    }


    /**
     * 刪除資料
     * @param userInfo
     * @return
     */
    public boolean deleteUserData(UserInfo userInfo) {
        boolean flag = false;
        try {
            getUserInfoDao().delete(userInfo);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
    /**
     * 觀察者模式 刪除資料
     * @param userInfo
     */
    public  Observable<Void> deleteUserDataRx(UserInfo userInfo) {
        return getUserInfoDao().rx().delete(userInfo);
    }
    /**
     * 刪除所有資料
     * @return
     */
    public boolean deleteAllData() {
        boolean flag = false;
        try {
            getUserInfoDao().deleteAll();
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }
    /**
     * 觀察者 刪除所有資料
     */
    public  Observable<Void> deleteAllDataRx() {
        return  getUserInfoDao().rx().deleteAll();
    }
    /**
     * 普通 查詢所有資料
     */
    public List<UserInfo> queryAllData() {
        return getUserInfoDao().loadAll();
    }
    /**
     * 觀察者 查詢所有資料
     */
    public Observable<List<UserInfo>> queryAllDataRx() {
        return getUserInfoDao().queryBuilder().rx().list();
    }
 //   查詢  最後在OnDestory中進行 obserable.unsubscribeOn(AndroidSchedulers.mainThread());
//    observable.observeOn(AndroidSchedulers.mainThread())
//            .subscribe(new Action1<Student>() {
//        @Override
//        public void call(Student student) {
//            mAddDailog.cancel();
//            onRefresh();
//        }
//    });

    /**
     * 根據引數查詢
     * @param where
     * @param param
     * @return
     */
    public List<UserInfo> queryUserByParams(String where, String... param) {
        return getUserInfoDao().queryRaw(where, param);
    }

    /**
     * 根據id查詢
     * @param uid
     * @return
     */
    public UserInfo queryUserByUid(String uid) {
        return getUserInfoDao().queryBuilder().where(UserInfoDao.Properties.Uid.eq(uid)).list().get(0);
    }

    public UserInfoDao getUserInfoDao() {
        return daoManager.getDaoSession().getUserInfoDao();
    }
}