项目如何引入GreenDao3.2的记录

• 在项目的根build.gradle脚本文件中加入 mavenCentral()仓库  和 编译插件

• classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'

• 

2. 在app 模块的build.gradle中加入以下内容

apply plugin: 'org.greenrobot.greendao'

greendao {
    schemaVersion 1
    daoPackage 'kap.com.smarthome.android.data.dao'//这个是生成代码保存的包名  （根据自己的实际情况而定）
    targetGenDir 'src/main/java/'//保存到java代码路径
}

compile 'org.greenrobot:greendao:3.2.0'
compile 'org.greenrobot:greendao-generator:3.2.0'




3. 新建一个Bean 类  格式如下 

@Entity
public class MyTestBean {
    @Id(autoincrement = true)
    private Long id;

    private String name;
    private String sex;
    private int age;
    private int salary;}

只需要定义这个实体类的字段 ， 其中注解 @Entity 代表的这是一个实体类，数据库的插件会在构建项目的时候生成出来数据库的一个结构 

会生成DaoMaster 和 DaoSession

DaoMaster ： 

     
     
是GreenDao的入口也是greenDao顶级对象,对于一个指定的表单持有数据库对象（SQLite数据库）并且能够管理DAO类
能够创建表和删除表
其内部类OpenHelper 与DevOpenHelper是创建SQlite数据库的SQLiteOpenHelper的具体实现
DaoSession ：



    
    


     
     


      
      
对于一个指定的表单可以管理所有的 Dao 对象。
也能够对实体类执行 insert ,load，update,refresh.delete操作。
DaoSession也能跟踪 identity scope：即session查询后的实体会存在缓存中，并给该实体生成一个flag来追踪该实体，
下次再次查询时会直接从缓存中取出来而不是从数据库中取出来

    
    

4. 创建一个单例类初始化数据库，再在Application中调用初始化类得到实例
数据库的管理类
public class DBManageUtils {

    private  static   DBManageUtils  mDBManage = null;
    private  DaoSession mDaoSession;


    /**
     * 采用单例模式，放到Application中进行初始，保证全局唯一性
     * @param context
     */
    private DBManageUtils(Context context){
        DaoMaster.DevOpenHelper  helper = new DaoMaster.DevOpenHelper(context, DBContstants.DB_NAME);
        Database db = helper.getWritableDb();
        mDaoSession = new DaoMaster(db).newSession();
    }

    public  synchronized  static  DBManageUtils  getDbInstance(Context context){
        if(mDBManage == null){
            mDBManage = new DBManageUtils(context);
        }
        return mDBManage;
    }


    /**
     * 得到数据库的session
     * @return
     */
    public DaoSession  getmDaoSession(){
        if(mDaoSession != null) {
            return mDaoSession;
        }
        return  null;
    }

}
MyApplication对数据库提供统一的接口：
 @Override
    public void onCreate() {
        super.onCreate();
        //初始化数据库
        initDb();
    }

    //数据库管理类
    private DBManageUtils mKotiDbManage;

    /**
     * 初始化数据库DB,实例化一个数据库的会话Sesssion, (采用的是GreenDao框架)
     */
    private void initDb(){
        mKotiDbManage =  DBManageUtils.getDbInstance(this);
    }

    //得到数据库管理类的方法
    public  DBManageUtils getmKotiDbManage(){
        return  mKotiDbManage;
    }


5. 在外界访问数据库，对其中的表数据进行增删改查

