devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Flutter】持久化存储方案_flutter 存储

作者：笔触狂放9 | 2024-03-25 09:47:28

赞

踩

flutter 存储

文章目录

Flutter 持久化存储

1.1 SharedPreference

SharedPreference插件

1.1.1 使用

import 'package:bilibili_getx/core/shared_preferences/shared_preference_util.dart';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';

///测试SharedPreference
void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await SharedPreferenceUtil.initSharedPreference();
  await saveKeys();
  readKeys();
  await removeKey();
}

Future saveKeys() async {
  //存储bool
  await SharedPreferenceUtil.setBool("test_bool", true);

  /// 存储浮点
  await SharedPreferenceUtil.setDouble('test_double', 1.5);

  ///存储int
  await SharedPreferenceUtil.setInt('test_int', 1);

  ///存储字符串
  await SharedPreferenceUtil.setString('test_string', 'text');

  ///存储字符串列表
  await SharedPreferenceUtil.setStringList('items', ['earth', 'moon']);
}

void readKeys() async {
  final bool? state = SharedPreferenceUtil.getBool('test_bool');
  final double? doubleValue = SharedPreferenceUtil.getDouble('test_double');
  final int? intValue = SharedPreferenceUtil.getInt('test_int');
  final String? stringValue = SharedPreferenceUtil.getString('test_string');
  final List<String>? items = SharedPreferenceUtil.getStringList('items');
  print(state); // true
  print(doubleValue); //1.5
  print(intValue); // 1
  print(stringValue); // text
  print(items.toString()); // [earth, moon]
}

