Flutter离线数据存储全面总结

在移动应用开发中，离线数据存储是确保应用无网络连接时仍能提供核心功能和良好用户体验的关键。Flutter作为跨平台开发框架，提供了多种离线数据存储解决方案，每种方案都有其独特的优势和适用场景。本文将深入探讨Shared Preferences、SQLite、Hive、Drift (Moor)和ObjectBox等主流存储选项，帮助你根据应用需求做出明智的选择。

1 Shared Preferences：轻量级键值存储

1.1 概述与特点

Shared Preferences是Flutter中最简单的数据持久化解决方案之一，基于键值对存储机制。它在不同平台上使用原生实现：iOS上的NSUserDefaults、Android上的PreferencesDataStore、Web上的localStorage以及桌面平台的本地文件存储。这种存储方式特别适合保存小量数据，如用户偏好设置、应用配置信息和简单的状态标记。

Shared Preferences的主要特点包括：

轻量级：专为小数据设计，不适合大量或复杂数据存储
持久化：数据在应用重启后仍然保留
异步API：所有操作都不会阻塞UI线程
跨平台兼容：支持Android、iOS、Web和桌面平台
无需复杂配置：开箱即用，无需数据库设置

1.2 使用方法与示例

1.2.1 添加依赖

在pubspec.yaml中添加依赖：

dependencies:
  shared_preferences: ^2.5.3

1.2.2 基本操作

import 'package:shared_preferences/shared_preferences.dart';

// 保存数据
Future<void> saveData() async {
  final prefs = await SharedPreferences.getInstance();
  await prefs.setString('username', 'flutter_user');
  await prefs.setInt('user_age', 25);
  await prefs.setBool('is_dark_mode', true);
}

// 读取数据
Future<void> readData() async {
  final prefs = await SharedPreferences.getInstance();
  final username = prefs.getString('username') ?? 'default_user';
  final age = prefs.getInt('user_age') ?? 0;
  final isDarkMode = prefs.getBool('is_dark_mode') ?? false;
}

// 删除数据
Future<void> deleteData() async {
  final prefs = await SharedPreferences.getInstance();
  await prefs.remove('username');
  // 或清空所有数据
  await prefs.clear();
}

1.2.3 封装实用类

为了更好地组织代码，可以创建SharedPreferences的封装类：

import 'package:shared_preferences/shared_preferences.dart';

class SharedPreferencesService {
  static late SharedPreferences _prefs;
  
  // 初始化
  static Future<void> init() async {
    _prefs = await SharedPreferences.getInstance();
  }
  
  // 保存字符串
  static Future<void> setString(String key, String value) async {
    await _prefs.setString(key, value);
  }
  
  // 获取字符串
  static String? getString(String key) {
    return _prefs.getString(key);
  }
  
  // 保存整数
  static Future<void> setInt(String key, int value) async {
    await _prefs.setInt(key, value);
  }
  
  // 获取整数
  static int? getInt(String key) {
    return _prefs.getInt(key);
  }
  
  // 其他数据类型方法类似...
  
  // 删除指定键
  static Future<void> remove(String key) async {
    await _prefs.remove(key);
  }
  
  // 清空所有数据
  static Future<void> clear() async {
    await _prefs.clear();
  }
}

// 在main函数中初始化
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await SharedPreferencesService.init();
  runApp(MyApp());
}

1.3 适用场景与限制

Shared Preferences最适合以下场景：

用户偏好设置（主题、语言、字体大小等）
简单的用户状态保存（登录状态、首次使用标志）
应用配置信息
小型的缓存数据

但其也有明显限制：

不适合大量数据：存储大量数据会导致性能下降
仅支持基本数据类型：String、int、double、bool和字符串列表
无加密：数据以明文存储，不适合敏感信息
无查询功能：只能通过键检索值

对于敏感数据，可以考虑使用flutter_secure_storage包，它提供加密存储功能。

1.4 实战案例：主题设置管理

