GreenDAO3.0应用指南

2017-03-06 本文已影响210人 Rave_Tian

GreenDAO简介

在Android项目开发过程中，sqlite来保存数据。由于原生api用起来比较麻烦，所以现在兴起很多的开源ORM框架。所以总的来说GreenDAO就是一款非常高效易用的ORM框架GitHub地址。相比于其他框架主要有以下特点：

性能高效
简洁的API
为Android做了很多优化
内存消耗小
网上有哥们儿专门做了性能对比实验，大家可以看看（http://www.tuicool.com/articles/7VVfye）
其实GreenDAO已经出来很久，但是之前的版本用起来真的非常麻烦。项目中集成起来不方便，而且学习成本相对较高。但是前端时间升级到3.0之后，用起来可以说得上是“傻瓜式”，下面就让我们开始玩玩GreenDAO3.0。

集成GreenDAO

首先需要在project的gradle文件中引入greenDAO插件：

project的gradle

然后在module的gradle文件中添加greenDAO的插件，并引入相关类库：

module的gradle

Gradle 插件配置：

schemaVersion：数据库schema版本，也可以理解为数据库版本号；
daoPackage：设置DaoMaster 、DaoSession、Dao包名；
targetGenDir：设置DaoMaster 、DaoSession、Dao目录；
targetGenDirTest：设置生成单元测试目录；
generateTests：设置自动生成单元测试用例。

在这里需要注意首先引入的是引入相关插件，然后在dependencies中引入greenDAO的类库。其中schemaVersion表示数据库版本号，每次数据库升级的时候我们修改这里的版本号即可（修改这里的版本号，greenDAO会自动修改生成到DAOMaster中的版本号），targetGenDir表示greenDAO生成的DAOMaster和DaoSession的位置。做完这一切我们就已经成功将greenDAO引入到我们的项目中了。

使用GreenDAO

数据库引入成功后，在使用之前，我们还得先来创建一个实体类：

编写实体类

@Entity表示这个实体类一会会在数据库中生成对应的表，@Id表示该字段是id，小伙伴们注意该字段的数据类型为包装类型Long，为什么要用包装类型呢？我们一会插入数据的时候再说。@Property则表示该属性将作为表的一个字段，其中nameInDb看名字就知道这个属性在数据库中对应的数据名称。OK，写完这些之后将项目进行编译，编译成功之后系统会帮助我们生成相应的构造方法和get/set方法，并且还会在我们的包下生成DaoMaster和DaoSession。

Paste_Image.png

接下来我们就可以进行数据库的初始化了（官方推荐在Application下面做）：


public class MyApplication extends Application {
    private DaoSession daoSession;

    @Override
    public void onCreate() {
        super.onCreate();

        DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this,"test.db",null);
        Database db = helper.getWritableDb();
        daoSession = new DaoMaster(db).newSession();
    }

    public DaoSession getDaoSession() {
        return daoSession;
    }
}

首先获取一个DevOpenHelper对象，这个类有点类似于我们使用的SqliteOpenHelper，我们主要在这个类中对数据库的版本进行管理。同时我们在这里提供一个借口用来提供DaoSession对象。因为我们需要用DAOSession来获取DAO对象，然后使用DAO对象操作数据库。

数据库操作CRUD

数据库的增删改查我们都将通过UserDao来进行，所以我们需要先对UserDao进行一个初始化：

        daoSessin = ((MyApplication) getApplication()).getDaoSession();
        userDao = daoSessin.getUserDao();

添加数据

        User addUser = new User();
        addUser.setUsername("xiaoming");
        addUser.setNickname("angle");
        userDao.insert(addUser);

修改数据

修改数据需要先执行查询，将待修改的数据查询出来，然后再分别执行修改：

        List<User> updateList = userDao.queryBuilder().where(UserDao.Properties.Username.eq("tianrenzheng")).build().list();
        for (User u : updateList) {
            u.setNickname("updated angle");
            userDao.update(u);
        }

删除数据

删除数据原理同修改数据类似：

        List<User> deleteList = userDao.queryBuilder().where(UserDao.Properties.Username.eq("tianrenzheng")).build().list();
        for (User u : deleteList) {
            userDao.delete(u);
        }

查询数据

由上面的这个操作，可以看出查询操作在GreenDAO使用过程中的重要性，因为修改和删除数据都需要先将数据查询出来才能操作。所以理解和熟悉查询语句是GreenDAO日常使用中重点：

        Query<User> userQuery = userDao.queryBuilder().orderAsc(UserDao.Properties.Id).build();
        List<User> users = userQuery.list();
        for (User u : users) {
            Log.d(TAG, u.toString());
        }

这里只是一个简单的例子，SQL语句的所有操作，我们可以通过构建Query对象来实现。这里大家在实践中去摸索，函数的命名跟SQL关键字都是类似的。

数据库升级

数据库的升级其实就两个步骤我们来看看：

1.修改gradle文件

首先在module的gradle文件中修改版本号：

Paste_Image.png

2.修改实体类

