greendao 3.0集成和使用封装

现在项目中要用到数据库，最终选择使用了greendao ，至于原因，肯定是性能原因了。本文将着重介绍数据库的异步操作，因为网上很多都是配置集成+简单的使用，并且都还是同步的（重要的是 都是一样的文章！！！）。我想说，如果是百万级的数据就GG了。
一般来说，我们需要数据时，先访问数据库看是否有数据，如果有，就从数据库取，如果没有，就访问网络，成功后，将开启线程将数据插入数据库中，同事更新UI 如下图所示：

1：集成配置

apply plugin: 'org.greenrobot.greendao'

greendao {
    schemaVersion 1
    daoPackage 'com.app.test.textgreendao.db' //这个填写你自己创建的路径
    targetGenDir 'src/main/java'
}
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'
    }
}

dependencies {
    compile'org.greenrobot:greendao:3.0.1'
    compile'org.greenrobot:greendao-generator:3.0.0'
}

2：接下来就是创建实体类了：

/**
 * Created by ${liumengqiang} on 2017/7/10.
 */
@Entity
public class User {
   
    @Id
    private long memberId;
    @Property
    private String name;
    @Property
    private String age;


}

然后点击 Build —— make build 就是那个绿色小锤子按钮，就会自动帮你生成相应的方法；
至于@Id，@Property 这一类的标记 大家可以上网搜一下 这个不再赘述。

3：然后就是自己封装GreenDao了，首先网上很多都是同步数据 在这里 我用的是异步处理的也就是使用的是AsyncSession类，这个是GreenDao内部封装好的 再次我们可以在封装一下，专门用于异步操作数据库的成功和失败；
首先 我定义了返回操作数据库结果的回调接口

package com.app.test.textgreendao.user;

import java.util.List;

/**
 * Created by ${liumengqiang} on 2017/7/12.
 */

public interface UserInterface {
   

    /**
     * type true 成功。 false 失败
     * @param <T>
     */

    interface OnIsertInterface<T>{
  //单个插入成功
        void onIsertInterface(boolean type);
    }

    interface OnQuerySingleInterface<T>{
  //单个查询成功
        void onQuerySingleInterface(T entry);
    }

    interface OnDeleteInterface<T>{
  //单个删除成功
        void onDeleteInterface(boolean type);
    }

    interface OnUpdateInterface<T>{
  //单个修改成功
        void onUpdateInterface(boolean type);
    }

    interface OnQueryAllInterface<T>{
  //批量查询数据回调
        void onQueryAllBatchInterface(List<T> list);
    }

}

然后 我们声明这些接口：

package com.app.test.textgreendao.db;

import com.app.test.textgreendao.user.UserInterface;

/**
 * Created by ${liumengqiang} on 2017/7/12.
 */

public class DaoInterface<T>  {

    protected UserInterface.OnQueryAllInterface<T> onQueryAllInterface;
    protected UserInterface.OnUpdateInterface<T> onUpdateInterface;
    protected UserInterface.OnIsertInterface<T> onIsertInterface;
    protected UserInterface.OnQuerySingleInterface<T> onQuerySingleInterface;
    protected UserInterface.OnDeleteInterface<T> onDeleteInterface;

    public UserInterface.OnQueryAllInterface<T> getOnQueryAllInterface() {
        return onQueryAllInterface;
    }

    public void setOnQueryAllInterface(UserInterface.OnQueryAllInterface<T> onQueryAllInterface) {
        this.onQueryAllInterface = onQueryAllInterface;
    }

    public UserInterface.OnUpdateInterface<T> getOnUpdateInterface() {
        return onUpdateInterface;
    }

    public void setOnUpdateInterface(UserInterface.OnUpdateInterface<T> onUpdateInterface) {
        this.onUpdateInterface = onUpdateInterface;
    }

    public UserInterface.OnIsertInterface<T> getOnIsertInterface() {
        return