以下是一个使用Shared Preferences管理应用主题的完整示例：

import 'package:flutter/material.dart';
import 'package:shared_preferences/shared_preferences.dart';

class ThemeManager with ChangeNotifier {
  bool _isDarkMode = false;
  
  bool get isDarkMode => _isDarkMode;
  
  // 从SharedPreferences加载主题设置
  Future<void> loadThemePreference() async {
    final prefs = await SharedPreferences.getInstance();
    _isDarkMode = prefs.getBool('is_dark_mode') ?? false;
    notifyListeners();
  }
  
  // 切换并保存主题设置
  Future<void> toggleTheme(bool isDark) async {
    _isDarkMode = isDark;
    final prefs = await SharedPreferences.getInstance();
    await prefs.setBool('is_dark_mode', isDark);
    notifyListeners();
  }
}

// 在应用中使用
class MyApp extends StatelessWidget {
  final ThemeManager themeManager;
  
  MyApp({required this.themeManager});
  
  @override
  Widget build(BuildContext context) {
    return ValueListenableBuilder<bool>(
      valueListenable: themeManager,
      builder: (context, isDarkMode, child) {
        return MaterialApp(
          theme: isDarkMode ? ThemeData.dark() : ThemeData.light(),
          home: MyHomePage(),
        );
      }
    );
  }
}

2 SQLite (sqflite)：关系型数据库

2.1 概述与特点

SQLite是Flutter中处理结构化数据的强大关系型数据库解决方案，通过sqflite插件提供支持。它基于SQL语言，提供ACID（原子性、一致性、隔离性、持久性）兼容的事务处理，适合存储和管理复杂的关系型数据。

SQLite在Flutter中的主要特点：

关系型数据支持：支持表、索引、视图等关系数据库特性
SQL查询：可以使用完整的SQL语法进行复杂查询
AC兼容：支持事务处理，保证数据一致性
可扩展性：适合处理大量结构化数据
成熟稳定：基于成熟的SQLite引擎，社区支持丰富

2.2 使用方法与示例

2.2.1 添加依赖

dependencies:
  sqflite: ^2.0.0
  path_provider: ^2.0.0
  path: ^1.8.0

2.2.2 数据库帮助类

import 'package:sqflite/sqflite.dart';
import 'package:path/path.dart';
import 'package:path_provider/path_provider.dart';

class DatabaseHelper {
  static Database? _database;
  static const String dbName = 'my_database.db';
  static const int dbVersion = 1;
  
  // 用户表结构
  static const String userTable = 'users';
  static const String columnId = 'id';
  static const String columnName = 'name';
  static const String columnEmail = 'email';
  static const String columnAge = 'age';
  
  // 获取数据库实例
  Future<Database> get database async {
    if (_database != null) return _database!;
    _database = await _initDatabase();
    return _database!;
  }
  
  // 初始化数据库
  Future<Database> _initDatabase() async {
    Directory documentsDirectory = await getApplicationDocumentsDirectory();
    String path = join(documentsDirectory.path, dbName);
    return await openDatabase(
      path,
      version: dbVersion,
      onCreate: _onCreate,
    );
  }
  
  // 创建表
  Future<void> _onCreate(Database db, int version) async {
    await db.execute('''
      CREATE TABLE $userTable (
        $columnId INTEGER PRIMARY KEY AUTOINCREMENT,
        $columnName TEXT NOT NULL,
        $columnEmail TEXT UNIQUE NOT NULL,
        $columnAge INTEGER
      )
    ''');
  }
  
  // 插入用户
  Future<int> insertUser(User user) async {
    Database db = await database;
    return await db.insert(userTable, user.toMap());
  }
  
  // 查询所有用户
  Future<List<User>> getUsers() async {
    Database db = await database;
    List<Map<String, dynamic>> maps = await db.query(userTable);
    return List.generate(maps.length, (i) {
      return User.fromMap(maps[i]);
    });
  }
  
