定制SQL获取实体集合，greendao的简单使用

public List<TaskWareList_Picking_DB> getWareListByCustom(String cBillCode)
    {
        List<TaskWareList_Picking_DB> list  = new ArrayList<>();
        Cursor cursor = null;
        TaskWareList_Picking_DBDao dao = BaseApplication.getDaoInstant().getTaskWareList_Picking_DBDao();
        String strSQL = "select T.*,T.[C_BILL_CODE] as parentID, ifnull(iSubCount,0) as iSubCount , T.[N_QNTTY]-b.[iSubCount]\n" +
                "from TASK_WARE_LIST__PICKING__DB T \n" +
                "left join (select i_id, sum(I_SCAN_COUNT) as iSubCount from TASK_WARE_INFO__PICKING__DB group by i_id) b on T.[i_id] = b.i_id\n" +
                "where T.[C_BILL_CODE] = ? \n" +
                "order by b.iSubCount>0, (T.[N_QNTTY]-b.[iSubCount]) desc, T.[I_ID]";
        strSQL = MessageFormat.format(strSQL, String.join(",", dao.getAllColumns()));
        try
        {
            cursor = BaseApplication.getDaoInstant().getDatabase().rawQuery(strSQL, new String[]{cBillCode});
            dao.detachAll();
            list = dao.loadAllDeepFromCursor(cursor);
//            while(cursor.moveToNext())
//            {
//                TaskWareList_Picking_DB entity = new TaskWareList_Picking_DB(
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.COrder.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.IID.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.COwnerName.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CWareCode.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CWareName.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CSpec.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CProducter.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.NQntty.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CCargoPosStr.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CLicenseID.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CSN.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CBatchNO.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CProductDate.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CExp.columnName)),
//                        cursor.getString(cursor.getColumnIndex(TaskWareList_Picking_DBDao.Properties.CBillCode.columnName))
//                );
//                list.add(entity);
//            }
        }
        catch (Exception ex)
        {
            Log.e("getWareListByCustom", ex.getMessage());
        }
        finally
        {
            if(cursor != null)
            {
                cursor.close();
            }
        }
        return list;
    }

 

/**
     * 获取拣货任务信息
     * @param cBillcode
     * @return
     */
    public static TaskInfo_Picking_DB getTaskInfoByCode(String cBillcode)
    {
        TaskInfo_Picking_DBDao dao = BaseApplication.getDaoInstant().getTaskInfo_Picking_DBDao();
        dao.detachAll();// 不这样，更新的数据字段可能不会被更新到界面上呀
        QueryBuilder<TaskInfo_Picking_DB> queryBuilder = dao.queryBuilder();
        queryBuilder.where(TaskInfo_Picking_DBDao.Properties.CBillCode.eq(cBillcode));
        return queryBuilder.unique();
    }

/**
     * 配置数据库 BaseApplication
     */
    private void setupDatabase()
    {
        //创建数据库shop.db
        DaoMaster.DevOpenHelper helper = new OpenHelper_update(this, "greendao.db", null);
        //获取可写数据库
        SQLiteDatabase db = helper.getWritableDatabase();
        //获取数据库对象
        DaoMaster daoMaster = new DaoMaster(db);
        //获取dao对象管理者
        daoSession = daoMaster.newSession(IdentityScopeType.Session/*None*/); 更新后内存中的值会更新，否则不会变
    }

    public static DaoSession getDaoInstant()
    {
        return daoSession;
    }

 

---

 

http://greenrobot.org/greendao/documentation/relations/

sqllite expert , 我的百度盘 : 链接: https://pan.baidu.com/s/1R9YQgBNa-XOuJkt6Nw-lJg 提取码: 33a6 

 

 

greendao的简单使用1

2017年08月01日 15:17:47 阅读数：160 标签： android开发android 更多

个人分类： Android框架学习

 

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/SuperBlueMe/article/details/76531667

GreenDao的简单使用

GreenDao是一个开源的基于SQLite数据库ORM(对象关系映射).我们在使用SQLite进行数据的缓存与读取,需要自己书写CRUD语句,还要将读取的数据进行转化为java对象,亦或者将java对象转化为数据库存储的一条条记录,这对于不是很熟悉SQL语句的android开发者来说实属不易.当然GreenDao存在的更大的意义是,通过简单的几行代码,就能够自动完成java对象与数据库表之间的链接,从而大大的节省了开发者的时间

特性

• 最好用的安卓ORM工具
• 强大的APIs支持
• 很小的内存开销
• 引入的jar包体积很小
• 使用了SQLCipher,保证数据库数据安全
• 其他不用多说了,使用的人多了,自然性能是经得起考验的

