flutter 本地缓存shared_preferences、flutter_secure_storage的封装 (全网最新)

创建 flutter 项目，并添加依赖包

# 应用依赖的包
dependencies:
  flutter:
    sdk: flutter
  cupertino_icons: ^1.0.6
  dio: ^5.4.3+1 # 网络插件
  shared_preferences: ^2.2.3 # 本地存储：官方维护的插件
  flutter_secure_storage: ^9.2.2 # 本地存储(加密)：第三方维护的插件

封装的组件为：local_storage_utils.dart

import 'dart:convert';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:shared_preferences/shared_preferences.dart';

/// SharedPreferences 插件的缓存数据工具： 对 SharedPreferences 封装的工具
class SharedPreferencesUtil {
  /// 设置数据: value类型可以是 String int double bool map
  static Future<bool> set(String key, dynamic value) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();

    /// 如果 value 的类型是 Map 和 List,则转换成 JSON字符串进行存储
    if (value is Map<String, dynamic> || value is List<dynamic>) {
      return prefs.setString(key, jsonEncode(value));
    }

    /// 根据 value 不同的类型,用不同的方法进行存储
    return switch (value.runtimeType) {
      String => prefs.setString(key, value),
      int => prefs.setInt(key, value),
      double => prefs.setDouble(key, value),
      bool => prefs.setBool(key, value),
      _ => Future<bool>.value(false) // 其他类型的，不支持存储,直接返回false
    };
  }

  /// 获取 String 数据, 获取数据为空，则返回默认值 "",判断使用 isEmpty 来判断
  static Future<String> getString(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    return prefs.getString(key) ?? "";
  }

  /// 获取 bool 数据
  static Future<bool> getBool(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    return prefs.getBool(key) ?? false;
  }

  /// 获取 int 数据, 获取数据为空，则返回默认值0
  static Future<int> getInt(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    return prefs.getInt(key) ?? 0;
  }

  /// 获取 double 数据, 获取数据为空，则返回默认值 0.0
  static Future<double> getDouble(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    return prefs.getDouble(key) ?? 0.0;
  }

  /// 获取 map 数据,获取数据为空，则返回默认值{},判断使用 isEmpty 来判断
  static Future<Map<String, dynamic>> getMap(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    var value = prefs.getString(key);
    if (value == null) {
      return {};
    }
    return jsonDecode(value);
  }

  /// 获取 list 数据,获取数据为空，则返回默认值[],判断使用 isEmpty 来判断
  static Future<List<dynamic>> getList(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    var value = prefs.getString(key);
    if (value == null) {
      return [];
    }
    return const JsonDecoder().convert(value) as List<dynamic>;
  }

  /// 删除数据
  static Future<bool> remove(String key) async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    return await prefs.remove(key);
  }

  /// 获取令牌
  static Future<String> getToken() async {
    return await getString("token");
  }

  /// 设置令牌
  static Future<bool> setToken(String tokenValue) async {
    return await set("token", tokenValue);
  }

  /// 移除令牌
  static Future<bool> removeToken() async {
    return await remove("token");
  }

  /// 清理所有缓存信息
  static Future<bool> removeAll() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();
    var keys = prefs.getKeys();
    // dart 官方推荐使用循环方式，不推荐使用.forEach()
    for (String key in keys) {
      await remove(key);
    }
    return true;
  }
}

/// flutter_secure_storage 插件的缓存数据工具： 对 flutter_secure_storage 封装的工具
class FlutterSecureStorageUtil {
  static const _instance = FlutterSecureStorage();

  /// 设置数据: value类型可以是 String int double bool map
  static Future<bool> set(String key, dynamic value) async {
    try {
      /// 如果 value 的类型是 Map 和 List,则转换成 JSON字符串进行存储
      if (value is Map<String, dynamic> || value is List<dynamic>) {
        await _instance.write(key: key, value: jsonEncode(value));
      } else {
        await _instance.write(key: key, value: value.toString());
      }
      return true;
    } catch (e) {
      return false;
    }
  }

  /// 获取 String 数据, 获取数据为空，则返回默认值 "",判断使用 isEmpty 来判断
  static Future<String> get(String key) async {
    return await _instance.read(key: key) ?? "";
  }

  /// 获取 bool 数据
  static Future<bool> getBool(String key) async {
    var value = await _instance.read(key: key);
    if (value == null) {
      return false;
    }
    return value.toLowerCase() == "true";
  }

  /// 获取 int 数据, 获取数据为空，则返回默认值0
  static Future<int> getInt(String key) async {
    var value = await _instance.read(key: key);
    if (value == null) {
      return 0;
    }

    /// int.tryParse 尝试将 string 串转为 int
    /// print(int.tryParse('2021')); // 2021
    /// print(int.tryParse('1f')); // null
    /// 获取数据为空，则返回默认值0
    return int.tryParse(value) ?? 0;
  }