  // 根据ID查询用户
  Future<User?> getUserById(int id) async {
    Database db = await database;
    List<Map<String, dynamic>> maps = await db.query(
      userTable,
      where: '$columnId = ?',
      whereArgs: [id],
    );
    if (maps.isNotEmpty) {
      return User.fromMap(maps.first);
    }
    return null;
  }
  
  // 更新用户
  Future<int> updateUser(User user) async {
    Database db = await database;
    return await db.update(
      userTable,
      user.toMap(),
      where: '$columnId = ?',
      whereArgs: [user.id],
    );
  }
  
  // 删除用户
  Future<int> deleteUser(int id) async {
    Database db = await database;
    return await db.delete(
      userTable,
      where: '$columnId = ?',
      whereArgs: [id],
    );
  }
  
  // 复杂查询：按年龄范围查询
  Future<List<User>> getUsersByAgeRange(int minAge, int maxAge) async {
    Database db = await database;
    List<Map<String, dynamic>> maps = await db.query(
      userTable,
      where: '$columnAge BETWEEN ? AND ?',
      whereArgs: [minAge, maxAge],
      orderBy: columnAge,
    );
    return List.generate(maps.length, (i) {
      return User.fromMap(maps[i]);
    });
  }
}

2.2.3 数据模型类

class User {
  int? id;
  String name;
  String email;
  int? age;
  
  User({
    this.id,
    required this.name,
    required this.email,
    this.age,
  });
  
  // 将User对象转换为Map
  Map<String, dynamic> toMap() {
    return {
      DatabaseHelper.columnId: id,
      DatabaseHelper.columnName: name,
      DatabaseHelper.columnEmail: email,
      DatabaseHelper.columnAge: age,
    };
  }
  
  // 从Map创建User对象
  factory User.fromMap(Map<String, dynamic> map) {
    return User(
      id: map[DatabaseHelper.columnId],
      name: map[DatabaseHelper.columnName],
      email: map[DatabaseHelper.columnEmail],
      age: map[DatabaseHelper.columnAge],
    );
  }
}

2.3 高级功能与优化

2.3.1 事务处理

SQLite支持事务，确保多个操作的原子性：

Future<void> transferData() async {
  Database db = await DatabaseHelper().database;
  await db.transaction((txn) async {
    // 执行多个数据库操作
    await txn.rawInsert(
      'INSERT INTO users(name, email) VALUES(?, ?)',
      ['John Doe', 'john@example.com']
    );
    await txn.rawUpdate(
      'UPDATE users SET age = ? WHERE name = ?',
      [30, 'John Doe']
    );
  });
}

2.3.2 批量操作

对于大量数据插入，使用批量操作可以提高性能：

Future<void> batchInsertUsers(List<User> users) async {
  Database db = await DatabaseHelper().database;
  Batch batch = db.batch();
  
  for (var user in users) {
    batch.insert(DatabaseHelper.userTable, user.toMap());
  }
  
  await batch.commit();
}

2.3.3 数据库迁移

当数据库结构需要变更时，需要处理版本迁移：

Future<Database> _initDatabase() async {
  Directory documentsDirectory = await getApplicationDocumentsDirectory();
  String path = join(documentsDirectory.path, DatabaseHelper.dbName);
  
  return await openDatabase(
    path,
    version: DatabaseHelper.dbVersion,
    onCreate: _onCreate,
    onUpgrade: (db, oldVersion, newVersion) async {
      if (oldVersion < 2) {
        // 从版本1升级到版本2的迁移逻辑
        await db.execute('ALTER TABLE users ADD COLUMN phone TEXT');
      }
      if (oldVersion < 3) {
        // 从版本2升级到版本3的迁移逻辑
        await db.execute('CREATE TABLE addresses(id INTEGER PRIMARY KEY, user_id INTEGER, address TEXT)');
      }
    },
  );
}

2.4 适用场景与限制

SQLite最适合以下场景：

需要关系型数据模型的复杂应用
需要执行复杂查询和聚合操作
需要事务支持保证数据一致性
中型到大型数据集的管理