Future removeKey() async {
  final bool? state = SharedPreferenceUtil.getBool('test_bool');
  print(state); // true
  await SharedPreferenceUtil.remove('test_bool');
  final bool? afterRemoveState = SharedPreferenceUtil.getBool('test_bool');
  print(afterRemoveState); // false
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

工具类

import 'dart:convert';

import 'package:shared_preferences/shared_preferences.dart';

///持久化存储数据
class SharedPreferenceUtil {
  static late SharedPreferences? _preferences = null;

  ///初始化SharedPreference
  static Future initSharedPreference() async {
    _preferences ??= await SharedPreferences.getInstance();
  }

  /// 根据key存储int类型
  static Future<bool>? setInt(String key, int value) {
    return _preferences?.setInt(key, value);
  }

  /// 根据key获取int类型
  static int? getInt(String key, {int defaultValue = 0}) {
    return _preferences?.getInt(key) ?? defaultValue;
  }

  /// 根据key存储double类型
  static Future<bool>? setDouble(String key, double value) {
    return _preferences?.setDouble(key, value);
  }

  /// 根据key获取double类型
  static double? getDouble(String key, {double defaultValue = 0.0}) {
    return _preferences?.getDouble(key) ?? defaultValue;
  }

  /// 根据key存储字符串类型
  static Future<bool>? setString(String key, String value) {
    return _preferences?.setString(key, value);
  }

  /// 根据key获取字符串类型
  static String? getString(String key, {String defaultValue = ""}) {
    return _preferences?.getString(key) ?? defaultValue;
  }

  /// 根据key存储布尔类型
  static Future<bool>? setBool(String key, bool value) {
    return _preferences?.setBool(key, value);
  }

  /// 根据key获取布尔类型
  static bool? getBool(String key, {bool defaultValue = false}) {
    return _preferences?.getBool(key) ?? defaultValue;
  }

  /// 根据key存储字符串类型数组
  static Future<bool>? setStringList(String key, List<String> value) {
    return _preferences?.setStringList(key, value);
  }

  /// 根据key获取字符串类型数组
  static List<String>? getStringList(String key,
      {List<String> defaultValue = const []}) {
    return _preferences?.getStringList(key) ?? defaultValue;
  }

  /// 根据key存储Map类型
  static Future<bool>? setMap(String key, Map value) {
    return _preferences?.setString(key, json.encode(value));
  }

  /// 根据key获取Map类型
  static Map? getMap(String key) {
    String jsonStr = _preferences?.getString(key) ?? "";
    return jsonStr.isEmpty ? Map : json.decode(jsonStr);
  }

  /// 获取持久化数据中所有存入的key
  static Set<String>? getKeys() {
    return _preferences?.getKeys();
  }

  /// 获取持久化数据中是否包含某个key
  static bool? containsKey(String key) {
    return _preferences?.containsKey(key);
  }

  /// 删除持久化数据中某个key
  static Future<bool?>? remove(String key) async {
    return await _preferences?.remove(key);
  }

  /// 清除所有持久化数据
  static Future<bool?>? clear() async {
    return await _preferences?.clear();
  }

  /// 重新加载所有数据,仅重载运行时
  static Future<void>? reload() async {
    return await _preferences?.reload();
  }

  /// 判断是否是json字符串
  static _isJson(String value) {
    try {
      const JsonDecoder().convert(value);
      return true;
    } catch (e) {
      return false;
    }
  }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111

1.2 Sqlite

Sqlite插件

1.2.1 使用

待补充

1.3 Realm

Realm插件

1.3.1 资料

MonGoDB官方资料
Flutter Realm数据类型

1.3.2 命令行生成Model(Flutter)

创建Flutter项目（略）
添加/更新Realm到项目中 & 配置pubspec.yaml文件
flutter pub add realm	

  • 1
realm: ^1.3.0

  • 1
flutter pub upgrade realm

  • 1
创建Model Data
import 'package:realm/realm.dart';

part 'realm_model_data_model.g.dart';

@RealmModel()
class _RealmModelDataModel {
  @PrimaryKey() //主键
  late Uuid uuid; //16Bytes的唯一值
  late ObjectId id; //mongodb特有的12Bytes唯一值
  late String text; //字符串
  late bool state; //布尔
  late int number; //整型
  late DateTime time; //时间
  late List<String> dataList; //数据列表
  late Set<_PartModel> partSet; //set集合
  String? textNote; //可选参数
  _PartModel? part; //引用其他模型
}

@RealmModel()
class _PartModel {
  late String partId;
  late String partName;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
生成对应的RealmObject Class
dart run realm install
dart run realm generate

  • 1
  • 2

执行generate命令，目录下会出现生成一个**.g.dart**文件，注意

part 'realm_model_data_model.g.dart';

  • 1

名称要写对，如下生成可用的RealmModelDataModel

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'realm_model_data_model.dart';

// **************************************************************************
// RealmObjectGenerator
// **************************************************************************

class RealmModelDataModel extends _RealmModelDataModel
    with RealmEntity, RealmObjectBase, RealmObject {
  RealmModelDataModel(
    Uuid uuid,
    ObjectId id,
    String text,
    bool state,
    int number,
    DateTime time, {
    String? textNote,
    PartModel? part,
    Iterable<String> dataList = const [],
    Set<PartModel> partSet = const {},
  }) {
    RealmObjectBase.set(this, 'uuid', uuid);
    RealmObjectBase.set(this, 'id', id);
    RealmObjectBase.set(this, 'text', text);
    RealmObjectBase.set(this, 'state', state);
    RealmObjectBase.set(this, 'number', number);
    RealmObjectBase.set(this, 'time', time);
    RealmObjectBase.set(this, 'textNote', textNote);
    RealmObjectBase.set(this, 'part', part);
    RealmObjectBase.set<RealmList<String>>(
        this, 'dataList', RealmList<String>(dataList));
    RealmObjectBase.set<RealmSet<PartModel>>(
        this, 'partSet', RealmSet<PartModel>(partSet));
  }
///截取至此

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
工具类RealmUtil

单例

import 'package:bilibili_getx/core/realm/realm_study/realm_realmList/realm_realm_list_model.dart';
import 'package:realm/realm.dart';

// mongodb realm 跨平台数据库
class RealmUtil {
  RealmUtil._internal();

  static final RealmUtil _instance = RealmUtil._internal();
  static late LocalConfiguration? config = null;
  static late Realm? _realm = null;

  factory RealmUtil() {
    ///注册schema
    List<SchemaObject> schemaObjects = [
      RealmRealmListModel.schema,
      ///补充,
    ];
    config ??= Configuration.local(schemaObjects);
    _realm ??= Realm(config!);
    return _instance;
  }

  Realm? get realmInstance => _realm;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

1.3.3 数据类型- 集合

RealmList

列表

import 'package:realm/realm.dart';

part 'realm_realm_list_model.g.dart';

@RealmModel()
class _RealmRealmListModel {
  late List<String> dataList; //数据列表
  late List<_Item> itemList; //对象列表
}

@RealmModel()
class _Item {
  @PrimaryKey()
  late ObjectId id;
  late String name;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

使用命令dart run realm generate生成RealmRealmListModel

基本使用
import 'package:bilibili_getx/core/realm/realm_study/realm_realmList/realm_realm_list_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

void main() {
  final sampleData = RealmRealmListModel(dataList: ["0", "dirty", "2", "3"]);

  ///新增一个列表
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.deleteAll<RealmRealmListModel>();
    RealmUtil().realmInstance?.add<RealmRealmListModel>(sampleData);
  });

  ///修改列表
  RealmResults<RealmRealmListModel>? results = RealmUtil().realmInstance?.all();
  RealmUtil().realmInstance?.write(() {
    results?.first.dataList.remove("dirty");
    results?.first.dataList[0] = "1";
    results?.first.dataList.add("4");
  });

  ///查看列表
  final res = RealmUtil().realmInstance?.all<RealmRealmListModel>();
  ///[1, 2, 3, 4]
  print(res?.toList().first.dataList.toString());
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
RealmSet

集合

import 'package:realm/realm.dart';

part 'realm_realm_set_model.g.dart';

@RealmModel()
class _RealmRealmSetModel {
  ///字符串Set
  late Set<String> stringSet;

  ///可空Set
  late Set<int?> intSet;

  ///对象Set
  late Set<_SomeRealmModel> objectSet;
}

@RealmModel()
class _SomeRealmModel {
  late ObjectId id;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
基本使用
import 'package:bilibili_getx/core/realm/realm_study/realm_realmSet/realm_realm_set_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

main() {
  final SomeRealmModel someRealm = SomeRealmModel(ObjectId());

  ///新增
  RealmUtil().realmInstance?.write<RealmRealmSetModel>(() {
    RealmUtil().realmInstance?.deleteAll<RealmRealmSetModel>();
    RealmRealmSetModel? realmRealmSet =
        RealmUtil().realmInstance?.add(RealmRealmSetModel(
              stringSet: {"apple", "banana"},
              intSet: {0, 1},
              objectSet: {someRealm},
            ));
    return realmRealmSet!;
  });

  ///修改
  ///{apple, banana, orange}
  // {null, 0, 1}
  // {Instance of 'SomeRealmModel', Instance of 'SomeRealmModel'}
  final res = RealmUtil().realmInstance?.all<RealmRealmSetModel>();
  RealmUtil().realmInstance?.write<RealmRealmSetModel?>(() {
    res?.first.stringSet.add("orange");
    res?.first.intSet.add(null);
    res?.first.objectSet.add(SomeRealmModel(ObjectId()));
    return null;
  });

  ///查询
  final queryRes = RealmUtil().realmInstance?.all<RealmRealmSetModel>();
  for (var item in queryRes!) {
    print(item.stringSet.toString());
    print(item.intSet.toString());
    print(item.objectSet.toString());
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
RealmResults

获取RealmResults可以通过realm.query() **realm.all()**查询获取

简单使用
import 'package:bilibili_getx/core/realm/realm_study/realm_model/realm_model_data_model.dart';
import 'package:bilibili_getx/core/realm/realm_study/realm_realmList/realm_realm_list_model.dart';
import 'package:bilibili_getx/core/realm/realm_study/realm_realmSet/realm_realm_set_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

main() {
  ///查询所有
  RealmResults<RealmRealmSetModel>? results =
      RealmUtil().realmInstance?.all<RealmRealmSetModel>();

  //新增测试数据
  RealmUtil().realmInstance?.write<RealmModelDataModel?>(() {
    RealmUtil().realmInstance?.deleteAll<RealmModelDataModel>();
    RealmUtil().realmInstance?.add<RealmModelDataModel>(RealmModelDataModel(
          Uuid.v4(),
          id: ObjectId(),
          text: "hello Realm",
          state: true,
          number: 1,
          time: DateTime.now(),
          textNote: "123",
        ));
    return null;
  });

  ///按条件查询
  RealmResults<RealmModelDataModel>? queryResult = RealmUtil()
      .realmInstance
      ?.query<RealmModelDataModel>(r'state == $0', [true]);

  ///{apple, banana, orange}
  // {null, 0, 1}
  // {Instance of 'SomeRealmModel', Instance of 'SomeRealmModel'}
  print("所有结果");
  for (var item in results!) {
    print(item.stringSet);
    print(item.intSet);
    print(item.objectSet);
  }

  ///hello Realm
  print("条件查询");
  for (var item in queryResult!) {
    print(item.text);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

1.3.4 其他数据类型

ObjectId

十二字节的唯一数值

import 'dart:typed_data';

import 'package:realm/realm.dart';

part 'realm_model_data_model.g.dart';

@RealmModel()
class _RealmModelDataModel {
  @PrimaryKey() //主键
  late Uuid uuid; //16Bytes的唯一值
  ObjectId? id; //mongodb特有的12Bytes唯一值
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
简单使用

通过**ObjectId()**获取

import 'package:bilibili_getx/core/realm/realm_study/realm_model/realm_model_data_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

main() {
  RealmUtil().realmInstance?.write<RealmModelDataModel?>(() {
    RealmUtil().realmInstance?.deleteAll<RealmModelDataModel>();
    RealmUtil().realmInstance?.add<RealmModelDataModel>(
        RealmModelDataModel(Uuid.v4(), id: ObjectId()));
    return null;
  });
  RealmResults<RealmModelDataModel>? results =
      RealmUtil().realmInstance?.all<RealmModelDataModel>();
  // b8193aa2-80f1-4922-b0fe-36beeda778c1
  // 64d9e645e5f9c0b1b84ef903
  for (var item in results!) {
    print(item.uuid);
    print(item.id);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
UUID

十六字节的唯一数值
数据模型同上

简单使用

**Uuid.v4()**获取一个唯一值
同上

RealmValue

存储任意数据类型
可以通过RealmValue.value && RealmValue.type来分别获取数值和数据类型

简单使用

**RealmValue.nullValue()**可存为空数值

import 'package:bilibili_getx/core/realm/realm_study/realm_model/realm_model_data_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

void main() {
  ///RealmValue任意数据类型
  final RealmValue realmValueOne = RealmValue.from(1);
  final List<RealmValue> realmValueListOne =
      ["abc", 123].map(RealmValue.from).toList();
  const RealmValue realmValueTwo = RealmValue.nullValue();
  final List<RealmValue> realmValueListTwo =
      ["abc", 123].map(RealmValue.from).toList();
  final sampleDataOne = RealmModelDataModel(
    Uuid.v4(),
    singleAnyValue: realmValueOne,
    listOfMixedAnyValues: realmValueListOne,
  );
  final sampleDataTwo = RealmModelDataModel(
    Uuid.v4(),
    singleAnyValue: realmValueTwo,
    listOfMixedAnyValues: realmValueListTwo,
  );

  ///写入
  RealmUtil().realmInstance?.write<RealmModelDataModel?>(() {
    RealmUtil().realmInstance?.deleteAll<RealmModelDataModel>();
    RealmUtil().realmInstance?.add<RealmModelDataModel>(sampleDataOne);
    RealmUtil().realmInstance?.add<RealmModelDataModel>(sampleDataTwo);
    return null;
  });

  ///读取
  // 1
  // [abc, 123]
  // [String, int]
  // null
  // [abc, 123]
  // [String, int]
  RealmResults<RealmModelDataModel> results =
      RealmUtil().realmInstance!.all<RealmModelDataModel>();
  for (RealmModelDataModel item in results) {
    print(item.singleAnyValue.value);
    ///获取数据
    print(item.listOfMixedAnyValues.map((e) => e.value).toList().toString());
    ///获取数据类型
    print(item.listOfMixedAnyValues.map((e) => e.type).toList().toString());
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
Uint8List

无符号8位整型

简单使用

通过Uint8List.fromList([1, 2])存储

import 'dart:typed_data';

import 'package:bilibili_getx/core/realm/realm_study/realm_model/realm_model_data_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

main() {
  RealmUtil().realmInstance?.write<RealmModelDataModel?>(() {
    RealmUtil().realmInstance?.deleteAll<RealmModelDataModel>();
    RealmUtil().realmInstance?.add<RealmModelDataModel>(RealmModelDataModel(
          Uuid.v4(),
          binaryList: Uint8List.fromList([1, 2]), //八位整型数组,realm1.3.0以上支持
        ));
    return null;
  });
  RealmResults<RealmModelDataModel>? results =
      RealmUtil().realmInstance?.all<RealmModelDataModel>();
  // e126c56d-77f1-4a6f-abf8-2ce48de340c8
  // [1, 2]
  for (var item in results!) {
    print(item.uuid);
    print(item.binaryList);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
嵌入对象Objects

数据模型可以加入其他数据模型，如加入PartModel

import 'package:bilibili_getx/core/realm/realm_study/realm_model/realm_model_data_model.dart';
import 'package:bilibili_getx/core/realm/realm_util.dart';
import 'package:realm/realm.dart';

///存储对象
main() {
  RealmUtil().realmInstance?.write<RealmModelDataModel?>(() {
    RealmModelDataModel realmModelData = RealmModelDataModel(
      Uuid.v4(),
      part: PartModel("part001", "partOne"),
    );
    RealmUtil().realmInstance?.deleteAll<RealmModelDataModel>();
    RealmUtil().realmInstance?.add<RealmModelDataModel>(realmModelData);
    return null;
  });
  final RealmResults<RealmModelDataModel>? results =
      RealmUtil().realmInstance?.all<RealmModelDataModel>();
  // partId: part001
  // partName: partOne
  for (var item in results!) {
    print("partId: ${item.part?.partId}");
    print("partName: ${item.part?.partName}");
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
注释属性

@PrimaryKey()主键
@Ignored() 忽略这个属性
@Indexed() 加快搜索
@Indexed(RealmIndexType.fullText) 全文搜索
@MapTo(‘name’) 属性名

import 'package:realm/realm.dart';

part 'realm_property_annotations_model.g.dart';

@RealmModel()
class _RealmPropertyAnnotationsModel {
  @PrimaryKey() //主键
  late ObjectId id;
  late String? optionalProperty; //可选参数
  late double defaultValue = 0; //默认数值
  @Ignored() //忽略该属性
  late String ignoreProperty;
  @Indexed() //增加查询该属性的速度
  late String quickQueryProperty;
  @Indexed(RealmIndexType.fullText) //增加查询该属性的速度
  late String fullTextSearch; //全文搜索
  @MapTo('keys') //属性名
  late int numberOfKeys;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

1.3.5 更新RealmModel

普通属性的增加和删除

包括int/string等
添加/删除普通属性值后 -> 重新生成RealmObject -> 更迭一个版本schemaVersion

  • 之前的RealmModel
import 'package:realm/realm.dart';

part 'modify_realm_model.g.dart';

@RealmModel()
class _ModifyRealmModel {
  late String firstName;
  late String lastName;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 更改之后
import 'package:realm/realm.dart';

part 'modify_realm_model.g.dart';

@RealmModel()
class _ModifyRealmModel {
  late String firstName;
  late String lastName;

  /// 修改RealmModel的属性
  late int age;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 运行命令重新生成
dart run realm generate

  • 1
  • 新增一个版本 (1->2)
import 'package:bilibili_getx/core/realm/realm_study/realm_update_model/modify_realm_model.dart';
import 'package:realm/realm.dart';

main() {
  final config = Configuration.local(
    [ModifyRealmModel.schema],
    // schemaVersion: 1,
    schemaVersion: 2, //更新版本
  );
  final realm = Realm(config);
  realm.write<ModifyRealmModel?>(() {
    realm.add<ModifyRealmModel>(ModifyRealmModel("james", "jock", 20));
    return null;
  });
  // james
  // jock
  // 0
  // james
  // jock
  // 20
  RealmResults<ModifyRealmModel> results = realm.all<ModifyRealmModel>();
  for (var item in results) {
    print(item.firstName);
    print(item.lastName);
    print(item.age);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
复杂属性的增加和删除

包括对象属性的删除和增加;利用**migration.deleteType(‘Person’)**来删除掉对象类型。如果这个对象类型还在其他类型中使用到，是删除不掉的

import 'package:bilibili_getx/core/realm/realm_study/realm_update_object_model/modify_realm_object_model.dart';
import 'package:realm/realm.dart';

main() {
  ///原先版本
  print("原先版本");
  operateOriginalVersion(1);

  ///去掉对象类型
  print("去掉Person类型");
  operateLaterVersion(2);

  ///查询结果
  operateResultVersion(3);

  // 原先版本
  // 1
  // 去掉Person类型
  // 0
}

void operateOriginalVersion(int version) {
  final configWithPerson = Configuration.local(
    [ModifyRealmObjectModel.schema, Person.schema],
    schemaVersion: version,
  );
  final realmWithPerson = Realm(configWithPerson);
  realmWithPerson.write<Person?>(() {
    realmWithPerson.deleteAll<Person>();
    realmWithPerson.add<Person>(
      Person("jack"),
    );
    return null;
  });
  RealmResults<Person> personResults = realmWithPerson.all<Person>();
  print(personResults.length);
  realmWithPerson.close();
}

void operateLaterVersion(int version) {
  final configWithoutPerson = Configuration.local(
    [ModifyRealmObjectModel.schema],
    schemaVersion: version,
    migrationCallback: ((migration, oldSchemaVersion) {
      ///移除Person类型
      migration.deleteType('Person');
    }),
  );
  final realmWithoutPerson = Realm(configWithoutPerson);
  realmWithoutPerson.close();
}

void operateResultVersion(int version) {
  final configWithoutPerson = Configuration.local(
    [Person.schema],
    schemaVersion: version,
  );
  final realmWithoutPerson = Realm(configWithoutPerson);
  RealmResults<Person> personResults = realmWithoutPerson.all<Person>();
  print(personResults.length);
  realmWithoutPerson.close();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
复杂属性的重命名

migration.renameProperty(模型名称,更改前属性名称,更改后属性名称)
更改模型中的其中一个属性名称

import 'package:bilibili_getx/core/realm/realm_study/realm_rename_property/realm_rename_property_model.dart';
import 'package:realm/realm.dart';

main() {
  final configWithRenameAge = Configuration.local(
    [RealmRenamePropertyModel.schema],
    schemaVersion: 2,
    migrationCallback: ((migration, oldSchemaVersion) {
      migration.renameProperty(
        'RealmRenamePropertyModel',
        'age',
        'yearsSinceBirth',
      );
    }),
  );
  final realmWithRenameAge = Realm(configWithRenameAge);
  realmWithRenameAge.write(() {
    realmWithRenameAge
        .add<RealmRenamePropertyModel>(RealmRenamePropertyModel("2"));
  });
  RealmResults<RealmRenamePropertyModel> results =
      realmWithRenameAge.all<RealmRenamePropertyModel>();
  for (var item in results) {
    print(item.yearsSinceBirth);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
属性的迁移

在回调函数migrationCallback((migration, oldSchemaVersion)){}
migration.oldRealm获取之前版本的Realm
migration.newRealm获取现版本的Realm
migration.findInNewRealm获取某一类型的对象
**RealmObjectBase.dynamic.get()**获取先前版本的属性值

简单使用
  • 修改前
import 'package:realm/realm.dart';

part 'realm_migration_tasks_model.g.dart';

@RealmModel()
class _Person {
  late String firstName;
  late String lastName;
  late ObjectId id;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

添加两组数据

void operateOldRealm() {
  final configBeforeChanges = Configuration.local(
    [Person.schema],
    schemaVersion: 1,
  );
  final realmBeforeChanges = Realm(configBeforeChanges);
  realmBeforeChanges.write(() {
    realmBeforeChanges.add<Person>(Person("jack", "james", ObjectId()));
    realmBeforeChanges.add<Person>(Person("lucky", "may", ObjectId()));
  });
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 修改后,新增属性fullName，修改id类型为String
import 'package:realm/realm.dart';

part 'realm_migration_tasks_model.g.dart';

@RealmModel()
class _Person {
  late String firstName;
  late String lastName;
  // late ObjectId id;

  // ///更改id的类型(objectId -> String)
  late String id;
  // ///新增一个属性fullName
  late String fullName;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

迁移数据库并对属性做出更改（firstName拼上lastName之后赋值给fullName,更改id类型为string）

void operateNewRealm() {
  final configWithChanges = Configuration.local(
    [Person.schema],
    schemaVersion: 2,
    migrationCallback: ((migration, oldSchemeVersion) {
      final oldPeople = migration.oldRealm.all('Person');
      for (final oldPerson in oldPeople) {
        final newPerson = migration.findInNewRealm<Person>(oldPerson);
        if (newPerson == null) {
          continue;
        }
        newPerson.fullName =
            "${oldPerson.dynamic.get<String>("firstName")} ${oldPerson.dynamic.get<String>("lastName")}";
        final oldId = oldPerson.dynamic.get<ObjectId>("id");
        newPerson.id = oldId.toString();
      }
    }),
  );
  final realmWithChanges = Realm(configWithChanges);
  RealmResults<Person> results = realmWithChanges.all<Person>();
  // id类型是String,数值是64dc126b8367fca9740fb0df
  // fullName是jack james
  // id类型是String,数值是64dc126b8367fca9740fb0e0
  // fullName是lucky may
  for (var item in results) {
    print("id类型是${item.id.runtimeType},数值是${item.id}");
    print("fullName是${item.fullName}");
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29

1.3.6 打开/设置Realm数据库

打开运行在缓存的数据库

打开一个运行在内存中的数据库,不记录任何写操作

  ///打开一个运行在内存中的数据库,不记录任何写操作
  Realm realm = openInMemoryRealm();
  realm.write(() {
    realm.add<Car>(Car("benTian"));
  });
  RealmResults<Car> results = realm.all<Car>();
  for (var item in results) {
    print(item.carName);
  }
  realm.close();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
Realm openInMemoryRealm() {
  final config = Configuration.inMemory([Car.schema]);
  final realm = Realm(config);
  return realm;
}

  • 1
  • 2
  • 3
  • 4
  • 5
本地数据库

记录读写

  Realm localRealm = openLocalRealm();
  RealmResults<Car> results = localRealm.all<Car>();
  for (var item in results) {
    print(item.carName);
  }
  localRealm.close();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
Realm openLocalRealm() {
  final config = Configuration.local([Car.schema]);
  final realm = Realm(config);
  return realm;
}

  • 1
  • 2
  • 3
  • 4
  • 5
只读数据库
///打开一个只读的数据库
  // Can't perform transactions on read-only Realms.
  Realm realm = openReadOnlyRealm();
  // 无法执行以下写数据的代码
  realm.write(() {
    realm.add<Car>(Car("BaoMa"));
  });

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
Realm openReadOnlyRealm() {
  final config = Configuration.local([Car.schema], isReadOnly: true);
  final realm = Realm(config);
  return realm;
}

  • 1
  • 2
  • 3
  • 4
  • 5
FIFO

创建一些轻量级的FIFO特殊文件,用于协调跨线程和进程对领域的访问

  ///创建一些轻量级的FIFO特殊文件,用于协调跨线程和进程对领域的访问
  Realm fiFoRealm = openFifoRealm();

  • 1
  • 2
Realm openFifoRealm() {
  final config =
      Configuration.local([Car.schema], fifoFilesFallbackPath: "./fifo_folder");
  final realm = Realm(config);
  return realm;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
初始化
  ///初始化数值，无需realm.write(),只能是第一次执行时会执行
  ///之前打开过，都不会再执行
  Realm realm = initDataAddRealm();
  RealmResults cars = realm.all<Car>();
  print(cars.length);

  • 1
  • 2
  • 3
  • 4
  • 5
Realm initDataAddRealm() {
  final config = Configuration.local([Car.schema], initialDataCallback: dataCb);
  final realm = Realm(config);
  return realm;
}

void dataCb(Realm realm) {
  realm.add(Car('Honda'));
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
数据库存储文件的默认存储路径
///自定义数据库存储文件的默认存储路径和数据库文件的默认文件
///地址：/Users/~/FlutterProject/bilibili_getx/myRealmName.realm
configureDefaultRealmName();

  • 1
  • 2
  • 3
void configureDefaultRealmName() async {
  Configuration.defaultRealmName = "myRealmName.realm";
  final customDefaultRealmPath = path.join(
    (await Directory.systemTemp.createTemp()).path,
    Configuration.defaultRealmName,
  );
  Configuration.defaultRealmName = customDefaultRealmPath;
  final config = Configuration.local([Car.schema]);
  print("地址：${config.path}");
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
查看存储文件的位置
void checkDefaultStoragePath() {
  final storagePath = Configuration.defaultStoragePath;
  print("默认存储路径地址：${storagePath}");
}

  • 1
  • 2
  • 3
  • 4
  ///查看存储文件的位置
  ///默认存储路径地址：/Users/~/FlutterProject/bilibili_getx
  checkDefaultStoragePath();

  • 1
  • 2
  • 3
复制数据库
///复制数据到新的数据库
  copyRealmToNewRealm();

  • 1
  • 2
///复制数据到新的数据库
///realm.writeCopy()注意事项
///目标文件不能已经存在
///不允许在写入事务中或迁移期间复制领域
///使用设备同步时，您必须在写入副本之前将所有本地更改与服务器同步。
///这确保了该文件可以用作新安装应用程序的起点。如果有待上传，Realm.writeCopy()会抛出
void copyRealmToNewRealm() {
  final inMemoryRealm =
      Realm(Configuration.inMemory([Car.schema], path: 'inMemory.realm'));
  inMemoryRealm.write(() {
    inMemoryRealm.addAll<Car>([
      Car("baoMa"),
      Car("benChi"),
      Car("jiLi"),
    ]);
  });
  final localConfig = Configuration.local([Car.schema]);
  inMemoryRealm.writeCopy(localConfig);
  inMemoryRealm.close();
  final localRealm = Realm(localConfig);
  final result = localRealm.all<Car>();
  print(result.length);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
复制数据库带key
  ///复制数据库并带有加密密钥
  copyRealmToNewRealmWithKey();

  • 1
  • 2
///复制数据库并带有加密密钥
void copyRealmToNewRealmWithKey() {
  final unencryptedRealm =
      Realm(Configuration.local([Car.schema], path: 'unencryptedRealm.realm'));
  unencryptedRealm.write(() => unencryptedRealm.addAll<Car>([
        Car("blueCar"),
        Car("redCar"),
        Car("greenCar"),
      ]));
  final key = List<int>.generate(64, (index) => Random().nextInt(256));
  final encryptedConfig = Configuration.local(
    [Car.schema],
    path: 'encrypted.realm',
    encryptionKey: key,
  );
  unencryptedRealm.writeCopy(encryptedConfig);
  unencryptedRealm.close();
  final encryptedRealm = Realm(encryptedConfig);
  final result = encryptedRealm.all<Car>();
  print(result.length);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

1.3.7 数据库读写操作

接下来使用到的Model

import 'package:realm/realm.dart';

part 'realm_read_write_model.g.dart';

@RealmModel()
class _Person {
  ///主键
  @PrimaryKey()
  late ObjectId id;
  late String name;
}

@RealmModel()
class _Team {
  ///主键
  @PrimaryKey()
  late ObjectId id;
  late String name;
  late List<_Person> crew;
}

@RealmModel()
class _Rug {
  ///全文搜索
  @Indexed(RealmIndexType.fullText)
  late String pattern;
  @Indexed(RealmIndexType.fullText)
  late String material;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
按主键查询

Realm.find()

///Realm.find(primaryKey) 根据主键查找对象
void findObjectByPrimaryKey() {
  ObjectId objectId = ObjectId();
  Person person = Person(objectId, "Jack");
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.add<Person>(person));

  ObjectId lukePrimaryKey = objectId;
  Person? thisPerson = RealmUtil().realmInstance?.find<Person>(lukePrimaryKey);
  //Jack
  print(thisPerson?.name);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
查询指定类型的所有数据

Realm.all()

void findAll() {
  RealmUtil().realmInstance?.write<Person?>(() {
    RealmUtil().realmInstance?.add(Person(ObjectId(), "Jack"));
    return null;
  });
  final people = RealmUtil().realmInstance?.all<Person>();
  //Jack
  for (var item in people!) {
    print(item.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
列表筛选

RealmList.query()

///RealmList.query()
void queryRealmObjects() {
  final heroes = Team(
    ObjectId(),
    'Millennium Falcon Crew',
    crew: [
      Person(ObjectId(), 'Luke'),
      Person(ObjectId(), 'Leia'),
      Person(ObjectId(), 'Han'),
      Person(ObjectId(), 'Chewbacca'),
    ],
  );
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.add<Team>(heroes));
  final lukeAndLeia = heroes.crew.query('name BEGINSWITH \$0', ['L']);
  // Luke
  // Leia
  for (var item in lukeAndLeia) {
    print(item.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
条件查询

Realm.query()

///Realm.query 条件查询
void queryRealm() {
  final team = RealmUtil()
      .realmInstance
      ?.query<Team>(r'name == $0', ['Millennium Falcon Crew']).first;
  // Millennium Falcon Crew
  print(team?.name);
  final humanCrewMembers = team?.crew.query(r'name != $0', ['Chewbacca']);
  // Luke
  // Leia
  // Han
  for (var item in humanCrewMembers!) {
    print(item.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
全文搜索

属性标注**@Indexed(RealmIndexType.fullText)**

///全文搜索
void queryFTS() {
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add(Rug("chevron", "sheep"));
    RealmUtil().realmInstance?.add(Rug("chevron", "wool"));
  });

  final chevronRugs = RealmUtil().realmInstance?.query<Rug>(
    "pattern TEXT \$0",
    ["chevron"],
  );
  // 2
  print(chevronRugs?.length);
  final notSheepWoolRugs = RealmUtil().realmInstance?.query<Rug>(
    "material TEXT \$0",
    ["-sheep wool"],
  );
  // 1
  print(notSheepWoolRugs?.length);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
排序

Realm.query() + RQL 排序 TRUEPREDICATE SORT(name ASC)

///排序 RQL
void sort() {
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.deleteAll<Person>();
    RealmUtil().realmInstance?.addAll<Person>([
      Person(ObjectId(), 'Luke'),
      Person(ObjectId(), 'Leia'),
      Person(ObjectId(), 'Han'),
      Person(ObjectId(), 'Chewbacca'),
    ]);
  });
  final alphabetizedPeople =
      RealmUtil().realmInstance?.query<Person>('TRUEPREDICATE SORT(name ASC)');
  // Chewbacca
  // Han
  // Leia
  // Luke
  for (var person in alphabetizedPeople!) {
    print(person.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
限制查询的个数

LIMIT(number)

///限制查询的个数
void limitResult() {
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.addAll([
      Person(ObjectId(), 'Luke'),
      Person(ObjectId(), 'Luke'),
      Person(ObjectId(), 'Luke'),
      Person(ObjectId(), 'Luke'),
    ]);
  });
  final limitedPeopleResults = RealmUtil()
      .realmInstance
      ?.query<Person>('name == \$0 LIMIT(2)', ['Luke']);
  // 2
  print(limitedPeopleResults?.length);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
写操作
///写操作
///RealmObjects已经写入Realm，将无法写入另一个Realm
void writeRealm() {
  RealmUtil().realmInstance?.write<Person?>(() {
    RealmUtil().realmInstance?.deleteAll<Person>();
    return RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), 'Yoda'));
  });
  RealmResults<Person>? results = RealmUtil().realmInstance?.all<Person>();
  // Yoda
  for (var item in results!) {
    print(item.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
创建对象/创建多个对象

Realm.addAll() / Realm.add()

///创建对象/创建多个对象
void addObjects() {
  RealmUtil().realmInstance?.write<Person?>(() {
    RealmUtil().realmInstance?.deleteAll<Person>();
    RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), 'Lando'));
    RealmUtil().realmInstance?.addAll<Person>([
      Person(ObjectId(), 'Figrin D\'an'),
      Person(ObjectId(), 'Greedo'),
      Person(ObjectId(), 'Toro'),
    ]);
    return null;
  });

  RealmResults<Person>? results = RealmUtil().realmInstance?.all<Person>();
  // Lando
  // Figrin D'an
  // Greedo
  // Toro
  for (var item in results!) {
    print(item.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
更新对象属性

RealmObject + Realm.write()

///更新对象属性
void updateObject() {
  RealmUtil().realmInstance?.write<Team?>(() {
    RealmUtil().realmInstance?.add<Team>(Team(
          ObjectId(),
          'Spaceship Team',
          crew: [Person(ObjectId(), 'Jack')],
        ));
    return null;
  });

  ///更新对象的属性
  RealmResults<Team>? results =
      RealmUtil().realmInstance?.query<Team>(r'name == $0', ['Spaceship Team']);
  Team? spaceshipTeam = results?.first;
  RealmUtil().realmInstance?.write(() {
    spaceshipTeam?.name = 'Galactic Republic Scout Team';
    spaceshipTeam?.crew.addAll([
      Person(ObjectId(), 'Luke'),
      Person(ObjectId(), 'Leia'),
    ]);
  });
  RealmResults<Team>? modifiedResults = RealmUtil()
      .realmInstance
      ?.query<Team>(r'name == $0', ['Galactic Republic Scout Team']);
  // Galactic Republic Scout Team
  // crew:
  // Jack
  // Luke
  // Leia
  for (var item in modifiedResults!) {
    print(item.name);
    print("crew:");
    for (var it in item.crew) {
      print(it.name);
    }
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
更新拥有主键的对象属性

Realm.add(object, update: true)

///Realm.add(_,update:true) update属性->更新拥有主键的对象
void updatePrimaryKeyRealmObject() {
  final id = ObjectId();
  final anakin = Person(id, "Anakin Skywalker");
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.add<Person>(anakin));
  final darthVader = Person(id, 'Darth Vader');
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.add(darthVader, update: true));
  Person? person = RealmUtil().realmInstance?.find<Person>(id);
  // Darth Vader
  print(person?.name);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
删除单个对象

Realm.delete()

///删除单个对象
void deleteObject() {
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), "Jack"));
  });
  RealmResults<Person>? results1 =
      RealmUtil().realmInstance?.query<Person>(r'name == $0', ["Jack"]);
  Person jackPerson = results1!.first;
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.delete<Person>(jackPerson));
  RealmResults<Person>? results = RealmUtil().realmInstance?.all<Person>();
  // 0
  print(results?.length);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
删除多个对象

Realm.deleteMany()

///删除多个对象
void deleteObjects() {
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), "Jack"));
    RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), "Lucy"));
  });
  RealmResults<Person>? results1 =
      RealmUtil().realmInstance?.query<Person>(r'name == $0', ["Jack"]);
  RealmResults<Person>? results2 =
      RealmUtil().realmInstance?.query<Person>(r'name == $0', ["Lucy"]);
  Person jackPerson = results1!.first;
  Person lucyPerson = results2!.first;
  RealmUtil().realmInstance?.write(() =>
      RealmUtil().realmInstance?.deleteMany<Person>([jackPerson, lucyPerson]));
  RealmResults<Person>? results = RealmUtil().realmInstance?.all<Person>();
  // 0
  print(results?.length);
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
删除所有对象

Realm.deleteAll()

///删除所有对象
void deleteAllObjects() {
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), "Jack"));
    RealmUtil().realmInstance?.add<Person>(Person(ObjectId(), "Lucy"));
  });
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.deleteAll<Person>());
  RealmResults<Person>? results = RealmUtil().realmInstance?.all<Person>();
  // 0
  print(results?.length);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
异步写操作

Realm.writeAsync()

///Realm.writeAsync() 异步写操作,不阻塞主进程进行的时间
void syncWrite() {
  Person leia = Person(ObjectId(), "Leia");
  RealmUtil()
      .realmInstance
      ?.writeAsync<Person?>(() => RealmUtil().realmInstance?.add<Person>(leia));
  RealmResults<Person>? results = RealmUtil().realmInstance?.all<Person>();

  ///不会输出Leia，因为此时writeAsync还未执行完成
  for (var item in results!) {
    print(item.name);
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

1.3.8 监听Realm

监听RealmResults
// RealmResultsChanges
void listenChangesOnRealmResults() {
  final frodo = Character(ObjectId(), 'Frodo', 'Hobbit', 51);
  final samwise = Character(ObjectId(), 'Samwise', 'Hobbit', 39);
  final gollum = Character(ObjectId(), 'Gollum', 'Hobbit', 589);
  final aragorn = Character(ObjectId(), 'Aragorn', 'Human', 87);
  final legolas = Character(ObjectId(), 'Legolas', 'Elf', 2931);
  final gimli = Character(ObjectId(), 'Gimli', 'Dwarf', 140);
  final fellowshipOfTheRing = Fellowship(
    ObjectId(),
    'Fellowship of the Ring',
    members: [frodo, samwise, gollum, aragorn, legolas, gimli],
  );
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<Fellowship>(fellowshipOfTheRing);
    RealmUtil().realmInstance?.add<Character>(gollum);
  });

  final characters = RealmUtil().realmInstance?.all<Character>();
  final subscription = characters?.changes.listen((event) {
    event.inserted; //此版本中添加的新集合中的索引
    event.modified; //此版本中修改的新集合中对象的索引
    event.deleted; //之前版本的集合中已从这个版本中删除的索引
    event.newModified; //考虑删除和插入后修改对象的索引
    event.moved; //移动的集合中对象的索引
    event.results; //正在监听结果收集的变化
  });
  final hobbits =
      fellowshipOfTheRing.members.query(r'species == $0', ['Hobbit']);
  final hobbitsSubscription = hobbits.changes.listen((event) {
    print(event.inserted);
    print(event.modified);
    print(event.deleted);
    print(event.newModified);
    print(event.moved);
    print(event.results);
  });
  print(hobbits.changes.isEmpty); // 判断结果是否为空
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.delete<Character>(hobbits.first);
  });
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
监听RealmObject
// RealmObjectChanges
void listenChangesOnRealmObject() {
  final frodo = Character(ObjectId(), 'Frodo', 'Hobbit', 51);
  RealmUtil()
      .realmInstance
      ?.write(() => RealmUtil().realmInstance?.add<Character>(frodo));
  final frodoSubscription = frodo.changes.listen((event) {
    event.isDeleted; // 如果对象被删除则为true
    event.object; // 正在监控变更的Realm对象
    event.properties; // 已更改的Realm对象属性的名称
  });
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
监听RealmList / RealmSet
// 监听RealmList
void listenChangesOnRealmListAndRealmSet() {
  final frodo = Character(ObjectId(), 'Frodo', 'Hobbit', 51);
  final samwise = Character(ObjectId(), 'Samwise', 'Hobbit', 39);
  final gollum = Character(ObjectId(), 'Gollum', 'Hobbit', 589);
  final aragorn = Character(ObjectId(), 'Aragorn', 'Human', 87);
  final legolas = Character(ObjectId(), 'Legolas', 'Elf', 2931);
  final gimli = Character(ObjectId(), 'Gimli', 'Dwarf', 140);
  final fellowshipOfTheRing = Fellowship(ObjectId(), 'Fellowship of the Ring',
      members: [frodo, samwise, gollum, aragorn, legolas, gimli]);
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<Fellowship>(fellowshipOfTheRing);
  });
  final fellowshipSubscription =
      fellowshipOfTheRing.members.changes.listen((event) {
    event.inserted; // 此版本中添加的新列表中项目的索引
    event.modified; // 在此版本中修改的新列表中项目的索引
    event.deleted; // 列表中先前版本中已从该版本中删除的项目索引
    event.newModified; // 考虑删除和插入后修改项目的索引
    event.moved; // 列表中移动的项目的索引
    event.list; // 监听RealmList或者RealmSet
    event.isCleared; // RealmList.clear()或者RealmSet.clear()则返回true
  });
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
暂停监听 / 恢复监听 / 取消监听
/// 暂停监听流
void pauseSubscription(StreamSubscription subscription) {
  subscription.pause(); //暂停监听流
}

///继续监听流
void resumeSubscription(StreamSubscription subscription) {
  subscription.resume(); //继续监听流
}

/// 取消监听流
void cancelSubscription(StreamSubscription subscription) async {
  await subscription.cancel(); // 取消订阅监听流
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

1.3.9 冻结数据

冻结Realm
///冻结Realm
void freezeRealm() {
  ///初始化数据
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<RealmFreezeModel>(RealmFreezeModel("one"));
  });

  ///冻结Realm
  final frozenRealm = RealmUtil().realmInstance?.freeze();

  ///更新数据
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.add<RealmFreezeModel>(RealmFreezeModel("two"));
  });

  final RealmResults<RealmFreezeModel>? results =
      frozenRealm?.all<RealmFreezeModel>();
  print("冻结Realm");
  // one
  for (var item in results!) {
    print(item.text);
  }

  ///完成冻结的工作后，必须关闭Realm，否则会内存泄漏
  frozenRealm?.close();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
冻结RealmResult
void freezeRealmResults() {
  /// 初始化数据
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.deleteAll<RealmFreezeModel>();
    RealmUtil().realmInstance?.add<RealmFreezeModel>(RealmFreezeModel("one"));
  });

  ///冻结RealmResults
  RealmResults<RealmFreezeModel>? results =
      RealmUtil().realmInstance?.all<RealmFreezeModel>();
  final frozenRealmResults = results?.freeze();

  ///更新数据
  RealmUtil().realmInstance?.write(() {
    results?.forEach((element) {
      element.text = "1";
    });
  });

  final queryResult = frozenRealmResults?.query(r'text == $0', ["1"]);
  // 0
  print(queryResult?.length);

  ///关闭
  frozenRealmResults?.realm.close();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
冻结RealmObject
void freezeRealmObject() {
  /// 初始化数据
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.deleteAll<RealmFreezeModel>();
    RealmUtil().realmInstance?.add<RealmFreezeModel>(RealmFreezeModel("one"));
  });

  ///冻结realmObject
  final realmObject = RealmUtil().realmInstance?.all<RealmFreezeModel>().first;
  final frozenRealmObject = realmObject?.freeze();

  ///更改数据
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.delete<RealmFreezeModel>(realmObject!);
  });

  // false
  print(realmObject?.isValid);
  // true
  print(frozenRealmObject?.isValid);

  ///关闭
  frozenRealmObject?.realm.close();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
冻结RealmObject的RealmList
///冻结RealmObject中的RealmList
void freezeRealmListInRealmObject() {
  ///初始化数据
  RealmUtil().realmInstance?.write(() {
    RealmUtil().realmInstance?.deleteAll<RealmFreezeModel>();
    RealmUtil().realmInstance?.add<RealmFreezeModel>(RealmFreezeModel(
          "One",
          attributes: ["1", "2"],
        ));
  });

  ///冻结RealmObject的RealmList
  RealmResults<RealmFreezeModel>? results =
      RealmUtil().realmInstance?.all<RealmFreezeModel>();
  final firstResult = results?.first;
  final firstResultRealmList = firstResult?.attributes.freeze();
  RealmUtil().realmInstance?.write(() {
    firstResult?.attributes.add("3");
  });
  final index = firstResultRealmList?.indexOf("3");

  /// -1
  print(index);

  ///关闭
  firstResultRealmList?.realm.close();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
检查数据是否被冻结
/// 检查数据是否被冻结
void checkIfFrozen(dynamic object) {
  if (object is Realm) {
    print(object.isFrozen);
  } else if (object is RealmResults) {
    print(object.isFrozen);
  } else if (object is RealmObject) {
    print(object.isFrozen);
  } else if (object is RealmList) {
    print(object.isFrozen);
  } else if (object is RealmSet) {
    print(object.isFrozen);
  } else {
    print("not type");
  }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

1.3.10 管理Realm File

加载一个本地的Realm文件
  • 创建bundle.realm
///创建出接下来要绑定的Realm文件
void bundlingRealm() {
  print("Bundling realm");
  final config =
      Configuration.local([ManageRealmModel.schema], path: 'bundle.realm');
  final realm = Realm(config);
  realm.write(() {
    realm.add(ManageRealmModel(ObjectId(), "Audi", model: 'A8'));
    realm.add(ManageRealmModel(ObjectId(), "Mercedes", model: 'G Wagon'));
  });
  print("Bundled realm location: ${realm.config.path}");
  realm.close();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 通过assets获取bundle.realm文件
main() async {
  deleteRealm();
  // bundlingRealm();
  WidgetsFlutterBinding.ensureInitialized();
  final realm = await initBundleRealm("assets/realm/bundle.realm");
  RealmResults<ManageRealmModel> results = realm.all<ManageRealmModel>();
  // text is Audi. id is 64e010937e233d7efa3fcf2f. model is A8
  // text is Mercedes. id is 64e010937e233d7efa3fcf30. model is G Wagon
  for (var item in results) {
    print("text is ${item.text}. id is ${item.id}. model is ${item.model}");
  }
}
///删除Realm
void deleteRealm() {
  final path = RealmUtil().realmInstance?.config.path;
  RealmUtil().realmInstance?.close();

  ///删除前先关闭realm
  Realm.deleteRealm(path!);
}

///创建出接下来要绑定的Realm文件
void bundlingRealm() {
  print("Bundling realm");
  final config =
      Configuration.local([ManageRealmModel.schema], path: "default.realm");
  final realm = Realm(config);
  realm.write(() {
    realm.add(ManageRealmModel(ObjectId(), "Audi", model: 'A8'));
    realm.add(ManageRealmModel(ObjectId(), "Mercedes", model: 'G Wagon'));
  });
  print("Bundled realm location: ${realm.config.path}");
  // realm.close();
}

Future<Realm> initBundleRealm(String assetKey) async {
  final config = Configuration.local([ManageRealmModel.schema]);
  final file = File(config.path);
  if (!await file.exists()) {
    final realmBytes = await rootBundle.load(assetKey);
    await file.writeAsBytes(
      realmBytes.buffer
          .asUint8List(realmBytes.offsetInBytes, realmBytes.lengthInBytes),
      mode: FileMode.write,
    );
  }
  return Realm(config);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
flutter:
  assets:
    - assets/realm/

  • 1
  • 2
  • 3
加载sync Realm

1.3.11 压缩Realm文件

import 'package:bilibili_getx/core/realm/realm_study/realm_compact/car_model.dart';
import 'package:realm/realm.dart';

main() {
  final config = Configuration.local([Car.schema],
      shouldCompactCallback: ((totalSize, usedSize) {
    const tenMB = 10 * 1048576;
    //如果文件超过10MB，少于50%的使用
    return (totalSize > tenMB) &&
        (usedSize.toDouble() / totalSize.toDouble()) < .5;
  }));
  final compacted = Realm.compact(config);
  print("Successfully compacted the realm: $compacted");
  final realm = Realm(config);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

1.3.12 加密Realm

提供64字节加密密钥，使用AES-256+SHA-2加密磁盘上的Realm

import 'package:realm/realm.dart';

import 'car_model.dart';

main() {
  // Realm.deleteRealm("encryptedRealm.realm");
  final key = List<int>.generate(64, (i) => 1);
  final encryptedConfig = Configuration.local([Car.schema],
      encryptionKey: key, path: "encryptedRealm.realm");
  final encryptedRealm = Realm(encryptedConfig);
  print(key);
  print(encryptedRealm.config.path);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

1.3.13 Realm数据库介绍

本节原文

原生数据库引擎

底层存储使用B+树

存储文件
  • default.realm 领域文件（包含对象数据）
  • default.realm.lock 锁定文件（跟踪一个领域中正在积极使用的数据版本。这可以防止领域回收客户端应用程序仍然使用的存储空间）
  • default.realm.note 注释文件（启用线程间和进程间通知）
  • default.realm.management 管理文件（内部状态管理）

1.3.14 Atlas Service

本节原文

连接APP Service

注册登录MongoDB Atlas APP Service
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

import 'package:realm/realm.dart';

main() {
  ///连接APP Service
  connectAppService();

}

///连接APP Service
void connectAppService() {
  String appId = "mytestapplication-iycfu";
  final appConfig = AppConfiguration(
    appId,
    defaultRequestTimeout: const Duration(seconds: 120),
    localAppVersion: '2.0',
  );
  final app = App(appConfig);
  print(app.id);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号