@Entity  
public class User {  
    @Property  
    private int age;  
    @Property  
    private String password;  
    @Id  
    private Long id;  
    @Property(nameInDb = "USERNAME")  
    private String username;  
    @Property(nameInDb = "NICKNAME")  
    private String nickname;  
}

重新编译项目运行即可。一般的数据库升级这样就可以了，特殊情况可能需要自己编写数据库迁移脚本，这种时候可以自定义DBHelper，定义方式如下，注意继承类：

public class DBHelper extends DaoMaster.OpenHelper {  
    public static final String DBNAME = "lenve.db";  
  
    public DBHelper(Context context) {  
        super(context, DBNAME, null);  
    }  
  
    @Override  
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
        super.onUpgrade(db, oldVersion, newVersion);  
    }  
}

可以在onUpgrade方法中进行数据库的迁移，如果自定义了DBHelper，则数据库的初始化变为如下方式：

DBHelper devOpenHelper = new DBHelper(this);  
DaoMaster daoMaster = new DaoMaster(devOpenHelper.getWritableDb());  
DaoSession daoSession = daoMaster.newSession();  
userDao = daoSession.getUserDao();

多表关联

数据库的表可能涉及到一对一和一对多关系，在greenDAO中涉及到to-one和to-many关系。例如，你想在greenDAO中建立一个对多关系模型，你就需要使用to-one和to-many关系。但是，请注意，to-one和to-many关系是不相关的，所以你必须同时更新。

1：1关联

当我们在使用sqlite数据库来实现表的1：1关联时，通常我们会在主表中定义一个外键去关联副表，当要查询对应的数据时，首先我们要知道查询数据的外键，然后需要用外键去副表中查询所需要的数据。比如下面这样：

@Entity
public class Customer {
    private Long id;    private String username;
}
@Entity
public class Order {
    private Long orderId;
    private String orderInfo;
    private Long customerId;
}

Customer表通过orderId与Order表关联，查询Order的Customer时需要先知道Order中的customerId然后根据
Customer.id=Order .customerId值再去数据库中查询该orderId所对应的Customer对象。然而在greenDao中一个注释就可以搞定，只需要使用@ToOne注释来定义一个关联对象即可。

@ToOne 定义了一个entities与另一个entities的1：1对应关系。通过joinProperty参数来定义一个外键下面是代码示例：

@Entity
public class Customer {
    @Id(autoincrement = true)
    @Property(nameInDb = "CUSTOMERID")
    private Long customerId;
    @Property(nameInDb = "USERNAME")
    private String username;
}
@Entity
public class Order {
    @Id(autoincrement = true)
    @Property(nameInDb = "ORDERID")
    private Long orderId;
    @Property(nameInDb = "ORDERINFO")
    private String orderInfo;
    @Property(nameInDb = "CUSTOMERID")
    private Long customerId;

    @ToOne(joinProperty = "customerId")
    private Customer customer;
}

这样只要获得Order对象就能通过getCustomer()方法获取Order所对应的Customer了，这样是不是很高效，很简便。其实getCustomer方法也很简单，就是在底层帮助我们封装好了查询语句而已，另外getCustomer获取的对象也是懒查询机制，只有真正使用getCustomer方法查询到的对象时greenDao才会执行查询操作。如果你想立即执行查询操作可以调用DAO类的loadDeep()与queryDeep()方法。如果编译的时候发生以下问题是因为没有设置主键（@Id）：

![没有设置主键 . . .]

Paste_Image.png

1：N 关联

在1对1关联中每个顾客只能与一个订单对应，但是现实生活中肯定不只是这样，也会出现一个顾客下多个订单的情况。如果出现这种需求的话，按照原生Sqlite的思路一样是通过外键关联即可，只是这一次查询的对象会有很多个，但是使用greenDao的1：1关联方式显然不行。不过别担心greenDao还给我们准备了@ToMany注释。

@ToMany 定义了一个entities(这个标记为源实体)与另一个entities(这个标记为目标实体)的多个对象的关联关系：@Tomany有一下三种方式来定义1：N的映射关系。
referencedJoinProperty 在目标实体中我们需要定义一个与源实体关联起来的外键，即Order中的customerId，然后需要在源实体里我们需要将customerId作为referencedJoinProperty的属性。

public class Customer {
    @Id(autoincrement = true)
    @Property(nameInDb = "CUSTOMERID")
    private Long customerId;
    @Property(nameInDb = "USERNAME")
    private String username;
    @ToMany(referencedJoinProperty = "customerId")
    private List<Order> orders;
}

@Entity
public class Order {
    @Id(autoincrement = true)
    @Property(nameInDb = "ORDERID")
    private Long orderId;
    @Property(nameInDb = "ORDERINFO")
    private String orderInfo;
    @Property(nameInDb = "CUSTOMERID")
    private Long customerId;
}