但其也有一些限制：

设置较复杂：需要手动创建和管理数据库模式
学习曲线：需要SQL知识
性能考虑：对于简单键值存储，可能过于重量级
无内置加密：需要额外措施保护敏感数据

3 Hive：轻量级NoSQL数据库

3.1 概述与特点

Hive是Flutter中一个轻量级且高性能的NoSQL数据库，使用纯Dart编写，无需原生依赖。它采用键值存储方式，但支持更复杂的数据结构，以其卓越的读写速度而闻名。

Hive的主要特点包括：

极高性能：基于二进制存储格式，读写速度极快
零依赖：纯Dart实现，无需原生依赖
简单API：易于学习和使用
跨平台支持：支持Android、iOS、Web和桌面平台
类型安全：支持生成类型适配器
加密支持：提供AES-256加密选项

3.2 使用方法与示例

3.2.1 添加依赖

dependencies:
  hive: ^2.2.3
  hive_flutter: ^1.1.0

dev_dependencies:
  hive_generator: ^2.0.0
  build_runner: ^2.4.0

3.2.2 初始化Hive

import 'package:hive/hive.dart';
import 'package:hive_flutter/hive_flutter.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // 初始化Hive
  await Hive.initFlutter();
  
  // 注册类型适配器
  Hive.registerAdapter(UserAdapter());
  
  // 打开盒子
  await Hive.openBox('settings');
  await Hive.openBox<User>('users');
  
  runApp(MyApp());
}

3.2.3 数据模型与类型适配器

import 'package:hive/hive.dart';

part 'user.g.dart'; // 生成的文件

@HiveType(typeId: 0)
class User {
  @HiveField(0)
  final String name;
  
  @HiveField(1)
  final int age;
  
  @HiveField(2)
  final String email;
  
  User({
    required this.name,
    required this.age,
    required this.email,
  });
}

运行以下命令生成类型适配器：

flutter pub run build_runner build

3.2.4 基本操作

// 打开盒子
var settingsBox = await Hive.openBox('settings');
var userBox = await Hive.openBox<User>('users');

// 写入数据
settingsBox.put('theme', 'dark');
settingsBox.put('language', 'en');
settingsBox.put('notifications', true);

userBox.put('user1', User(name: 'Alice', age: 25, email: 'alice@example.com'));

// 读取数据
String theme = settingsBox.get('theme', defaultValue: 'light');
bool notifications = settingsBox.get('notifications', defaultValue: false);
User? user = userBox.get('user1');

// 删除数据
settingsBox.delete('theme');
settingsBox.clear(); // 清空整个盒子

// 监听数据变化
settingsBox.listenable().addListener(() {
  print('Settings changed: ${settingsBox.values}');
});

// 批量操作
await settingsBox.putAll({
  'key1': 'value1',
  'key2': 'value2',
  'key3': 'value3',
});

// 获取所有键值对
Map<dynamic, dynamic> allSettings = settingsBox.toMap();

// 条件查询
List<User> youngUsers = userBox.values
    .where((user) => user.age < 30)
    .toList();

3.3 高级功能

3.3.1 加密盒子

import 'package:hive/hive.dart';

void main() async {
  var encryptionKey = Hive.generateSecureKey();
  var encryptedBox = await Hive.openBox(
    'secure_box',
    encryptionCipher: HiveAesCipher(encryptionKey),
  );
  
  await encryptedBox.put('secret', 'sensitive_data');
  String secret = encryptedBox.get('secret');
}

3.3.2 事务处理

await userBox.transaction((transaction) async {
  for (int i = 0; i < 100; i++) {
    transaction.put('user_$i', User(
      name: 'User $i',
      age: i % 50 + 18,
      email: 'user$i@example.com'
    ));
  }
});

3.3.3 懒加载盒子（LazyBox）

对于大型数据集，可以使用懒加载盒子来减少内存使用：

var lazyBox = await Hive.openLazyBox('large_data');

