入门

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

    我们有这样的关系：

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

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

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

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

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

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

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

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

    1. 注释标记类

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

    3. 至少定义一个主键

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

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

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

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

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

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

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

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

    在3.0，我们不再需要明确地定义@ForeignKeyReference 每个引用列。DBFlow会自动将它们添加到表定义中，基于引用表的。它们将出现在格式{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
    13.   @ForeignKey(saveForeignKeyModel = false)
    14.   ForeignKeyContainer<Queen> queenForeignKeyContainer;
    16.   /**
    17.   * Example of setting the model for the queen.
    19.   public void associateQueen(Queen queen) {
    20.     queenForeignKeyContainer = FlowManager.getContainerAdapter(Queen.class).toForeignKeyContainer(queen);
    21.   }
    22. }

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

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

    由于ModelContainer默认情况下不会使用，所以我们必须添加 @ModelContainer注释到Queen 累中才能使用 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. }

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

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