具体使用(greendao版本为:3.2.2,使用的IDE为AndroidStudio)

1.在build.gradle(app)下引入库的依赖

     apply plugin: 'com.android.application'
     apply plugin: 'org.greenrobot.greendao' // 生成一个module(library)

     android {
             ......
     }

     //初始化数据库
     greendao {
         schemaVersion 1 //数据库版本
         daoPackage 'com.leer.greendaotest.gen'//生成的DAOs, DaoMaster, 和DaoSession存放的包名

         targetGenDir 'src/main/java' //上面的daoPackage在工程中存放的位置
     }

     dependencies {
         ......
         compile 'org.greenrobot:greendao:3.2.2' // 添加greendao的jar包依赖,会自动进行下载
     }

2.在build.gradle(project)下添加greendao插件依赖

    buildscript {
         repositories {
             jcenter()
         }
         dependencies {
              ......
              classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // 添加插件
         }
     }

3.创建数据库当中的表(table)对应的实体(Entity)

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

        @Property
        private String studentName;

        @Property(nameInDb = "sex")
        private String studentSex;

       @Transient
        private String isChecked;
    }

 

• @Entity:代表Student类映射到数据库当中的一个表,表名叫做”Student”;其实我们可以换个角度来看,每张表下面都是一条条的记录,每一条记录包含了单个Student的各种属性,那么一个Student对象就映射到数据库Student表下面的一条条记录. 
  
  • @Id:对应主键,autoincrement = true,代表自增长,在向数据库中插入值得时候我们不必要为这个字段赋值
  • @Property:顾名思义,就是属性,相当于表中的一个个列名,当然Id也是列,只是它是主键列;nameInDb = “sex”:数据库当中的sex对应于实体类当中的studentSex;
  • @Transient:这个字段不会被写入到数据库,只是作为一个普通的java字段用来临时存储数据的,不会被持久化存到数据库当中去
  • 对应的注解还有好多,这里只罗列一些简单常常用到的
  • 更多注解说明请移步：http://m.blog.csdn.net/kongxingxing/article/details/5205233

使用

准备工作已经都准备完了,接下来该使用了.使用很简单—-> build -> Make Project,接下来神奇的事情发生了,看看你的项目目录:

• 点击Make Project之前:

  

• 点击Make Project之后:

  

  可以看到多了三个自动生成的类:DaoMaster、DaoSession、StudentDao

  这三个类有什么用呢:

• DaoMaster : 包含一个继承自 OpenHelper 的内部类,完成对数据库的创建,更新;创建数据库当中的表(table)等等;又被称作会话层,和SQLiteDatabase进行会话
• DaoSession : 管理Daos的class文件;也包含了一些基础的增删改查的方法
• XXXDao : 数据访问对象,每一张表格对应一个Entity实体类,dao就是访问一张具体表 格下面的数据的对象

        DaoMaster.DevOpenHelper openHelper = new DaoMaster.DevOpenHelper(this, "students.db",null);
        Database database = openHelper.getWritableDataBase();
        //将database传入daomaster创建daomaster对象
        DaoMaster daoMaster = new DaoMaster(database);
        //创建DaoSession对象,其实通过DaoSession对象,我们也可以完成对数据的增删改查了,但是利用XXXDao对象,方法会更加的全面
        DaoSession daoSession = daoMaster.newSession();


        //获取每一张表格的数据访问对象
        StudentDao studentDao = daoSession.getStudentDao();
        Student student = new Student();
        student.id = 1001;
        student.name = 张三;
        student.sex = male;
        //插入数据
        studentDao.insert(student);

 

StudentDao还有update(),delete(),query()等等的方法,如需了解更多,请查看我的 GreenDao的简单使用2 就先写到这里了..

在上一篇的greendao的使用的介绍中,我们知道了利用XXXDao可以完成数据库的一些基础的操作,例如:增、删、改、查

再次回忆三个自动生成的核心类：DaoMaster、DaoSession、XXXDao

• DaoMaster称作会话层，DaoMaster包含了一个DevOpenHelper(继承自OpenHelper),DevOpenHelper包含了对数据库的基础操作,例如:创建表,删除表,更新表,值得一提的是,DevOpenHelper类当中的升级数据库的方式是先将所有的表格删除,然后在重新创建表格,所有的数据就会消失掉,解决这个办法请参考:greendao3.0以上使用步骤（二）：数据库到底该怎么升级http://blog.csdn.net/huangxiaoguo1/article/details/54574713
• DaoSession 管理XXXDao.class类,也提供了增删改查的方法(其实是使用了AbstractDao抽象类)
• XXXDao 每一个table实体(Entity)对应的Dao类,提供了数据的增删改查等等一系列操作,比DaoSession类提供的方法更加具体