// 值只在首次访问时加载
await lazyBox.put('key', largeObject);
var value = await lazyBox.get('key');

3.4 性能优化技巧

使用类型适配器：为复杂对象生成类型适配器以提高性能
批量操作：使用putAll和事务进行批量写入
懒加载：对大型数据集使用LazyBox
定期压缩：对于频繁删除操作的盒子，定期调用box.compact()来回收空间
合理设计数据结构：避免存储过大的单个对象

3.5 适用场景与限制

Hive最适合以下场景：

需要高性能读写的应用
中小型数据集的管理
不需要复杂关系查询的应用
需要加密存储的场景
希望避免原生依赖的项目

Hive的限制包括：

不支持复杂关系查询：不能执行SQL风格的join操作
社区规模较小：相比SQLite，社区资源和支持较少
不适合超大型数据集：所有数据存储在内存中，不适合极大数据集

4 Drift (Moor)：响应式持久化库

4.1 概述与特点

Drift（原名Moor）是一个建立在SQLite之上的响应式持久化库，为Flutter应用提供类型安全和响应式数据库操作。它结合了SQLite的强大功能和现代Dart编程的便利性。

Drift的主要特点：

类型安全：编译时检查查询语法和类型
响应式：自动在数据变化时更新UI
SQL能力：可以使用原始SQL或类型安全的Dart查询
迁移工具：提供强大的数据库迁移支持
跨平台：支持Android、iOS、Web和桌面平台

4.2 使用方法与示例

4.2.1 添加依赖

dependencies:
  drift: ^2.0.0
  sqlite3_flutter_libs: ^0.5.0
  path_provider: ^2.0.0
  path: ^1.8.0

dev_dependencies:
  drift_dev: ^2.0.0
  build_runner: ^2.4.0

4.2.2 数据库和表定义

import 'package:drift/drift.dart';
import 'package:path_provider/path_provider.dart';
import 'package:path/path.dart' as p;

part 'database.g.dart';

// 表定义
class Users extends Table {
  IntColumn get id => integer().autoIncrement()();
  TextColumn get name => text().withLength(min: 1, max: 50)();
  TextColumn get email => text().withLength(min: 6, max: 100)();
  IntColumn get age => integer().nullable()();
  DateTimeColumn get createdAt => dateTime().withDefault(currentDateAndTime)();
}

// 数据库定义
@DriftDatabase(tables: [Users])
class MyDatabase extends _$MyDatabase {
  MyDatabase() : super(_openConnection());
  
  @override
  int get schemaVersion => 1;
  
  // 查询方法
  Future<List<User>> getAllUsers() => select(users).get();
  
  Future<User?> getUserById(int id) =>
      (select(users)..where((u) => u.id.equals(id))).getSingleOrNull();
  
  Stream<List<User>> watchAllUsers() => select(users).watch();
  
  // 插入方法
  Future<int> insertUser(UsersCompanion companion) =>
      into(users).insert(companion);
  
  // 更新方法
  Future<bool> updateUser(User user) =>
      update(users).replace(user);
  
  // 删除方法
  Future<int> deleteUser(int id) =>
      (delete(users)..where((u) => u.id.equals(id))).go();
}

// 打开数据库连接
LazyDatabase _openConnection() {
  return LazyDatabase(() async {
    final dbFolder = await getApplicationDocumentsDirectory();
    final file = File(p.join(dbFolder.path, 'db.sqlite'));
    return NativeDatabase(file);
  });
}

4.2.3 数据操作

// 初始化数据库
final database = MyDatabase();

// 插入数据
await database.insertUser(
  UsersCompanion(
    name: Value('Alice'),
    email: Value('alice@example.com'),
    age: Value(25),
  ),
);

// 查询数据
List<User> allUsers = await database.getAllUsers();
User? user = await database.getUserById(1);

