关于flutter:Flutter-sharedpreferences的基本使用源码分析封装

81次阅读

共计 12507 个字符，预计需要花费 32 分钟才能阅读完成。

前言

本文是基于官网最新稳固版本 ^2.0.8 进行开发

源代码及视频教程地址

源代码地址

视频教程地址

目标

本文次要对 shared_preferences: ^2.0.8 的作用以及根本应用来进行源码剖析，最终会封装一个比拟通用的类库，因为 2.0 以上版本是空平安，所以前面讲的所有代码以及封装都是基于空平安的。

shared_preferences 介绍

shared_preferences次要的作用是用于将数据 异步长久化到磁盘，因为长久化数据只是存储到长期目录，当 app 删除时该存储的数据就是隐没，web 开发时革除浏览器存储的数据也将隐没。

反对存储类型：

  • bool
  • int
  • double
  • string
  • stringList

shared_preferences 利用场景

次要用于长久化数据，如长久化用户信息、列表数据等。

长久化用户信息

因为用户信息根本是不扭转的，而在一个应用程序中经常会有多个页面须要展现用户信息，咱们不可能每次都去获取接口，那么本地长久化就会变得很不便。

长久化列表数据

为了给用户更好的体验，在获取列表数据时咱们经常会先展现旧数据，带给用户更好的体验，不至于一关上页面就是空白的，当咱们采纳长久化列表数据后，能够间接先展现本地数据，当网络数据申请回来后在进行数据更新。

shared_preferences 应用的对应类库

咱们晓得每个平台长久化数据的形式都不一样，而 shared_preferences 针对不同的平台封装了一个通用的类库，接下来咱们看看不同平台下他们应用的库：

  • iOS： NSUserDefaults
  • Android： SharedPreferences
  • Web： localStorage
  • Linux： FileSystem（保留数据到本地系统文件库中）
  • Mac OS： FileSystem（保留数据到本地系统文件库中）
  • Windows： FileSystem（保留数据到本地系统文件库中）

shared_preferences 根本应用

pubspec.yaml 导入依赖

shared_preferences: ^2.0.8

导入头文件

import 'package:shared_preferences/shared_preferences.dart';

获取实例对象

SharedPreferences? sharedPreferences = await SharedPreferences.getInstance();

设置长久化数据

咱们能够通过 sharedPreferences 的实例化对象调用对应的 set 办法设置长久化数据

SharedPreferences? sharedPreferences;

// 设置长久化数据
void _setData() async {
  // 实例化
  sharedPreferences = await SharedPreferences.getInstance();

  // 设置 string 类型
  await sharedPreferences?.setString("name", "Jimi");

  // 设置 int 类型
  await sharedPreferences?.setInt("age", 18);

  // 设置 bool 类型
  await sharedPreferences?.setBool("isTeacher", true);

  // 设置 double 类型
  await sharedPreferences?.setDouble("height", 1.88);

  // 设置 string 类型的数组
  await sharedPreferences?.setStringList("action", ["吃饭", "睡觉", "打豆豆"]);

  setState(() {});
}

读取长久化数据

咱们能够通过 sharedPreferences 的实例化对象调用对应的 get 办法读取长久化数据