在项目中使用GreenDao操作数据的步骤:

1. (推荐)自己维护一个DaoManager的类,用来获取DaoMaster和DaoSession实例,例如:

public class DaoManager {
    //数据库名
    private static final String DB_NAME = "student.db";

    private Context mContext;
    //单例模式
    private volatile static DaoManager mDaoManager;

    private DaoMaster mDaoMaster;
    private DaoSession mDaoSession;
    private DaoMaster.DevOpenHelper mOpenHelper;

    private DaoManager(Context context) {
        this.mContext = context;
    }

    public static DaoManager getInstance(Context context) {
        if (mDaoManager == null) {
            synchronized (DaoManager.class) {
                mDaoManager = new DaoManager(context);
            }
        }

        return mDaoManager;
    }

    /**
     * 判断是否存在数据库,如果不存在,就创建数据库
     *
     * @return
     */
    public DaoMaster getDaoMaster() {
        if (mDaoMaster == null) {
            mOpenHelper = new DaoMaster.DevOpenHelper(mContext, DB_NAME);

            //完成数据库的创建
            mDaoMaster = new DaoMaster(mOpenHelper.getWritableDatabase());
        }
        return mDaoMaster;
    }


    public DaoSession getDaoSession() {
        if (mDaoSession == null) {
            if (mDaoMaster == null) {
                mDaoMaster = getDaoMaster();
            }
            mDaoSession = mDaoMaster.newSession();
        }

        return mDaoSession;
    }


    /**
     * 打开输出日志的操作,默认是关闭的
     */
    public void setDebug() {
        QueryBuilder.LOG_SQL = true;
        QueryBuilder.LOG_VALUES = true;
    }

    /**
     * 关闭
     */
    public void closeDaoSession() {
        if (mDaoSession != null) {
            mDaoSession.clear();
            mDaoSession = null;
        }
    }

    public void closeHelper() {
        if (mOpenHelper != null) {
            mOpenHelper.close();
            mOpenHelper = null;
        }
    }

    /**
     * 关闭数据库连接
     */
    public void closeDBConncetion() {
        closeDaoSession();
        closeHelper();
    }

}

 

2. 创建每一张table表格对应的dao,如下

public class StudentDaoManager {
    private DaoManager mDaoManager;

    private StudentDaoManager(Context context) {
        mDaoManager = DaoManager.getInstance(context);
    }

    //单例模式
    private static volatile StudentDaoManager mStudentDaoManager;

    public static StudentDaoManager getInstance(Context context) {
        if (mStudentDaoManager == null) {
            synchronized (StudentDaoManager.class) {
                if (mStudentDaoManager == null) {
                    mStudentDaoManager = new StudentDaoManager(context);
                }
            }
        }

        return mStudentDaoManager;
    }

    /**
     * 插入单条数据
     *
     * @param student 需要插入的数据
     * @return 是否插入成功
     */
    public boolean insertStu(Student student) {
        boolean flag = false;
        flag = mDaoManager.getDaoSession().getStudentDao().insert(student) != -1 ? true : false;
        return flag;
    }

    /**
     * 插入或者更新单条数据,如果数据已经存在,那么更新该条数据
     *
     * @param student
     * @return 是否插入成功
     */
    public boolean insertOrReplace(Student student) {
        boolean flag = false;
        flag = mDaoManager.getDaoSession().getStudentDao().insertOrReplace(student) != -1 ? true : false;
        return flag;
    }