// 响应式查询
StreamBuilder<List<User>>(
  stream: database.watchAllUsers(),
  builder: (context, snapshot) {
    if (snapshot.hasData) {
      return ListView.builder(
        itemCount: snapshot.data!.length,
        itemBuilder: (context, index) {
          final user = snapshot.data![index];
          return ListTile(
            title: Text(user.name),
            subtitle: Text(user.email),
          );
        },
      );
    } else {
      return CircularProgressIndicator();
    }
  },
);

// 更新数据
await database.updateUser(user.copyWith(age: Value(26)));

// 删除数据
await database.deleteUser(1);

4.2.4 复杂查询

// 自定义查询方法
Future<List<User>> getUsersByAgeRange(int minAge, int maxAge) async {
  return await (select(users)
    ..where((u) => u.age.isBetweenValues(minAge, maxAge))
    ..orderBy([(u) => OrderingTerm(expression: u.age)]))
    .get();
}

Future<List<User>> searchUsers(String query) async {
  return await (select(users)
    ..where((u) => u.name.like('%$query%') | u.email.like('%$query%')))
    .get();
}

// 使用原始SQL
Future<List<User>> getTopUsers(int limit) {
  return customSelect(
    'SELECT * FROM users ORDER BY created_at DESC LIMIT ?',
    variables: [Variable<int>(limit)],
    readsFrom: {users},
  ).then((rows) {
    return rows.map((row) => User.fromData(row.data, database)).toList();
  });
}

4.3 迁移与高级功能

4.3.1 数据库迁移

@DriftDatabase(tables: [Users, Posts]) // 新增Posts表
class MyDatabase extends _$MyDatabase {
  MyDatabase() : super(_openConnection());
  
  @override
  int get schemaVersion => 2; // 版本号增加
  
  @override
  MigrationStrategy get migration {
    return MigrationStrategy(
      onCreate: (Migrator m) async {
        await m.createAll();
      },
      onUpgrade: (Migrator m, int from, int to) async {
        if (from < 2) {
          // 从版本1升级到版本2
          await m.createTable(posts);
        }
      },
    );
  }
}

4.3.2 事务处理

Future<void> transferData() async {
  await database.transaction(() async {
    // 插入用户
    final userId = await database.insertUser(
      UsersCompanion(
        name: Value('Bob'),
        email: Value('bob@example.com'),
      ),
    );
    
    // 为用户创建相关数据
    await database.into(database.posts).insert(
      PostsCompanion(
        userId: Value(userId),
        title: Value('First Post'),
        content: Value('Hello World!'),
      ),
    );
  });
}

4.4 适用场景与限制

Drift最适合以下场景：

需要类型安全数据库操作的应用
希望使用响应式数据更新的应用
复杂的数据关系和查询需求
需要强大迁移支持的项目

Drift的限制包括：

学习曲线：需要时间学习其概念和API
构建过程：需要代码生成步骤
性能开销：相比直接使用SQLite有一定性能开销

5 ObjectBox：高性能NoSQL数据库

5.1 概述与特点

ObjectBox是一个高性能的NoSQL数据库，专为Flutter和移动设备优化。它以其卓越的性能和低资源消耗而闻名，特别适合需要处理大量数据或要求极高读写速度的应用。

ObjectBox的主要特点：

极致性能：读写速度极快，适合高性能需求
资源高效：低CPU、内存和能耗使用
离线优先：专为离线场景设计
向量搜索：支持设备上的向量搜索功能
数据同步：提供跨设备数据同步功能
跨平台：支持移动、桌面和嵌入式设备

5.2 使用方法与示例

5.2.1 添加依赖

dependencies:
  objectbox: ^3.0.0
  objectbox_flutter_libs: ^3.0.0

dev_dependencies:
  objectbox_generator: ^3.0.0
  build_runner: ^2.4.0

5.2.2 实体定义

import 'package:objectbox/objectbox.dart';

@Entity()
class User {
  @Id()
  int id = 0;
  
  String name;
  String email;
  int? age;
  
  User({
    this.id = 0,
    required this.name,
    required this.email,
    this.age,
  });
}