joinProperties这个参数是referencedJoinProperty 参数的升级版。在referencedJoinProperty参数中我们发现俩个实体关联的外键是CustomerId与id，但是如果我们的需求是外键不能通过id来定义，需要用自己自定义属性来定义，第一种方法就没法用了，而joinProperties就是为了解决这个需求的。

  @Entity
  public class Customer {
      @Id private Long id;
      @Unique private String tag;

      @ToMany(joinProperties = {
              @JoinProperty(name = "tag", referencedName = "customerTag")
      })
      @OrderBy("date ASC")
      private List<Site> orders;
  }

  @Entity
  public class Order {
      @Id private Long id;
      private Date date;
      @NotNull private String customerTag;
  }

其实如果把

@ToMany(joinProperties = {
              @JoinProperty(name = "id", referencedName = "customerId")
      })

这样的话就和第一种方法实现原理是一样的了。

N：M关系

@JoinEntity 定义了N：M的映射关系。

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

      @ToMany
      @JoinEntity(
              entity = JoinProductsWithOrders.class,
              sourceProperty = "productId",
              targetProperty = "orderId"
      )
      private List<Order> ordersWithThisProduct;
  }

  @Entity
  public class JoinProductsWithOrders {
      @Id private Long id;
      private Long productId;
      private Long orderId;
  }

  @Entity
  public class Order {
      @Id private Long id;
  }

关联表的更新与解析

关联的查询也是懒加载机制，而且查询的结果会保存在缓存中下一次查询的时候如果缓存有会直接从缓存中获取结果。

同样关联表更新时因为有缓存机制的存在你需要将改动的表手动的通过add()方法来更新关联表中的对象或者直接清除缓存。

// 获取当前顾客的订单列表
List<Order> orders1 = customer.getOrders();

// 插入一个新订单
Order order = new Order();
order.setCustomerId(customer.getId());
daoSession.insert(order);

// 再一次获取顾客的订单
List<Order> orders2 = customer.getOrders(); 

// 因为缓存列表没有更新所以订单1与订单2的大小相等
assert(orders1.size() == orders2.size);
// 也是相同的对象
assert(orders1.equals(orders2));

//调用该方法后，才能更新缓存列表
orders1.add(newOrder);

//删除时也许要手动将缓存列表里面的数据删除
List orders = customer.getOrders();
// 从数据库中移除
daoSession.delete(someOrder);
// 手动从缓存列表移除
orders.remove(someOrder);

//如果数据库更新后不想手动添加数据可以使用resetXX()方法来清除缓存

customer.resetOrders();
List orders = customer.getOrders();

多表查询

有些时候我们的表没有使用ToOne与ToMany建立关联关系，但是我们又想一步到位。这时我们可以使用greenDao的多表查询功能来帮助我们减少不必要的代码。

关联单个表

//查询地址是住在迪拜大楼的用户
QueryBuilder<User> queryBuilder = userDao.queryBuilder();
queryBuilder.join(Address.class, AddressDao.Properties.userId)
  .where(AddressDao.Properties.Street.eq("迪拜大楼"));
List<User> users = queryBuilder.list();

关联多个表

//查询在欧洲人口超过100000的城市
QueryBuilder qb = cityDao.queryBuilder().where(Properties.Population.ge(1000000));
Join country = qb.join(Properties.CountryId, Country.class);
Join continent = qb.join(country, CountryDao.Properties.ContinentId,
Continent.class, ContinentDao.Properties.Id);
continent.where(ContinentDao.Properties.Name.eq("Europe"));
List<City> bigEuropeanCities = qb.list();

通过queryBuilder.join()链式调用来实现多表查询
注意：多表查询的前提是我们已经定义好了外键来关联表与表之间的关系。

注解（不全，用到了再补充）

实体@Entity注解

schema：告知GreenDao当前实体属于哪个schema；
active：标记一个实体处于活动状态，活动实体有更新、删除和刷新方法；
nameInDb：在数据中使用的别名，默认使用的是实体的类名；
indexes：定义索引，可以跨越多个列;
createInDb：标记创建数据库表;

基础属性注解

@Id :主键 Long型，可以通过@Id(autoincrement = true)设置自增长；
@Property：设置一个非默认关系映射所对应的列名，默认是的使用字段名举例:@Property (nameInDb="name")；
@NotNul：设置数据库表当前列不能为空；
@Transient ：添加次标记之后不会生成数据库表的列；

索引注解

@Index：使用@Index作为一个属性来创建一个索引，通过name设置索引别名，也可以通过unique给索引添加约束；
@Unique：向数据库列添加了一个唯一的约束；

关系注解

@ToOne：定义与另一个实体（一个实体对象）的关系
@ToMany：定义与多个实体对象的关系

GreenDAO原理简析

GreenDAO3.0应用指南

GreenDAO简介

集成GreenDAO

使用GreenDAO

数据库操作CRUD

添加数据

修改数据

删除数据

查询数据

数据库升级

1.修改gradle文件

2.修改实体类

多表关联

1：1关联

1：N 关联

N：M关系

关联表的更新与解析

多表查询

关联单个表

关联多个表

注解（不全，用到了再补充）

实体@Entity注解

基础属性注解

索引注解

关系注解

猜你喜欢

热点阅读