    /**
     * 插入多条数据
     *
     * @param isUseTra 是否使用事物
     * @param list     需要批量插入的数据的列表
     * @return 是否插入成功
     */
    public boolean insertMutiStus(boolean isUseTra, List<Student> list) {
        boolean flag = false;
        try {

            if (isUseTra) {
                //使用事物批量插入
               mDaoManager.getDaoSession().getStudentDao().insertOrReplaceInTx(list);

            } else {
                for (Student student : list) {
                    //使用普通的方法,单条单条的插入
                    mDaoManager.getDaoSession().getStudentDao().insertOrReplace(student);
                }
            }
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }


    /**
     * 删除单条数据
     *
     * @param student
     * @return 是否插入成功
     */
    public boolean delete(Student student) {
        boolean flag = false;
        try {
            mDaoManager.getDaoSession().getStudentDao().delete(student);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 更新数据
     *
     * @param student 需要更新的数据
     * @return 是否插入成功
     */
    public boolean update(Student student) {
        boolean flag = false;
        try {
            mDaoManager.getDaoSession().getStudentDao().update(student);
            flag = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 返回所有的数据
     *
     * @return 列表
     */
    public List<Student> queryAll() {
        List<Student> students = mDaoManager.getDaoSession().getStudentDao().loadAll();
        return students;
    }

    /**
     * 返回单条记录
     *
     * @param studentId Student对象的ID,主键
     * @return 单条记录
     */
    public Student queryOne(long studentId) {
        return mDaoManager.getDaoSession().getStudentDao().load(studentId);
    }

    /**
     * 分页查询
     *
     * @param limit  查询记录的条数
     * @param offset 查询的起始位置
     * @return
     */
    public List<Student> queryOffset(int limit, int offset) {
        QueryBuilder<Student> builder = mDaoManager.getDaoSession().getStudentDao().queryBuilder();
        builder.offset(offset).limit(limit);
        List<Student> list = builder.list();
        return list;
    }

    /**
     * 使用QueryBuilder进行查询,
     *
     * @return
     */
    public List<Student> queryWithBuilder() {
        QueryBuilder<Student> builder = mDaoManager.getDaoSession().getStudentDao().queryBuilder();
        //1.使用了where(所有的where之间都是逻辑与的关系,相当于and)相当于:select * from student where name like "%乐" and sex = "男";
        builder.where(StudentDao.Properties.Name.like("%乐")).where(StudentDao.Properties.Sex.eq("男"));
        //2.上面相当于:
//        builder.where(StudentDao.Properties.Name.like("%乐"),StudentDao.Properties.Sex.eq("男"));

        //3.逻辑或,相当于or,将许多个查询条件串联起来
        builder.whereOr(StudentDao.Properties.Name.like("%乐%"), StudentDao.Properties.Sex.eq("男"));

        //4.和1中的查询结果是一样的
        List<Student> students = mDaoManager.getDaoSession().getStudentDao().queryRaw("where name like ? and sex = ?", new String[]{"%乐%", "男"});
        List<Student> studentList = builder.list();
        return students;
    }
}

 

上面的代码有些长,需要注意的是:

1.使用事务将数据插入(insert)到数据库的时候,对于数据量比较大的应该采取开启事务

//使用事物批量插入
mDaoManager.getDaoSession().getStudentDao().insertOrReplaceInTx(list);

可以看到直接传入一个List对象即可.另外需要注意的是,在批量插入数据的过程中,如果出现一个数据插入错误,那么事务就会回滚到插入前的状态.事务的开启与关闭,在greendao中已经为我们封装好了,我们不用操心.

2.查询数据是重中之重,对于SQL不是很熟悉的程序员来说,QueryBuilder是个好东西,先来看看怎么用吧:

QueryBuilder<Student> builder = mDaoManager.getDaoSession().getStudentDao().queryBuilder();
        //1.使用了where(所有的where之间都是逻辑与的关系,相当于and)相当于:select * from student where name like "%乐" and sex = "男";
        builder.where(StudentDao.Properties.Name.like("%乐")).where(StudentDao.Properties.Sex.eq("男"));
        //2.上面相当于:
//        builder.where(StudentDao.Properties.Name.like("%乐"),StudentDao.Properties.Sex.eq("男"));

        //3.逻辑或,相当于or,将许多个查询条件串联起来
        builder.whereOr(StudentDao.Properties.Name.like("%乐%"), StudentDao.Properties.Sex.eq("男"));

        //4.和1中的查询结果是一样的
        List<Student> students = mDaoManager.getDaoSession().getStudentDao().queryRaw("where name like ? and sex = ?", new String[]{"%乐%", "男"});

 

3. 我们知道XXXDao是继承自AbstractDao的,XXXDao封装了基本的增删改查的方法,而DaoSession也包含基本的增删改查的方法,在维护自己的XXXDao的时候,就像上面的示例代码中我自己定义了一个StudentDaoManager,里面包含了许多的增删改查的方法,这个StudentDaoManager只针对一张table,也就是Student,而日常的开发中数据库中肯定有多张表格,我们针对一张表格就写一个DaoManager这岂不是增加了开发的重复性.因此我建议直接将XXXDao这个自动生成的忽略掉,直接用DaoSession中的增删改查方法来操作数据库数据,示例如下:

//插入数据,T是泛型
public void insert(T t) {
    mDaoManager.getDaoSession().insert(t);
}

 

这样此数据库中的所有表格对应的数据就都能使用此方法了,而不用一个Entity就需要维护一个Dao

**4.**Properties是Student是StudentDao的一个内部类,维护了每一个table实体的列名 
关于更多类似于where、whereOr、like等等的greendao关键词的含义，请参考greendao官方API（http://greenrobot.org/files/greendao/javadoc/current/）