@Entity()
class Order {
  @Id()
  int id = 0;
  
  final DateTime date;
  final double amount;
  
  @Property(type: PropertyType.date)
  DateTime get dateAsDateTime => DateTime.fromMillisecondsSinceEpoch(date);
  set dateAsDateTime(DateTime value) {
    date = value.millisecondsSinceEpoch;
  }
  
  Order({
    this.id = 0,
    required this.date,
    required this.amount,
  });
}

5.2.3 初始化ObjectBox

import 'package:objectbox/objectbox.dart';
import 'package:path_provider/path_provider.dart';

class ObjectBox {
  late final Store store;
  late final Box<User> userBox;
  late final Box<Order> orderBox;
  
  ObjectBox._create(this.store) {
    userBox = Box<User>(store);
    orderBox = Box<Order>(store);
  }
  
  static Future<ObjectBox> create() async {
    final appDir = await getApplicationDocumentsDirectory();
    final store = await openStore(directory: appDir.path + '/objectbox');
    return ObjectBox._create(store);
  }
  
  // 关闭存储
  void close() {
    store.close();
  }
}

// 在main函数中初始化
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  final objectBox = await ObjectBox.create();
  runApp(MyApp(objectBox: objectBox));
}

5.2.4 基本操作

// 插入数据
final user = User(name: 'Alice', email: 'alice@example.com', age: 25);
final userId = userBox.put(user);

final order = Order(date: DateTime.now(), amount: 99.99);
final orderId = orderBox.put(order);

// 查询数据
final user = userBox.get(userId); // 根据ID查询
final allUsers = userBox.getAll(); // 获取所有用户

// 条件查询
final query = userBox.query(User_.age.greaterThan(18))
  ..order(User_.name);
final youngUsers = query.find();
query.close(); // 记得关闭查询

// 更新数据
user.age = 26;
userBox.put(user);

// 删除数据
userBox.remove(userId);

// 批量操作
final users = [
  User(name: 'User1', email: 'user1@example.com'),
  User(name: 'User2', email: 'user2@example.com'),
  User(name: 'User3', email: 'user3@example.com'),
];
userBox.putMany(users);

5.3 高级功能

5.3.1 关系管理

@Entity()
class Customer {
  @Id()
  int id = 0;
  
  String name;
  
  @Backlink()
  final orders = ToMany<Order>();
  
  Customer({
    this.id = 0,
    required this.name,
  });
}

@Entity()
class Order {
  @Id()
  int id = 0;
  
  final double amount;
  final DateTime date;
  
  final customer = ToOne<Customer>();
  
  Order({
    this.id = 0,
    required this.amount,
    required this.date,
  });
}

// 管理关系
final customer = Customer(name: 'John Doe');
final customerId = customerBox.put(customer);

final order = Order(amount: 149.99, date: DateTime.now());
order.customer.target = customer;
orderBox.put(order);

// 查询关联数据
final orders = customer.orders;

5.3.2 数据同步

ObjectBox Sync提供跨设备数据同步：

// 配置同步
final syncClient = Sync.client(
  store,
  'ws://your-sync-server:9999',
  SyncCredentials.none(),
);

// 启动同步
await syncClient.start();

// 监听同步状态
syncClient.stream.listen((event) {
  if (event is SyncConnected) {
    print('Connected to sync server');
  } else if (event is SyncDisconnected) {
    print('Disconnected from sync server');
  }
});

5.4 性能优化技巧

批量操作：使用putMany和removeMany进行批量操作
查询重用：重用查询对象而不是创建新查询
限制结果集：使用offset和limit分页查询大量数据
异步操作：将大量数据库操作放在isolate中执行
索引优化：为频繁查询的字段添加索引

5.5 适用场景与限制

ObjectBox最适合以下场景：

需要极致性能的应用
处理大量数据的应用
需要离线功能的IoT和移动应用
需要跨设备数据同步的应用
资源受限的环境

ObjectBox的限制包括：

