入门

在本节中，我们介绍如何构建一个简单的数据库，表，还有如何建立Model之间的关系。

蚁后：我们想知道蚁群数据是怎么保存的。我们要跟踪和标记所有蚂蚁的特定群体以及每个蚁后。

我们有这样的关系：

  2. Colony (1..1) -> Queen (1...many)-> Ants//1对1，1对多

设置DBFlow

要初始化DBFlow，放置在这段代码( FlowManager.init(this);)在你自定义的 Application 类中（推荐）：

  2. public class ExampleApplication extends Application {
  4.     @Override
  5.     public void onCreate() {
  6.         super.onCreate();
  7.         FlowManager.init(this);
  8.     }
  10. }

别担心，这只是初始化一次，它会守住只有应用程序，即使使用其他Context初始化。

最后，定义添加到清单（对应您的自定义应用程序的名称）：

  2. <application
  3.   android:name="{packageName}.ExampleApplication"
  4.   ...>
  5. </application>

定义我们的数据库

在DBFlow，一个 @Database 是一个占位符，这个占位符可以生产子类对象 BaseDatabaseDefinition， BaseDatabaseDefinition连接所有表，ModelAdapter，Views，Queries还有更多其下的对象。所有连接都在预编译的时候完成，所以没有搜索，反射，和任何其他能减慢您的应用程序的运行时间的影响。

在这个例子中，我们需要定义我们要把蚁群保存到哪里（定义数据库）：

  2. @Database(name = ColonyDatabase.NAME, version = ColonyDatabase.VERSION)
  3. public class ColonyDatabase {
  5.   public static final String NAME = "Colonies";
  7.   public static final int VERSION = 1;
  8. }

对于最佳实践，我们声明的常量NAME和 VERSION为public，以便于我们以后可以使用它。

Note: 如果你想使用SQLCipher（数据库加密） 请阅读 setup here

创建我们的表和建立关系

现在，我们有了保存蚁群数据的地方了(ColonyDatabase)，我们需要明确定义Model 来保存数据和展示数据

蚁后表（The Queen Table）

我们将自上而下的理解关系。每个蚁群只有一个皇后。我们定义数据库对象使用ORM（对象关系映射）模型。我们需要做的是在我们的Model定义我们每个需要保存到数据库的字段。

在DBFlow，任何要使用ORM实现数据库交互的都必须实现接口Model（也就是说如果你的数据库表一定要实现Model接口）。这样做的原因是统一接口balabala。。。。。为了方便起见，我们可以extends BaseModel（BaseModel 已经实现了 Model接口）

要正确定义一个表，我们必须：

  1. @Table注释标记类

  2. 将表到正确的数据库，例如ColonyDatabase

  3. 至少定义一个主键

  4. 类及其所有数据库中的列（model中的变量）必须用private或public,private的必须有（getter和setter方法）。这样从DBFlow生成的类可以访问它们。

我们可以这样定义一个基础的 Queen 表:

  2. @Table(database = ColonyDatabase.class)
  3. public class Queen extends BaseModel {
  5.   @PrimaryKey(autoincrement = true)
  6.   long id;
  8.   @Column
  9.   String name;
  11. }

因此，我们有一个蚁后的定义后，现在我们需要为蚁后定义一个蚁群。

The Colony(蚁群)

  1. @ModelContainer // more on this later.
  2. @Table(database = ColonyDatabase.class)
  3. public class Colony extends BaseModel {
  5.   @PrimaryKey(autoincrement = true)
  6.   long id;
  8.   @Column
  9.   String name;
  11. }

现在，我们有一个Queen和Colony，我们要建立一个1对1的关系。我们希望，当数据被删除，例如，如果发生火灾，破坏蚁群 Colony。当蚁群被破坏，我们假设女王Queen不再存在，所以我们要为 Colony“杀”了Queen，使其不再存在。

1-1 关系

