使用encrypt包加解密数据性能慢，求代码优化最佳方案

看起来你遇到的问题是频繁加解密拖慢了应用运行和UI展示速度——这根源其实是你的代码里每次调用加解密函数都在重复初始化加密核心对象（Key、IV、Encrypter），这些对象的创建是有开销的，反复调用自然会浪费资源、拖慢速度。下面是针对性的优化方案，都是实际项目里验证过的：

1. 复用加密核心实例（最关键的优化） #

把Key、IV、Encrypter这些初始化成本高的对象提前创建好，只做一次初始化，后续加解密直接复用。我建议封装成一个单例工具类，这样整个APP里都能共用同一个实例：

步骤1：封装加密工具单例 #

import 'package:encrypt/encrypt.dart';
import 'dart:convert';
import 'dart:typed_data';

class CryptoUtils {
  late final Key _key;
  late final IV _iv;
  late final Encrypter _encrypter;

  // 单例模式，确保全局只有一个实例
  static final CryptoUtils _instance = CryptoUtils._internal();

  factory CryptoUtils(List<int> strKey) {
    _instance._init(strKey);
    return _instance;
  }

  CryptoUtils._internal();

  // 只初始化一次加密配置
  void _init(List<int> strKey) {
    // Key只做一次base64编码和转换，不用每次加解密都重复处理
    final keyBase64 = base64Encode(Uint8List.fromList(strKey));
    _key = Key.fromBase64(keyBase64);
    // 固定IV提前初始化，避免反复调用fromUtf8
    _iv = IV.fromUtf8('utf8_string');
    // Encrypter实例只创建一次，这是性能提升的核心
    _encrypter = Encrypter(AES(_key, mode: AESMode.cbc));
  }

  String encrypt(String plainText) {
    try {
      final encrypted = _encrypter.encrypt(plainText, iv: _iv);
      return encrypted.base64;
    } catch (ex) {
      print('CRYPError===${ex}');
      return plainText;
    }
  }

  String decrypt(String encryptedBase64) {
    try {
      final encrypted = Encrypted.fromBase64(encryptedBase64);
      final decrypted = _encrypter.decrypt(encrypted, iv: _iv);
      return decrypted;
    } catch (ex) {
      print('DECRYPError===${ex}');
      return encryptedBase64;
    }
  }
}

步骤2：改造Users模型类 #

现在Users类可以直接复用这个工具类的实例，不用每次加解密都重新造轮子：

class Users {
  String? id;
  String? name;
  String? surname;
  // 标记是否已经解密，避免重复解密同一个对象的字段
  bool _isDecrypted = false;

  Users({this.id, this.name, this.surname});

  // 全局初始化加密工具（建议在APP启动时，比如main函数里调用一次就行）
  static late final CryptoUtils _cryptoUtils;

  static void initCrypto(List<int> key) {
    _cryptoUtils = CryptoUtils(key);
  }

  Map<String, Object> toMap() => {
        'id': id ?? '',
        'name': _cryptoUtils.encrypt(name ?? ''),
        'surname': _cryptoUtils.encrypt(surname ?? ''),
      };

  Users.fromMap(Map<String, dynamic> u) {
    id = u['id'];
    // 一次性解密所有字段，避免分散操作
    _decryptFields(u);
  }

  // 统一处理解密，确保只执行一次
  void _decryptFields(Map<String, dynamic> u) {
    if (!_isDecrypted) {
      name = _cryptoUtils.decrypt(u['name'] ?? '');
      surname = _cryptoUtils.decrypt(u['surname'] ?? '');
      _isDecrypted = true;
    }
  }
}

2. 避免在UI线程做批量加解密 #

如果是加载大量用户数据（比如从数据库查出来几十上百条），别在UI线程里逐个解密——会直接导致UI卡顿。把这些批量操作放到后台Isolate里执行：

// 示例：用Isolate批量处理用户解密
Future<List<Users>> loadUsersInBackground(List<Map<String, dynamic>> rawUsers, List<int> key) async {
  // Isolate.run是Flutter 3.0+的便捷API，自动处理线程通信
  return await Isolate.run(() {
    // 在Isolate内部初始化加密工具（因为Isolate有独立内存空间）
    CryptoUtils.initCrypto(key);
    return rawUsers.map((userMap) => Users.fromMap(userMap)).toList();
  });
}

3. 额外小优化点 #

• 检查你的Key长度：AES要求128/192/256位，如果你的strKey长度不符合，encrypt包会自动调整，但会带来额外开销，尽量让Key符合标准长度。
• 延迟解密（可选）：如果某些字段很少被用到，可以把解密逻辑放到getter里，用到的时候再解密，避免不必要的开销。不过这个要根据你的业务场景来判断，大部分情况下一次性解密更省心。

总结 #

最核心的优化就是复用加密核心实例，这能直接砍掉大部分重复初始化的开销。再配合后台线程处理批量操作，基本就能解决你遇到的性能问题了。

内容的提问来源于stack exchange，提问作者FQDEV