GreenDao3.2数据库使用教程

greenDao github地址

基本增删改查命令【CRUD】

新建User.java文件，如下：

@Entity
public class User {@Id(autoincrement = true)@Property(nameInDb = "_id")private Long _id ;@Property(nameInDb = "_name" )private String name ;@Property(nameInDb = "_age")private int age ;@Generated()public User() {}

这里声明一下，各种注解稍后解释，大家先看着就行，User的属性getter/setter方法不需要你生成，使用Ctrl+F9（或者Build -> make module）进行编译，然后在你所写的greendao/package路径下生成了三个文件：UserDao，DaoMaster，DaoSession,如下图（其他文件无视即可）：

同时再回过头来，你会发现你的User.java文件也生成了getter/setter方法，那么说明自动生成已经凑效了。

下面就greenDao的注解，简单说明一下各个注解的含义：

@Entity         标识实体类，greenDAO会映射成sqlite的一个表，表名为实体类名的大写形式@Id             标识主键，该字段的类型为long或Long类型，autoincrement设置是否自动增长@Property       标识该属性在表中对应的列名称, nameInDb设置名称@Transient      标识该属性将不会映射到表中，也就是没有这列@NotNull        设置表中当前列的值不可为空@Convert        指定自定义类型(@linkPropertyConverter)@Generated      greenDAO运行所产生的构造函数或者方法，被此标注的代码可以变更或者下次运行时清除@Index          使用@Index作为一个属性来创建一个索引；定义多列索引(@link Entity#indexes())@JoinEntity     定义表连接关系@JoinProperty   定义名称和引用名称属性关系@Keep           注解的代码段在GreenDao下次运行时保持不变  1.注解实体类：默认禁止修改此类 2.注解其他代码段，默认禁止修改注解的代码段@OrderBy        指定排序@ToMany         定义与多个实体对象的关系@ToOne          定义与另一个实体（一个实体对象）的关系@Unique         向数据库列添加了一个唯一的约束

注解需要在实际中运用，光这个我也是记不住的，写多了自然就记住了。

编写dao处理对象：

DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(ctx,DB_NAME);
DaoMaster mDaoMaster = new DaoMaster(devOpenHelper.getWritableDb());
DaoSession mDaoSession = mDaoMaster.newSession();

具体代码可以参考这里；

新增操作

    public void addData(User user) {UserDao userDao = mDaoSession.getUserDao();long insertId = userDao.insert(user);LogUtils.d("insertId:"+insertId);}

注意，User的初始化为：

User user = new User(null,"zhangsan",18);

User的Id应该设置为null，不然id默认为0，在自增主键情况下，插入数据将会报错。
同时还有以下方法：

  userDao.insertWithoutSettingPk(user);  //如果没有对象没有设置主键，使用这个方法，你基本上放进去的东西就废了，因为不知道怎么找出来:)userDao.insertOrReplace(user);   //如果主键一致，则替换为新的User对象userDao.insertInTx(List<User>);  //批量插入User对象

删除

    public void deleteUser(long _id) {UserDao userDao = mDaoSession.getUserDao();userDao.deleteByKey(_id);LogUtils.d("delete User finished");}

上面是使用primary_key删除的，还有以下删除方式：

userDao.deleteAll();                              //删除全部
userDao.deleteByKeyInTx(List<Long> idList);       //删除id为idList中的User
userDao.deleteInTx(List<User> userList);          //删除集合中的user
userDao.delete(user);                             //删除目标User[需要包含主键]

还可以使用条件删除，使用StringCondition模式，删除name=micro和age>20岁的人

QueryBuilder<User> queryBuilder = mDaoSession.queryBuilder(User.class);;WhereCondition.StringCondition  stringCondition = new WhereCondition.StringCondition("_name = 'micro'");
WhereCondition.StringCondition stringCondition1 = new WhereCondition.StringCondition("_age > 20");queryBuilder.where(stringCondition,stringCondition1).buildDelete().executeDeleteWithoutDetachingEntities();

删除name=micro 或者 name>20的user

queryBuilder.whereOr(stringCondition,stringCondition1).buildDelete().executeDeleteWithoutDetachingEntities();

当然还可以使用Property进行删除：

        QueryBuilder<User> queryBuilder = mDaoSession.queryBuilder(User.class);WhereCondition nameCondition = null ;WhereCondition ageCondition = null;Property[] properties = mDaoSession.getUserDao().getProperties();for (Property p : properties) {if(p.columnName.equals("_name")) {nameCondition = p.eq("micro");}if(p.columnName.equals("_age")){ageCondition = p.gt(20);}}queryBuilder.whereOr(nameCondition,ageCondition).buildDelete().executeDeleteWithoutDetachingEntities();

基本套路是一致的。

修改
基本代码如下：

    public void updateUser(User user) {UserDao userDao = mDaoSession.getUserDao();userDao.update(user);LogUtils.d("update user finished");}

这里User中需要有主键，不然没法修改的。
当然还有

userDao.updateInTx(Iterator<User>);    //批量修改User

查找
这个查找是SQL中最复杂最难的一个科目，也是考验程序员经验的时候，面对大数据量的数据库，一条有经验的SQL往往能节省很多时间，到了我们android这里，就不扯了，greenDao已经做了很好的优化了，你只需要怎么查找就行了。

通过Id查找
这个最简单了，就不说了，代码为：

    public void btnGetById(View view) {User user = mDaoSession.load(User.class,2L);if(null != user) {mTvInfo.setText(user.toString());}else{Toast.makeText(this, "查询数据失败", Toast.LENGTH_SHORT).show();}}

通过原生SQL查找
这个一般在条件语句中用的比较多：

    public void btnGetBySQL(View view) {String sql = "select * from " + UserDao.TABLENAME + " where _age > ? "  ;Cursor cursor =  mDaoSession.getDatabase().rawQuery(sql,new String[]{String.valueOf(23)});while (null != cursor && cursor.moveToNext()) {Long _id =  cursor.getLong(cursor.getColumnIndex("_id"));String name = cursor.getString(cursor.getColumnIndex("_name")) ;int age = cursor.getInt(cursor.getColumnIndex("_age"));//..... 原生的SQLite写法}
}

通过StringCondition查找
这个其实也说过了，就是上面的删除项，其实删除就是你先查出来再删除啊：

    public void btnGetByStringCondition(View view) {QueryBuilder<User> queryBuilder = mDaoSession.queryBuilder(User.class);WhereCondition.StringCondition  stringCondition = new WhereCondition.StringCondition("_name = 'micro'");WhereCondition.StringCondition stringCondition1 = new WhereCondition.StringCondition("_age > 20");List<User> userList = queryBuilder.where(stringCondition,stringCondition1).build().list();Log.d("TAG","---->>>" + userList);}

通过PropertyCondition查找

QueryBuilder<User> queryBuilder = mDaoSession.queryBuilder(User.class);WhereCondition nameCondition = null ;
WhereCondition ageCondition = null;
Property[] properties = mDaoSession.getUserDao().getProperties();for (Property p : properties) {if(p.columnName.equals("_name")) {nameCondition = p.eq("micro");  //p.eq,p.nep,p.like,p.between,p.in,p.notIn,p.isNull,p.isNotNull 各种SQL操作}if(p.columnName.equals("_age")){ageCondition = p.gt(20);}
}List<User> userList = queryBuilder.where(queryBuilder.or(nameCondition,ageCondition)).build().list();

数据库关系模型

目前greenDao支持的数据库模型为一对比一，一对多模型，暂未支持多对多模型。这是这篇博客的重点所在，在项目中，遇到几张表，没什么逻辑关系，那么使用原生的SQLite就可以搞定了，就不比请greenDao大佬了。由于在项目中遇到了很多表出现了相互依赖的关系，那么使用greenDao简单配置一下，就可以使用了。

一对一关系
什么是一对一，读官方的解释我不会，就举个例子吧，每个人对应一张身份证信息，那么提取对象人与身份证就是一对一的关系。在greenDao中，建立这种一对一的关系，先要确定谁是主导关系，这里是人，因为有人才有身份证信息，那么看IdCard和Person对象：

IdCard对象

@Entity
public class IdCard {@Id(autoincrement = true)private Long _id ;private String cardName;private String location;@Generated()public IdCard() {}
}

Person对象

@Entity
public class Person {@Id(autoincrement = true)private Long _id;private String name ;private Long idCardId ;@ToOne(joinProperty = "idCardId")private IdCard  idCard;@Generatedpublic Person(){}}

可以看到，Person对象中存在了IdCard的引用，而且IdCard的注解上为@ToOne,而其中的joinProperty对应了Person中一个私有属性idCardId。
完成编译之后，我们可以打开greenDao给我们建立的数据库，其中Person与IdCard表的结构为：

我们看到了Person表里面引用了IdCard的id，那么添加数据时应该这样：

    public void addPersonAndIdCard(View view) {IdCard idCard = new IdCard(null,"421111111133","shanghai22");mDaoSession.getIdCardDao().insert(idCard);Person p = new Person(null,"lisi",null);p.setIdCard(idCard);Long insertId = mDaoSession.getIdCardDao().getPersonDao().insert(p);Toast.makeText(this, "the insert id is " + insertId, Toast.LENGTH_SHORT).show();}

结果为：

一对多关系

对于一对多关系，这个字面上很好解释，一个人可以拥有多套房子，一个人可以买多件商品，水有不同的状态等等。在greenDao中，有三种映射方式生成一对

第一种：
@ToMany(referencedJoinProperty = “referenceId”)

一个人可有多个产品订单，抽象之后产生：顾客Customer与订单Order对象。一个顾客对应多个订单：
Order.java:

@Entity（nameInDb = "t_order"）
public class Order {@Idprivate Long _id ;private java.util.Date date ;//引用了顾客的Idprivate long customerId ;@Generated()public Order() {}

Customer.java:

@Entity
public class Customer {@Idprivate Long id ;@ToMany(referencedJoinProperty = "customerId")@OrderBy("date ASC")private List<Order> orders;@Generated()public Customer() {}

在Custom中使用注解@ToMany, 其referencedJoinProperty 对应Order对象中的customerId 对应的多个订单为List类型，生成的表的结构为：

插入数据：

    public void btnAdd(View view) {CustomerDao customerDao = mSession.getCustomerDao();Customer customer = new Customer(null);customerDao.insert(customer);OrderDao orderDao = mSession.getOrderDao();Order order1 = new Order(null,new Date(),customer.getId());Order order2 = new Order(null,new Date(),customer.getId());Order order3 = new Order(null,new Date(),customer.getId());orderDao.insert(order1);orderDao.insert(order2);orderDao.insert(order3);Toast.makeText(this, "add data finished...", Toast.LENGTH_SHORT).show();}

第二种：
@ToMany(joinProperties = {
@JoinProperty(name = “current_object_param”,referencedName = “reference_object_params”)
})

什么意思呢？不好解释，那还是举个例子吧，比如一个成功的人SuccessfulMan拥有很多家公司，抽象出来，这个SuccessfulMan对应多个公司对象，那么相对应的对象分别为：

SuccessFulMan.java

@Entity
public class SuccessfulMan {@Id(autoincrement = true)private Long _id;private int age ;@NotNullprivate String name;@ToMany(joinProperties = {@JoinProperty(name = "name",referencedName = "successfulManName")})@OrderBy("date ASC")private List<Company> companyList;@Generated()public SuccessfulMan (){}}

Company.java:

@Entity
public class Company {@Id(autoincrement = true)private Long _id;@NotNullprivate String successfulManName ;//当前公司名称private String companyName ;private java.util.Date date ;//销售额private double price;@Generated()public Company(){}
}

编译成功之后，我们查看两张表的结构：

SuccessfulMan表中的name字段与Company表中的successful_man_name绑定了，我们来添加数据试一下：

    public void addBtn(View view) {SuccessfulMan man = new SuccessfulMan(null, "micro", 34);mDaoSession.getSuccessfulManDao().insert(man);Company company = new Company(null, "micro", "baidu1", new Date(), 2000);Company company2 = new Company(null, "micro", "tencent1", new Date(), 4000);Company company3 = new Company(null, "micro", "ali1", new Date(), 5000);mDaoSession.getCompanyDao().insert(company);mDaoSession.getCompanyDao().insert(company2);mDaoSession.getCompanyDao().insert(company3);Toast.makeText(this, "insert data finished....", Toast.LENGTH_SHORT).show();}

可以看到的结果为：

可以看到绑定的name是一致的。

第三种：
@ToMany
@JoinEntity(entity = A_AND_B.class,
sourceProperty = “referenceAId” ,
targetProperty = “referenceBId”)

个人感觉这个是最好理解的，同时感觉这个也是最greenDao中最接近多对多关系的一种模式。还是拿例子说话吧。一个城市图书馆很多书，那么图书馆与书就是一对多的关系，抽象成代码为：
Book.java:

@Entity
public class Book {@Idprivate Long _id;private String name ;private double price ;@Generatedpublic Book(){}

City.java:[library不会写！！！]

@Entity
public class City {@Idprivate Long _id;private String name ;@ToMany@JoinEntity(entity = CityAndBooks.class,sourceProperty = "cityId" ,targetProperty = "bookId")private List<Book> bookList;@Generatedpublic City(){}

中间体CityAndBooks.java:

@Entity
public class CityAndBooks {@Idprivate Long _id;private long bookId;private long cityId ;@Generated()public CityAndBooks() {}

编译之后，获取的表结构为：

图中可以看出，此时的一对多关系建立了三张表，而city_and_book表记录了city表的id，book表的id，相互查询时就是按照这张中间表进行的，我们插入数据看一下结果：

        City city = new City(null,"shanghai");City city1 = new City(null,"北京");Book book = new Book(null,"one night",40);Book book1 = new Book(null,"thinking in java",68);mDaoSession.getCityDao().insert(city);mDaoSession.getCityDao().insert(city1);mDaoSession.getBookDao().insert(book);mDaoSession.getBookDao().insert(book1);CityAndBooks cb = new CityAndBooks(null,book.get_id(),city.get_id());CityAndBooks cb1 = new CityAndBooks(null,book1.get_id() , city1.get_id());mDaoSession.getCityAndBooksDao().insert(cb);mDaoSession.getCityAndBooksDao().insert(cb1);Toast.makeText(this, "insert data finished....", Toast.LENGTH_SHORT).show();

我们来看一下结果：

可以看出，我们的city与book已经建立了联系，那么查询起来应该不是那么困难吧。

数据库的更新

对于greenDao，或者对于SQLite数据库更新，一般比较负责任的方式一般是这样的：
* 对于需要更新的表，创建临时表，复制数据
* 删除需要更新的表
* 创建新的目标表
* 将临时数据复制到新的目标表中，并删除临时表

这个就不说，下面的地址中会给出代码更新代码。

好了，greenDao的基本用法就介绍得差不多了，当然还有很多细节问题需要大家去注意了，这个只有大家在应用中去体会了，东西还是很多的，如果有问题或者疑惑，请留言。

所有代码地址为：https://github.com/Microhx/studyCodes/tree/master/testgreengao
效果图为：