为了建立他们的关系，我们将会定义一个外键作为Child：

  2. @ModelContainer
  3. @Table(database = ColonyDatabase.class)
  4. public class Queen extends BaseModel {
  6.   //...previous code here
  8.   @Column
  9.   @ForeignKey(saveForeignKeyModel = false)
  10.   Colony colony;
  12. }

为Model定义为外键的时候，查询数据库时候，该外键的值会自动加载（查询Queen的时候,对应的Colony会自动被加载）。出于性能方面的原因，我们默认saveForeignKeyModel=false ，目的是保存 Queen不会自动保存 Colony 。

如果你想保持这种配对完好，设置saveForeignKeyModel=true。

在3.0，我们不再需要明确地定义@ForeignKeyReference 每个引用列。DBFlow会自动将它们添加到表定义中，基于引用表的@PrimaryKey。它们将出现在格式{foreignKeyFieldName}_{referencedColumnName}。（如上外键colony的格式是：colony_id）

蚂蚁表 + 一对多

现在，我们有一个蚁群Colony 与蚁后 Queen 属于它，我们需要一些蚂蚁服侍她！

  2. @Table(database = ColonyDatabase.class)
  3. public class Ant extends BaseModel {
  5.   @PrimaryKey(autoincrement = true)
  6.   long id;
  8.   @Column
  9.   String type;
  11.   @Column
  12.   boolean isMale;
  14.   @ForeignKey(saveForeignKeyModel = false)
  15.   ForeignKeyContainer<Queen> queenForeignKeyContainer;
  17.   /**
  18.   * Example of setting the model for the queen.
  19.   */
  20.   public void associateQueen(Queen queen) {
  21.     queenForeignKeyContainer = FlowManager.getContainerAdapter(Queen.class).toForeignKeyContainer(queen);
  22.   }
  23. }

我们有 type，它可以是 “worker”, “mater”, 或 “other”。此外，如果蚂蚁还有男女之分。

在这种情况下，我们使用 ForeignKeyContainer，因为我们可以有成千上万的蚂蚁。出于性能的考虑，Queen将会被“延迟加载的”，只有我们调用toModel（）,才会查询数据库找出对应的 Queen。与此说，为了在ForeignKeyContainer上设置适当的值，你应该通过调用其生成的方法(FlowManager.getContainerAdapter(Queen.class).toForeignKeyContainer(queen))为自己转换成 ForeignKeyContainer 。

由于ModelContainer默认情况下不会使用，所以我们必须添加 @ModelContainer注释到Queen 累中才能使用 ForeignKeyContainer。

最后，使用@ForeignKeyContainer可以防止循环引用。如果这 Queen 和 Colony互相引用，我们会碰上的StackOverflowError，因为他们都将尝试从数据库加载对方中。

接下来，我们通过延迟加载蚂蚁建立“一对多”的关系，因为我们可能有成千上万，甚至是，数以百万计的储存：

  2. @ModelContainer
  3. @Table(database = ColonyDatabase.class)
  4. public class Queen extends BaseModel {
  5.   //...
  7.   // needs to be accessible for DELETE
  8.   List<Ant> ants;
  10.   @OneToMany(methods = {OneToMany.Method.SAVE, OneToMany.Method.DELETE}, variableName = "ants")
  11.   public List<Ant> getMyAnts() {
  12.     if (ants == null || ants.isEmpty()) {
  13.             ants = SQLite.select()
  14.                     .from(Ant.class)
  15.                     .where(Ant_Table.queenForeignKeyContainer_id.eq(id))
  16.                     .queryList();
  17.     }
  18.     return ants;
  19.   }
  20. }

注意：如果你发现Ant_Table报错的时候，跑一下，让库自动生成模板就不会再报错了

如果你想给自己懒加载，指定OneToMany.Method.DELETE和SAVE，代替ALL。如果每当女王的数据变化时候，您不希望保存，那么只指定 DELETE 和 LOAD。