  /// 获取 double 数据, 获取数据为空，则返回默认值 0.0
  static Future<double> getDouble(String key) async {
    var value = await _instance.read(key: key);
    if (value == null) {
      return 0.0;
    }

    /// double.tryParse 尝试将 string 串转为 double
    /// 获取数据为空，则返回默认值0.0
    return double.tryParse(value) ?? 0.0;
  }

  /// 获取 map 数据,获取数据为空，则返回默认值{},判断使用 isEmpty 来判断
  static Future<Map<String, dynamic>> getMap(String key) async {
    var value = await _instance.read(key: key);
    if (value == null) {
      return {};
    }
    return jsonDecode(value);
  }

  /// 获取 list 数据,获取数据为空，则返回默认值[],判断使用 isEmpty 来判断
  static Future<List<dynamic>> getList(String key) async {
    var value = await _instance.read(key: key);
    if (value == null) {
      return [];
    }
    return const JsonDecoder().convert(value) as List<dynamic>;
  }

  /// 删除数据
  static Future<bool> remove(String key) async {
    try {
      await _instance.delete(key: key);
      return true;
    } catch (e) {
      return false;
    }
  }

  /// 清理所有缓存信息
  static Future<bool> removeAll() async {
    try {
      await _instance.deleteAll();
      return true;
    } catch (e) {
      return false;
    }
  }

  /// 获取令牌
  static Future<String> getToken() async {
    return await get("token");
  }

  /// 设置令牌
  static Future<bool> setToken(String tokenValue) async {
    return await set("token", tokenValue);
  }

  /// 移除令牌
  static Future<bool> removeToken() async {
    return await remove("token");
  }
}

测试案列

import 'package:uim_cloud_common/utils/local_storage_utils.dart';
import 'package:flutter/material.dart';

/// 入口
void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      title: '测试',
      home: MyHomePage(title: '测试页面'),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key, required this.title});

  final String title;

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  int _counter = 0;

  void _incrementCounter() {
    setState(() {
      _counter++;
    });

    // sharedPreferencesUtilPrint();
    flutterSecureStorageUtilPrint();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        backgroundColor: Theme.of(context).colorScheme.inversePrimary,
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            const Text(
              'xxx',
            ),
            Text(
              '$_counter',
              style: Theme.of(context).textTheme.headlineMedium,
            ),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: _incrementCounter,
        tooltip: 'Increment',
        child: const Icon(Icons.add),
      ),
    );
  }

  Future<void> sharedPreferencesUtilPrint() async {
    await SharedPreferencesUtil.set("key1", 1);
    await SharedPreferencesUtil.set("key2", 1.54);
    await SharedPreferencesUtil.set("key3", true);
    await SharedPreferencesUtil.set("key4", "张三");
    const list = <String>["张三", "李四", "王五"];
    await SharedPreferencesUtil.set("key5", list);

    const map = <String, String>{
      "zhangsan": "张三",
      "lisi": "李四",
      "wangwu": "王五"
    };
    await SharedPreferencesUtil.set("key6", map);

    print(await SharedPreferencesUtil.getInt("key1"));
    print(await SharedPreferencesUtil.getDouble("key2"));
    print(await SharedPreferencesUtil.getBool("key3"));
    print(await SharedPreferencesUtil.getString("key4"));
    print(await SharedPreferencesUtil.getList("key5"));
    print(await SharedPreferencesUtil.getMap("key6"));
    print(await SharedPreferencesUtil.remove("key7"));
  }

  Future<void> flutterSecureStorageUtilPrint() async {
    await FlutterSecureStorageUtil.set("key1", 1);
    await FlutterSecureStorageUtil.set("key2", 1.54);
    await FlutterSecureStorageUtil.set("key3", true);
    await FlutterSecureStorageUtil.set("key4", "张三");
    const list = <String>["张三", "李四", "王五"];
    await FlutterSecureStorageUtil.set("key5", list);

    const map = <String, String>{
      "zhangsan": "张三",
      "lisi": "李四",
      "wangwu": "王五"
    };
    await FlutterSecureStorageUtil.set("key6", map);

    print(await FlutterSecureStorageUtil.getInt("key1"));
    print(await FlutterSecureStorageUtil.getDouble("key2"));
    print(await FlutterSecureStorageUtil.getBool("key3"));
    print(await FlutterSecureStorageUtil.get("key4"));
    print(await FlutterSecureStorageUtil.getList("key5"));
    print(await FlutterSecureStorageUtil.getMap("key6"));

    print(await FlutterSecureStorageUtil.getInt("key4"));

    print(await FlutterSecureStorageUtil.remove("key7"));
    print(await FlutterSecureStorageUtil.removeAll());
  }
}