在 Flutter 中使用数据库

以 sqlite 为例，flutter 在使用数据库时需要引入 sqflite 依赖

dependencies:
  flutter:
    sdk: flutter

  sqflite:

导入 package:sqflite/sqflite.dart 与 package:sqflite/sql.dart 后，可以在 openDatabase 中的 onCreate 参数中设置初始化

openDatabase(
  'file:///home/steiner/workspace/playground/todolist/todolist.db',
  onCreate: (database, version) async {
    await database.execute(
      'create table if not exists TaskList('
      'id integer primary key autoincrement,'
      'name text not null'
      ');'
    );
  },

  version: 1
);

其余数据库操作参考 中文文档

由于在 Dart 中数据库的操作是异步的，返回值是 Future 类型，对 Future 使用 await 需要在异步函数中进行，
各个组件的 build 方法又是同步的，无法使用 Future
不过 flutter 提供了 FutureBuilder 组件，为其提供 futurue 选项来构造组件

FutureBuilder({
  this.future,
  this.initialData,
  required this.builder,
})

这里我们只需要用 future 与 builder 就好了
其中

• future : FutureBuilder 依赖的 Future ，通常是一个异步耗时任务。
  
• initialData : 初始数据，用户设置默认数据。
  
• builder : Widget 构建器; 该构建器会在 Future 执行的不同阶段被多次调用，构建器签名如下:
  Function (BuildContext context, AsyncSnapshot snapshot)
  

组件由 builder 返回，所有数据的获取通过 snapshot.data ，由于是异步操作，可能会有错误结果， 需要多次调用 future
此时可以通过 snapshot 的一些属性来判断状态

• snapshot.hasError
  
• snapshot.hasData
  

要查看错误信息，调用 snapshot.error

来看一个例子

• 定义一个异步函数，返回数据库对象的 Future 类型
  

  Future<Database> loadDataBase() async {
    WidgetsFlutterBinding.ensureInitialized();
    return openDatabase(
      'file:///home/steiner/workspace/playground/todolist/todolist.db',
      onCreate: (database, version) async {
        await database.execute(
    'create table if not exists TaskList('
        'id integer primary key autoincrement,'
        'name text not null'
        ');'
        );
  
        List<TaskList> listOfTaskList = [
    TaskList(name: 'Hello', id: 0),
    TaskList(name: 'World', id: 0),
    TaskList(name: 'Fuck', id: 0),
    TaskList(name: 'You', id: 0),
        ];
  
        listOfTaskList.forEach((tasklist) async {
    await database.rawInsert(
      'insert into ${TaskList.TABLE}'
          '(name)'
          'values(?);',
      [tasklist.name]
    );
        });
  
        await database.execute(
    'create table ${Task.TABLE} ('
        'id integer primary key autoincrement,'
        'name text,'
        'listid integer,'
        'isdone boolean,'
        'foreign key(listid) references ${TaskList.TABLE} (id)'
        ');'
        );
  
        List<Task> listOfTask = [
    Task(id: 0, name: "task1", isdone: false, listid: 1),
    Task(id: 0, name: "task2", isdone: false, listid: 1),
    Task(id: 0, name: "task3", isdone: false, listid: 1),
    Task(id: 0, name: "task4", isdone: false, listid: 2),
    Task(id: 0, name: "task5", isdone: false, listid: 2),
        ];
  
        listOfTask.forEach((task) async {
    await database.rawInsert(
      'insert into ${Task.TABLE}'
          '(name, isdone, listid)'
          'values(?, ?, ?);',
      [task.name, task.isdone, task.listid]
    );
        });
      },
  
      version: 1
    );
  }
  

• 在 HomePage 组件中定义异步函数 loadTaskList ，返回 List<TaskList> 类型
  
• 使用 FutureBuilder ，传入 future
  
• 在 builder 中返回组件
  

class HomePage extends StatelessWidget {

  Future<List<TaskList>> loadTaskList() async {
    final database = await loadDataBase();
    final maps =  await database.query(TaskList.TABLE);

    return List.generate(maps.length, (index) {
  Map<String, dynamic> record = maps[index];
  return TaskList(name: record['name'], id: record['id']);
    });
  }

  Widget build(BuildContext context) {
    // TODO: implement build
    return Scaffold(
      appBar: AppBar(title: Text('HomePage')),
      body: FutureBuilder(
  future: loadTaskList(),
  builder: (BuildContext context, AsyncSnapshot<List<TaskList>> snapshot) {
    if(snapshot.hasError) {
      return Text("fuck, error: ${snapshot.error}");
    } else if(snapshot.hasData) {
      List<TaskList> listOfTaskList = snapshot.data!;
      return Column(
        children: listOfTaskList.map((tasklist) => buildTaskList(context, tasklist)).toList(),
      );
    } else {
      return Text("there is no data now");
    }
  },
      ),
    );
  }

  Widget buildTaskList(BuildContext context, TaskList tasklist) {
    return OutlineButton(
      onPressed: () {
  Navigator.push(context, MaterialPageRoute(
      builder: (context) => TaskPage(tasklist: tasklist)
  ));
      },

      child: Row(
  mainAxisAlignment: MainAxisAlignment.spaceBetween,
  children: [
    Text(tasklist.name),
    Text(tasklist.id.toString()),
  ],
      ),
    );
  }
}

在一个测试的目录下，有以下文件

• database.dart
  
• database.g.dart
  
• main.dart
  
• task.dart
  
• task_dao.dart
  

使用 FutureBuilder 构造组件只能用一次 future ，这样的话组件不会感知到数据库的更新
为了解决这个问题，我们将获取数据库数据的结果定义为 Stream ，再用 StreamBuilder 来构造

首先，是重新定义一个数据库的查询方法，在 task_dao.dart 中

@Query('select * from task')
Stream<List<Task>> findAllTasksAsStream();

之后，重新生成代码
flutter pub run build_runner build

再是 StreamBuilder 传入 stream 与 builder

StreamBuilder<List<Task>>(
  stream: dao.findAllTasksAsStream(),
  builder: (_, snapshot) {
    if (!snapshot.hasData) return Container();

    final tasks = snapshot.requireData;

    return ListView.builder(
      itemCount: tasks.length,
      itemBuilder: (_, index) {
  return TaskListCell(
    task: tasks[index],
    dao: dao,
  );
      },
    );
  },
),

疑问
snapshot.requireData 能否使用 snapshot.data! 来替代 ?