/**
     * 对位置 为position的的数据进行修改
     * @param position
     */
    public void updateUser(Long position , MyTestBeanDao myTestBeanDao){
        //查询id是1位置的数据
        TestBean user = myTestBeanDao.load(5l);
        //对其进行修改
        user.setName("简国堂");
        myTestBeanDao.update(user);

        //这个方法也可以修改
        myTestBeanDao.insertOrReplace(user);

    }

    /**
     * 查询所有
     * @param myTestBeanDao
     */

    public void getAll ( MyTestBeanDao myTestBeanDao){

        List<TestBean>  lists =  myTestBeanDao.queryBuilder().list();
        for (TestBean myBean : lists) {
            Log.e("CHRIS", "getAll: lists  = " + myBean.toString());
        }

        //懒加载模式
        LazyList<TestBean> lazyList =  myTestBeanDao.queryBuilder().listLazy();
        //myTestBeanDao.queryBuilder().

        for (TestBean myBean : lazyList) {
            Log.e("CHRIS", "getAll: lazyList  = " + myBean.toString());
        }


        //用另一整个遍历查询的方法
        Iterator  myIterator = myTestBeanDao.queryBuilder().listIterator();
        while(myIterator.hasNext()){
            TestBean bean  = (TestBean) myIterator.next();
            Log.i("CHRIS", "getAll: myIterator  = " + bean.toString());
        }

        lazyList.close();

    }

    public void delete(MyTestBeanDao myTestBeanDao){
        //删除
        myTestBeanDao.delete(new TestBean());
        myTestBeanDao.deleteByKey(1L);

    }


    /**
     * 条件查询  等于 Eq
     */
    public void queryEq(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Id.eq(1)).list();

        Log.i("CHRIS", "getAll: queryEq  = " + beans.toString());
    }

    /**
     * 条件查询  不等于 NotEq
     */
    public void queryNotEq(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Id.notEq(1)).list();

        Log.i("CHRIS", "getAll: queryNotEq  = " + beans.toString());
    }


    /**
     * 条件查询  匹配查找 Like
     */
    public void queryLike(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Name.like("jiang")).list();

        Log.i("CHRIS", "getAll: queryLike  = " + beans.toString());
    }

    /**
     * 条件查询  区间查找 Between
     */
    public void queryBetween(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Age.between(10,20)).list();

        Log.i("CHRIS", "getAll: queryBetween  = " + beans.toString());

    }


    /**
     * 条件查询  大于查找  Gt
     */
    public void queryGt(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Age.gt(20)).list();

        Log.i("CHRIS", "getAll: queryGt  = " + beans.toString());

    }

    /**
     * 条件查询  大于等于查找 Ge
     */
    public void queryGe(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Age.ge(20)).list();

        Log.i("CHRIS", "getAll: queryGe  = " + beans.toString());

    }

    /**
     * 条件查询  小于查找  Lt
     */
    public void queryLt(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Age.lt(20)).list();

        Log.i("CHRIS", "getAll: queryLt  = " + beans.toString());
    }

    /**
     * 条件查询  小于等于查找 Le
     */
    public void queryLe(MyTestBeanDao myTestBeanDao){

        List beans =   myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Age.le(20)).list();

        Log.i("CHRIS", "getAll: queryLe  = " + beans.toString());
    }


    /**
     * 条件查询  排序查询
     * 升序  OrderAsc
     * 升序  OrderDsc
     */
    public void queryOrderAsc(MyTestBeanDao myTestBeanDao){

        List beans = myTestBeanDao.queryBuilder().where(MyTestBeanDao.Properties.Age.le(20)).
                orderAsc(MyTestBeanDao.Properties.Id).list();

        Log.i("CHRIS", "getAll: queryLe  = " + beans.toString());
    }

    /**
     * 原生方法查询
     * 升序  OrderAsc
     * 升序  OrderDsc
     */
    public void querySQL(MyTestBeanDao myTestBeanDao){

        Query<TestBean> query = myTestBeanDao.queryBuilder().where(
                new WhereCondition.StringCondition("_ID IN " +
                        "(SELECT USER_ID FROM USER_MESSAGE WHERE READ_FLAG = 0)")
        ).build();

        Log.i("CHRIS", "getAll: queryLe  = " + query.toString());
    }


    public void queryThread(MyTestBeanDao myTestBeanDao){
public class TestBean1 {
    @Id
    private Long id;

    private String name;

    private int  age;

final Query query = myTestBeanDao.queryBuilder().build(); new Thread(){ @Override public void run() { super.run(); // org.greenrobot.greendao.DaoException: // Method may be called only in owner thread, // use forCurrentThread to get an instance for this thread
 Query創建和調用需要在同一個線程中 List data = query.forCurrentThread().list(); Log.e("CHRIS", "run: == data == " + data); } }.start(); }

6.问题1： 如果一个表需要和另外一个表关联： 在建立实体类的时候需要建立连接关系（）

eg: 1 我有两个Bean TestBean1 和TestBean2 

      2 TestBean2 需要关联查询TestBean1，在编写实体类如下（红色字体的是表示实现连接关系  一对一关系  @toOne ）

public class TestBean1 {
    @Id
    private Long id;

    private String name;

    private int  age;

@Entity
public class TestBean2 {
    @Id
    private Long  id;

    private String Address;

    private String salary;

    private Long  testBeanId;

    @ToOne(joinProperty = "testBeanId")
    private TestBean1 testBean1;

7.问题2： 实现一对多的关系 和 多对多关系的方法（ 暂时未研究验证清楚）