不支持Web：目前不支持Flutter Web
学习曲线：需要学习新的API和概念
社区规模：相比SQLite社区较小
存储格式：专有存储格式，不易直接访问

6 存储方案对比与选择指南

6.1 综合对比表

特性	SharedPreferences	SQLite	Hive	Drift (Moor)	ObjectBox
存储类型	键值存储	关系型	NoSQL	关系型(SQLite包装)	NoSQL
性能	中等(小数据)	良好	优秀	良好	极佳
查询能力	无	强大(SQL)	有限	强大(类型安全)	良好
加密支持	需第三方库	需第三方库	内置AES-256	需第三方库	需手动加密
复杂度	低	中	低	高	中
跨平台	全平台	全平台	全平台	全平台	无Web支持
数据同步	无	无	无	无	内置同步
社区支持	强大	强大	良好	良好	一般

6.2 性能数据对比

根据实际基准测试（10,000条数据的读写操作）：

数据库	写入时间(ms)	读取时间(ms)
SharedPreferences	~15,000	~8,000
Hive	~800	~500
Isar	~300	~200
ObjectBox	~200	~150

6.3 选择指南

6.3.1 根据数据规模选择

小数据量（<1MB）：SharedPreferences或Hive
中等数据量（1MB-10MB）：Hive或SQLite
大数据量（>10MB）：SQLite、Drift或ObjectBox

6.3.2 根据查询需求选择

简单键值查询：SharedPreferences或Hive
复杂关系查询：SQLite或Drift
高性能读写：Hive或ObjectBox

6.3.3 根据特定需求选择

加密需求：Hive（内置加密）或其他+第三方加密
同步需求：ObjectBox（内置同步）或其他+自定义同步
类型安全：Drift（编译时检查）
零依赖：Hive（纯Dart实现）

6.3.4 实际应用场景推荐

用户设置/偏好：SharedPreferences
聊天消息缓存：Hive
电子商务产品目录：SQLite/Drift
物联网传感器数据：ObjectBox
社交媒体Feed：SQLite/Drift + 分页
离线地图数据：自定义文件存储 + SQLite

6.4 迁移策略

当需要从一种存储方案迁移到另一种时，考虑以下策略：

双写策略：在一段时间内同时写入新旧两种存储
数据导出导入：设计数据迁移工具
渐进式迁移：按功能模块逐步迁移
版本控制：通过应用版本控制管理迁移过程

// 示例：从SharedPreferences迁移到Hive
Future<void> migrateFromSharedPrefsToHive() async {
  final prefs = await SharedPreferences.getInstance();
  final settingsBox = await Hive.openBox('settings');
  
  // 迁移所有键值对
  final keys = prefs.getKeys();
  for (final key in keys) {
    final value = prefs.get(key);
    if (value != null) {
      await settingsBox.put(key, value);
    }
  }
  
  // 标记迁移完成，可选择性清理旧数据
  await prefs.clear();
}

7 总结

选择合适的离线数据存储方案是Flutter应用开发中的重要决策，直接影响应用的性能、用户体验和开发效率。SharedPreferences适合简单的键值对存储，Hive提供了优秀的NoSQL解决方案，SQLite和Drift适合复杂的关系型数据需求，而ObjectBox则提供了极致的性能和专业特性。

在实际项目中，考虑以下因素做出选择：

数据规模和复杂度
性能要求
查询需求
加密和安全需求
同步和跨设备需求
团队熟悉度和社区支持
长期维护考虑

无论选择哪种方案，都建议实施适当的数据抽象层，使存储实现细节与业务逻辑分离，为未来的迁移和扩展留下灵活性。良好的离线数据策略不仅能提升用户体验，还能减少对网络连接的依赖，提高应用的可靠性和可用性。

提示

对于大多数应用，建议从Hive开始，它在易用性和性能之间提供了良好的平衡。随着应用复杂度的增长，可以逐步迁移到更强大的解决方案如Drift或ObjectBox。