Text("名字: ${sharedPreferences?.getString("name") ??""}",
     style: TextStyle(
       color: Colors.blue,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("年龄: ${sharedPreferences?.getInt("age") ??""}",
     style: TextStyle(
       color: Colors.red,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("是老师吗?: ${sharedPreferences?.getBool("isTeacher") ??""}",
     style: TextStyle(
       color: Colors.orange,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("身高: ${sharedPreferences?.getDouble("height") ??""}",
     style: TextStyle(
       color: Colors.pink,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("我正在: ${sharedPreferences?.getStringList("action") ??""}",
     style: TextStyle(
       color: Colors.purple,
       fontSize: 20
     ),
    ),

残缺代码

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

class SharedPreferencesExample extends StatefulWidget {
  @override
  _SharedPreferencesExampleState createState() => _SharedPreferencesExampleState();
}

class _SharedPreferencesExampleState extends State<SharedPreferencesExample> {


  SharedPreferences? sharedPreferences;

  // 设置长久化数据
  void _setData() async {
    // 实例化
    sharedPreferences = await SharedPreferences.getInstance();

    // 设置 string 类型
    await sharedPreferences?.setString("name", "Jimi");

    // 设置 int 类型
    await sharedPreferences?.setInt("age", 18);

    // 设置 bool 类型
    await sharedPreferences?.setBool("isTeacher", true);

    // 设置 double 类型
    await sharedPreferences?.setDouble("height", 1.88);

    // 设置 string 类型的数组
    await sharedPreferences?.setStringList("action", ["吃饭", "睡觉", "打豆豆"]);

    setState(() {});
  }


  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("SharedPreferences"),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _setData,
        child: Icon(Icons.add),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          crossAxisAlignment: CrossAxisAlignment.center,
          children: [Text("名字: ${sharedPreferences?.getString("name") ??""}",
                 style: TextStyle(
                   color: Colors.blue,
                   fontSize: 20
                 ),
                ),
            SizedBox(height: 20,),
            Text("年龄: ${sharedPreferences?.getInt("age") ??""}",
                 style: TextStyle(
                   color: Colors.red,
                   fontSize: 20
                 ),
                ),
            SizedBox(height: 20,),
            Text("是老师吗?: ${sharedPreferences?.getBool("isTeacher") ??""}",
                 style: TextStyle(
                   color: Colors.orange,
                   fontSize: 20
                 ),
                ),
            SizedBox(height: 20,),
            Text("身高: ${sharedPreferences?.getDouble("height") ??""}",
                 style: TextStyle(
                   color: Colors.pink,
                   fontSize: 20
                 ),
                ),
            SizedBox(height: 20,),
            Text("我正在: ${sharedPreferences?.getStringList("action") ??""}",
                 style: TextStyle(
                   color: Colors.purple,
                   fontSize: 20
                 ),
                ),
          ],
        ),
      ),
    );
  }
}

成果展现

shared_preferences 辅助操作

获取长久化数据中所有存入的 key

List<String> keys = sharedPreferences?.getKeys().toList() ?? [];
print(keys);

// 控制台输入
[name, age, isTeacher, height, action]

判断长久化数据中是否蕴含某个 key

bool isContainKey = sharedPreferences?.containsKey("name") ?? false;
print(isContainKey);

// 控制台输入
flutter: true

删除长久化数据中某个 key

bool isRemoveKey = await sharedPreferences?.remove("name") ?? false;
print(isRemoveKey);

// 控制台输入
flutter: true

革除所有长久化数据

bool isClearAllKey = await sharedPreferences?.clear() ?? false;
print(isClearAllKey);

// 控制台输入
flutter: true

从新加载所有数据（仅重载运行时）

await sharedPreferences?.reload();

shared_preferences 源码剖析

实例化对象源码剖析

接下来咱们来对 shared_preferences 进行剖析，咱们在应用的时候须要通过 getInstance 实例化一个对象，接下来咱们看下这外面它都做了什么操作。

动态变量剖析

咱们先来看下它定义了三个动态变量:

  • _prefix： 设置长久化数据和读取长久化数据时对立设置前缀（flutter.）
  • _completer： 长久化数据异步告诉，就是当 shared_preferences 实例化实现后通过 completer.future 来返回后果
  • _manualDartRegistrationNeeded： 是否须要手动注册，因为波及到 Linux、Windows、Mac Os 的长久化数据时，是须要手动进行注册的，默认为 true
static const String _prefix = 'flutter.';
static Completer<SharedPreferences>? _completer;
static bool _manualDartRegistrationNeeded = true;

getInstance()源码剖析

当咱们获取实例化对象时先判断 _completer 是否为空，如果不为空则间接返回它的的 future 后果，否则它会实例化一个 SharedPreferences 的Completer对象，而后通过 _getSharedPreferencesMap 来获取长久化的 map 对象，获取到 map 对象后，通过 completer.complete(SharedPreferences._(preferencesMap)) 将Map后果返回进来，代码如下：

static Future<SharedPreferences> getInstance() async {if (_completer == null) {final completer = Completer<SharedPreferences>();
    try {
      final Map<String, Object> preferencesMap =
        await _getSharedPreferencesMap();
      completer.complete(SharedPreferences._(preferencesMap));
    } on Exception catch (e) {
      // If there's an error, explicitly return the future with an error.
      // then set the completer to null so we can retry.
      completer.completeError(e);
      final Future<SharedPreferences> sharedPrefsFuture = completer.future;
      _completer = null;
      return sharedPrefsFuture;
    }
    _completer = completer;
  }
  return _completer!.future;
}

_getSharedPreferencesMap()源码剖析

在咱们调用 getInstance() 办法里，会调用 _getSharedPreferencesMap() 来获取长久化的 Map 数据，咱们接下来看看它是如何获取的，首先它通过 _store.getAll() 就能够间接获取到本地的所有长久化数据，当咱们调用 _store 时，它会判断是否须要手动注册

不须要手动注册时：

在 iOS、Android 等平台中应用不须要手动注册，所以它间接就返回的对应的实例对象

须要手动注册时：

先判断是否是 web，如果是就返回localStorage，否则判断是Linux 还是Windows，而后依据平台的不同返回其对应的实例。

static Future<Map<String, Object>> _getSharedPreferencesMap() async {final Map<String, Object> fromSystem = await _store.getAll();
  assert(fromSystem != null);
  // Strip the flutter. prefix from the returned preferences.
  final Map<String, Object> preferencesMap = <String, Object>{};
  for (String key in fromSystem.keys) {assert(key.startsWith(_prefix));
    preferencesMap[key.substring(_prefix.length)] = fromSystem[key]!;
  }
  return preferencesMap;
}

static SharedPreferencesStorePlatform get _store {// TODO(egarciad): Remove once auto registration lands on Flutter stable.
  // https://github.com/flutter/flutter/issues/81421.
  if (_manualDartRegistrationNeeded) {
    // Only do the initial registration if it hasn't already been overridden
    // with a non-default instance.
    if (!kIsWeb &&
        SharedPreferencesStorePlatform.instance
        is MethodChannelSharedPreferencesStore) {if (Platform.isLinux) {SharedPreferencesStorePlatform.instance = SharedPreferencesLinux();
      } else if (Platform.isWindows) {SharedPreferencesStorePlatform.instance = SharedPreferencesWindows();
      }
    }
    _manualDartRegistrationNeeded = false;
  }

  return SharedPreferencesStorePlatform.instance;
}

_setValue()源码剖析

不论咱们是存储什么内容的数据，最终都会调用 _setValue() 来进行存储，

  1. 首先它会查看存入的 value 是否为空，如果为空就抛出异样，否则就用 _prefix + key 来作为存入的 key 值。
  2. 判断存入的值是不是 List<String>, 如果是先把value 通过 toList() 办法转换，而后在存入，否则间接存入，这步存入操作只是存入缓存中，当应用程序退出时将隐没
  3. 最初通过 _store 来异步写入到磁盘中
Future<bool> _setValue(String valueType, String key, Object value) {ArgumentError.checkNotNull(value, 'value');
  final String prefixedKey = '$_prefix$key';
  if (value is List<String>) {
    // Make a copy of the list so that later mutations won't propagate
    _preferenceCache[key] = value.toList();} else {_preferenceCache[key] = value;
  }
  return _store.setValue(valueType, prefixedKey, value);
}

shared_preferences 封装

咱们在应用 shared_preferences 时每次都须要去获取它的实例，如果多个中央用到，那么每次都要实例化一次。这样代码的可读性差，前期的保护老本也变得很高，而且还不反对存储 Map 类型，所以接下来咱们对 shared_preferences 来封装一个通用而且应用更简略的库。

应用单例模式进行 shared_preferences 封装

因为咱们获取的都是同一个实例，所以采纳单例模式来进行封装最好，而且获取实例是异步的，所以咱们在应用程序启动时先初始化，这样应用起来更加的不便。

创立单例类

因为咱们代码都是采纳了空平安，所以空平安外面有个十分重要的属性 late 来提早加载咱们实例，如下：

class JSpUtil {JSpUtil._internal();
  
  factory JSpUtil() => _instance;

  static late final JSpUtil _instance = JSpUtil._internal();}

初始化 shared_preferences

因为采纳单例模式，所以在获取惟一实例的时候咱们在入口对立获取一次即可。

static late SharedPreferences _preferences;

static Future<JSpUtil> getInstance() async {_preferences = await SharedPreferences.getInstance();
  return _instance;
}

封装形式一：对应 get、set 办法

/// 依据 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);
}

封装形式二：对立 set、get 办法

/// 通用设置长久化数据
static setLocalStorage<T>(String key, T value) {String type = value.runtimeType.toString();

  switch (type) {
    case "String":
      setString(key, value as String);
      break;
    case "int":
      setInt(key, value as int);
      break;
    case "bool":
      setBool(key, value as bool);
      break;
    case "double":
      setDouble(key, value as double);
      break;
    case "List<String>":
      setStringList(key, value as List<String>);
      break;
    case "_InternalLinkedHashMap<String, String>":
      setMap(key, value as Map);
      break;
  }
}

/// 获取长久化数据
static dynamic getLocalStorage<T>(String key) {dynamic value = _preferences.get(key);
  if (value.runtimeType.toString() == "String") {if (_isJson(value)) {return json.decode(value);
    }
  }
  return value;
}

其余辅助办法封装

/// 获取长久化数据中所有存入的 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 {JsonDecoder().convert(value);
    return true;
  } catch(e) {return false;}
}

两种封装的应用形式

// 设置 String 类型
await JSpUtil.setString("name", "Jimi");

// 设置 int 类型
await JSpUtil.setInt("age", 18);

// 设置 bool 类型
await JSpUtil.setBool("isTeacher", true);

// 设置 double 类型
await JSpUtil.setDouble("height", 1.88);

// 设置 string 类型的数组
await JSpUtil.setStringList("action", ["吃饭", "睡觉", "打豆豆"]);

// 设置 Map 类型
await JSpUtil.setMap("weight", {"weight": 112});

JSpUtil.setLocalStorage("name", "Jimi");
JSpUtil.setLocalStorage("age", 18);
JSpUtil.setLocalStorage("isTeacher", true);
JSpUtil.setLocalStorage("height", 1.88);
JSpUtil.setLocalStorage("action", ["吃饭", "睡觉", "打豆豆"]);
JSpUtil.setLocalStorage("weight", {"weight": "112"});

JSpUtil.getLocalStorage("name");
JSpUtil.getLocalStorage("age");
JSpUtil.getLocalStorage("isTeacher");
JSpUtil.getLocalStorage("height");
JSpUtil.getLocalStorage("action");
JSpUtil.getLocalStorage("weight");


// 获取磁盘中所有存入的 key
List<String> keys = JSpUtil.getKeys().toList();
print(keys);

// 长久化数据中是否蕴含某个 key
bool isContainKey = JSpUtil.containsKey("name");
print(isContainKey);

// 删除长久化数据中某个 key
bool isRemoveKey = await JSpUtil.remove("name");
print(isRemoveKey);

// 革除所有长久化数据
bool isClearAllKey = await JSpUtil.clear();
print(isClearAllKey);

// 从新加载所有数据, 仅重载运行时
await JSpUtil.reload();

获取值的形式

Text("名字: ${JSpUtil.getString("name")}",
     style: TextStyle(
       color: Colors.blue,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("年龄: ${JSpUtil.getInt("age")}",
     style: TextStyle(
       color: Colors.red,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("是老师吗?: ${JSpUtil.getBool("isTeacher")}",
     style: TextStyle(
       color: Colors.orange,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("身高: ${JSpUtil.getDouble("height")}",
     style: TextStyle(
       color: Colors.pink,
       fontSize: 20
     ),
    ),
SizedBox(height: 20,),
Text("我正在: ${JSpUtil.getStringList("action")}",
     style: TextStyle(
       color: Colors.purple,
       fontSize: 20
     ),
    ),

总结

当咱们须要对数据进行长久化贮存的时候，咱们能够采纳 shared_preferences 来进行贮存到磁盘，这样 app 启动时可拜访贮存后的数据，而且反对存储多种类型。

正文完
flutter
发表至： flutter
2021-09-28
 0
关于flutter:Dart-213-版现已发布
关于flutter:与-Flutter-共创未来-Flutter-Forward-活动精彩回顾
关于flutter:flutter-sliver-多种滚动组合开发指南
Flutter开发之动态权限