Supabase云同步架构：Flutter应用的数据同步策略

Supabase云同步架构：Flutter应用的数据同步策略

本文基于BeeCount(蜜蜂记账)项目的实际开发经验，深入探讨如何使用Supabase构建安全、高效的云端数据同步系统。

项目背景

BeeCount(蜜蜂记账)是一款开源、简洁、无广告的个人记账应用。所有财务数据完全由用户掌控，支持本地存储和可选的云端同步，确保数据绝对安全。

引言

在现代移动应用开发中，多设备数据同步已成为用户的基本需求。用户希望在手机、平板、不同设备间无缝切换，同时保持数据的一致性和安全性。BeeCount选择Supabase作为云端后台服务，不仅因为其开源特性和强大功能，更重要的是它提供了完整的数据安全保障。

Supabase架构优势

开源与自主可控

• 开源透明：完全开源的后台即服务(BaaS)解决方案
• 数据主权：支持自建部署，数据完全可控
• 标准技术：基于PostgreSQL，无厂商锁定风险

功能完整性

• 实时数据库：基于PostgreSQL的实时数据同步
• 用户认证：完整的身份验证和授权系统
• 文件存储：对象存储服务，支持大文件上传
• 边缘函数：服务端逻辑处理能力

同步架构设计

整体架构图

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐ │   Flutter App   │    │   Supabase       │    │   Other Device  │ │  (Local SQLite) │◄──►│  (PostgreSQL)    │◄──►│  (Local SQLite) │ │                 │    │  (Auth + Storage) │    │                 │ └─────────────────┘    └──────────────────┘    └─────────────────┘          │                       │                       │          └───── 加密备份文件 ─────┴───── 加密备份文件 ─────┘ 

核心设计原则

1. 本地优先：所有操作优先在本地完成，确保响应速度
2. 增量同步：只同步变更数据，降低网络开销
3. 端到端加密：敏感数据在客户端加密后上传
4. 冲突处理：合理的冲突解决策略
5. 离线可用：网络异常时应用仍可正常使用

认证系统集成

Supabase认证配置

class SupabaseAuthService implements AuthService {   final s.SupabaseClient client;      SupabaseAuthService({required this.client});    @override   Future<AuthResult> signInWithEmail({     required String email,     required String password,   }) async {     try {       final response = await client.auth.signInWithPassword(         email: email,         password: password,       );              if (response.user != null) {         return AuthResult.success(user: AppUser.fromSupabase(response.user!));       } else {         return AuthResult.failure(error: 'Login failed');       }     } catch (e) {       return AuthResult.failure(error: e.toString());     }   }    @override   Future<AuthResult> signUpWithEmail({     required String email,     required String password,   }) async {     try {       final response = await client.auth.signUp(         email: email,         password: password,       );              return AuthResult.success(user: AppUser.fromSupabase(response.user!));     } catch (e) {       return AuthResult.failure(error: e.toString());     }   }    @override   Stream<AuthState> get authStateChanges {     return client.auth.onAuthStateChange.map((data) {       if (data.session?.user != null) {         return AuthState.authenticated(           user: AppUser.fromSupabase(data.session!.user)         );       }       return AuthState.unauthenticated();     });   } } 

用户模型设计

class AppUser {   final String id;   final String email;   final DateTime? lastSignInAt;    const AppUser({     required this.id,     required this.email,     this.lastSignInAt,   });    factory AppUser.fromSupabase(s.User user) {     return AppUser(       id: user.id,       email: user.email ?? '',       lastSignInAt: user.lastSignInAt,     );   }    bool get isAnonymous => email.isEmpty; } 

数据同步策略

备份文件格式

BeeCount采用加密备份文件的方式进行数据同步：

class BackupData {   final String version;   final DateTime createdAt;   final String deviceId;   final Map<String, dynamic> ledgers;   final Map<String, dynamic> accounts;   final Map<String, dynamic> categories;   final Map<String, dynamic> transactions;      BackupData({     required this.version,     required this.createdAt,     required this.deviceId,     required this.ledgers,     required this.accounts,     required this.categories,     required this.transactions,   });    Map<String, dynamic> toJson() => {     'version': version,     'createdAt': createdAt.toIso8601String(),     'deviceId': deviceId,     'ledgers': ledgers,     'accounts': accounts,     'categories': categories,     'transactions': transactions,   };    factory BackupData.fromJson(Map<String, dynamic> json) {     return BackupData(       version: json['version'],       createdAt: DateTime.parse(json['createdAt']),       deviceId: json['deviceId'],       ledgers: json['ledgers'],       accounts: json['accounts'],       categories: json['categories'],       transactions: json['transactions'],     );   } } 

同步服务实现

class SupabaseSyncService implements SyncService {   final s.SupabaseClient client;   final BeeDatabase db;   final BeeRepository repo;   final AuthService auth;   final String bucket;      // 状态缓存和上传窗口管理   final Map<int, SyncStatus> _statusCache = {};   final Map<int, _RecentUpload> _recentUpload = {};   final Map<int, DateTime> _recentLocalChangeAt = {};    SupabaseSyncService({     required this.client,     required this.db,     required this.repo,     required this.auth,     this.bucket = 'beecount-backups',   });    @override   Future<SyncStatus> getSyncStatus(int ledgerId) async {     // 检查缓存     if (_statusCache.containsKey(ledgerId)) {       final cached = _statusCache[ledgerId]!;       if (DateTime.now().difference(cached.lastCheck).inMinutes < 5) {         return cached;       }     }      try {       final user = await auth.getCurrentUser();       if (user == null) {         return SyncStatus.notLoggedIn();       }        // 获取云端文件信息       final fileName = 'ledger_${ledgerId}_backup.json';       final cloudFile = await _getCloudFileInfo(fileName);              // 计算本地数据指纹       final localFingerprint = await _calculateLocalFingerprint(ledgerId);              if (cloudFile == null) {         final status = SyncStatus.localOnly(           localFingerprint: localFingerprint,           hasLocalChanges: true,         );         _statusCache[ledgerId] = status;         return status;       }        // 比较指纹判断同步状态       final isUpToDate = localFingerprint == cloudFile.fingerprint;       final status = SyncStatus.synced(         localFingerprint: localFingerprint,         cloudFingerprint: cloudFile.fingerprint,         isUpToDate: isUpToDate,         lastSyncAt: cloudFile.lastModified,       );              _statusCache[ledgerId] = status;       return status;     } catch (e) {       logger.error('Failed to get sync status', e);       return SyncStatus.error(error: e.toString());     }   }    @override   Future<SyncResult> uploadBackup(int ledgerId) async {     try {       final user = await auth.getCurrentUser();       if (user == null) {         return SyncResult.failure(error: 'Not logged in');       }        // 生成备份数据       final backupData = await _generateBackup(ledgerId);       final jsonString = json.encode(backupData.toJson());              // 加密备份数据       final encryptedData = await _encryptBackupData(jsonString);              // 上传到Supabase Storage       final fileName = 'ledger_${ledgerId}_backup.json';       final uploadResult = await client.storage           .from(bucket)           .uploadBinary(fileName, encryptedData);        if (uploadResult.isNotEmpty) {         // 记录上传成功         final fingerprint = await _calculateLocalFingerprint(ledgerId);         _recentUpload[ledgerId] = _RecentUpload(           fingerprint: fingerprint,           uploadedAt: DateTime.now(),         );                  // 更新缓存         _statusCache[ledgerId] = SyncStatus.synced(           localFingerprint: fingerprint,           cloudFingerprint: fingerprint,           isUpToDate: true,           lastSyncAt: DateTime.now(),         );          return SyncResult.success(           syncedAt: DateTime.now(),           message: 'Backup uploaded successfully',         );       }        return SyncResult.failure(error: 'Upload failed');     } catch (e) {       logger.error('Failed to upload backup', e);       return SyncResult.failure(error: e.toString());     }   }    @override   Future<SyncResult> downloadRestore(int ledgerId) async {     try {       final user = await auth.getCurrentUser();       if (user == null) {         return SyncResult.failure(error: 'Not logged in');       }        // 下载备份文件       final fileName = 'ledger_${ledgerId}_backup.json';       final downloadData = await client.storage           .from(bucket)           .download(fileName);        if (downloadData.isEmpty) {         return SyncResult.failure(error: 'No backup found');       }        // 解密备份数据       final decryptedData = await _decryptBackupData(downloadData);       final backupData = BackupData.fromJson(json.decode(decryptedData));        // 执行数据恢复       await _restoreFromBackup(backupData, ledgerId);        // 更新状态       final fingerprint = await _calculateLocalFingerprint(ledgerId);       _statusCache[ledgerId] = SyncStatus.synced(         localFingerprint: fingerprint,         cloudFingerprint: fingerprint,         isUpToDate: true,         lastSyncAt: DateTime.now(),       );        return SyncResult.success(         syncedAt: DateTime.now(),         message: 'Data restored successfully',       );     } catch (e) {       logger.error('Failed to download restore', e);       return SyncResult.failure(error: e.toString());     }   }    // 数据加密/解密   Future<Uint8List> _encryptBackupData(String jsonData) async {     final key = await _getDerivedKey();     final cipher = AESCipher(key);     return cipher.encrypt(utf8.encode(jsonData));   }    Future<String> _decryptBackupData(Uint8List encryptedData) async {     final key = await _getDerivedKey();     final cipher = AESCipher(key);     final decrypted = cipher.decrypt(encryptedData);     return utf8.decode(decrypted);   } } 

数据安全保障

端到端加密

class AESCipher {   final Uint8List key;    AESCipher(this.key);    Uint8List encrypt(List<int> plaintext) {     final cipher = AESEngine()       ..init(true, KeyParameter(key));          // 生成随机IV     final iv = _generateRandomIV();     final cbcCipher = CBCBlockCipher(cipher)       ..init(true, ParametersWithIV(KeyParameter(key), iv));      // PKCS7填充     final paddedPlaintext = _padPKCS7(Uint8List.fromList(plaintext));     final ciphertext = Uint8List(paddedPlaintext.length);          for (int i = 0; i < paddedPlaintext.length; i += 16) {       cbcCipher.processBlock(paddedPlaintext, i, ciphertext, i);     }      // IV + 密文     return Uint8List.fromList([...iv, ...ciphertext]);   }    Uint8List decrypt(Uint8List encrypted) {     // 分离IV和密文     final iv = encrypted.sublist(0, 16);     final ciphertext = encrypted.sublist(16);      final cipher = AESEngine()       ..init(false, KeyParameter(key));     final cbcCipher = CBCBlockCipher(cipher)       ..init(false, ParametersWithIV(KeyParameter(key), iv));      final decrypted = Uint8List(ciphertext.length);     for (int i = 0; i < ciphertext.length; i += 16) {       cbcCipher.processBlock(ciphertext, i, decrypted, i);     }      // 移除PKCS7填充     return _removePKCS7Padding(decrypted);   }    Uint8List _generateRandomIV() {     final random = Random.secure();     return Uint8List.fromList(       List.generate(16, (_) => random.nextInt(256))     );   } } 

密钥派生

Future<Uint8List> _getDerivedKey() async {   final user = await auth.getCurrentUser();   if (user == null) throw Exception('User not authenticated');    // 使用用户ID和设备特征生成密钥   final salt = utf8.encode('${user.id}_${await _getDeviceId()}');   final password = utf8.encode(user.id);    // PBKDF2密钥派生   final pbkdf2 = PBKDF2KeyDerivator(HMac(SHA256Digest(), 64))     ..init(Pbkdf2Parameters(salt, 10000, 32));    return pbkdf2.process(password); }  Future<String> _getDeviceId() async {   final prefs = await SharedPreferences.getInstance();   String? deviceId = prefs.getString('device_id');      if (deviceId == null) {     deviceId = const Uuid().v4();     await prefs.setString('device_id', deviceId);   }      return deviceId; } 

冲突处理策略

冲突检测

class ConflictDetector {   static ConflictResolution detectConflict({     required BackupData localData,     required BackupData cloudData,     required DateTime lastSyncAt,   }) {     final localChanges = <String, dynamic>{};     final cloudChanges = <String, dynamic>{};          // 检测交易记录冲突     _detectTransactionConflicts(       localData.transactions,       cloudData.transactions,       lastSyncAt,       localChanges,       cloudChanges,     );      if (localChanges.isEmpty && cloudChanges.isEmpty) {       return ConflictResolution.noConflict();     }      if (localChanges.isNotEmpty && cloudChanges.isEmpty) {       return ConflictResolution.localWins(changes: localChanges);     }      if (localChanges.isEmpty && cloudChanges.isNotEmpty) {       return ConflictResolution.cloudWins(changes: cloudChanges);     }      // 存在双向冲突，需要用户选择     return ConflictResolution.needsResolution(       localChanges: localChanges,       cloudChanges: cloudChanges,     );   }    static void _detectTransactionConflicts(     Map<String, dynamic> localTxs,     Map<String, dynamic> cloudTxs,     DateTime lastSyncAt,     Map<String, dynamic> localChanges,     Map<String, dynamic> cloudChanges,   ) {     // 检测本地新增/修改的交易     localTxs.forEach((id, localTx) {       final txUpdatedAt = DateTime.parse(localTx['updatedAt'] ?? localTx['createdAt']);       if (txUpdatedAt.isAfter(lastSyncAt)) {         localChanges[id] = localTx;       }     });      // 检测云端新增/修改的交易     cloudTxs.forEach((id, cloudTx) {       final txUpdatedAt = DateTime.parse(cloudTx['updatedAt'] ?? cloudTx['createdAt']);       if (txUpdatedAt.isAfter(lastSyncAt)) {         cloudChanges[id] = cloudTx;       }     });   } } 

冲突解决

class ConflictResolver {   static Future<BackupData> resolveConflict({     required BackupData localData,     required BackupData cloudData,     required ConflictResolution resolution,   }) async {     switch (resolution.type) {       case ConflictType.noConflict:         return localData;              case ConflictType.localWins:         return localData;              case ConflictType.cloudWins:         return cloudData;              case ConflictType.needsResolution:         return await _mergeData(localData, cloudData, resolution);     }   }    static Future<BackupData> _mergeData(     BackupData localData,     BackupData cloudData,     ConflictResolution resolution,   ) async {     // 实现智能合并策略     final mergedTransactions = <String, dynamic>{};          // 优先保留较新的数据     mergedTransactions.addAll(cloudData.transactions);          resolution.localChanges.forEach((id, localTx) {       final localUpdatedAt = DateTime.parse(localTx['updatedAt'] ?? localTx['createdAt']);              if (resolution.cloudChanges.containsKey(id)) {         final cloudTx = resolution.cloudChanges[id];         final cloudUpdatedAt = DateTime.parse(cloudTx['updatedAt'] ?? cloudTx['createdAt']);                  // 保留时间戳较新的版本         if (localUpdatedAt.isAfter(cloudUpdatedAt)) {           mergedTransactions[id] = localTx;         } else {           mergedTransactions[id] = cloudTx;         }       } else {         mergedTransactions[id] = localTx;       }     });      return BackupData(       version: localData.version,       createdAt: DateTime.now(),       deviceId: localData.deviceId,       ledgers: localData.ledgers,       accounts: localData.accounts,       categories: localData.categories,       transactions: mergedTransactions,     );   } } 

性能优化

增量同步优化

class IncrementalSync {   static Future<BackupData> generateIncrementalBackup({     required int ledgerId,     required DateTime lastSyncAt,     required BeeRepository repo,   }) async {     // 只获取自上次同步后的变更数据     final changedTransactions = await repo.getTransactionsSince(       ledgerId: ledgerId,       since: lastSyncAt,     );      final changedAccounts = await repo.getAccountsSince(       ledgerId: ledgerId,       since: lastSyncAt,     );      // 构建增量备份数据     return BackupData(       version: '1.0',       createdAt: DateTime.now(),       deviceId: await _getDeviceId(),       ledgers: {}, // 账本信息变化较少，可按需包含       accounts: _mapAccountsToJson(changedAccounts),       categories: {}, // 分类变化较少，可按需包含       transactions: _mapTransactionsToJson(changedTransactions),     );   }    static Map<String, dynamic> _mapTransactionsToJson(List<Transaction> transactions) {     return Map.fromEntries(       transactions.map((tx) => MapEntry(         tx.id.toString(),         {           'id': tx.id,           'ledgerId': tx.ledgerId,           'type': tx.type,           'amount': tx.amount,           'categoryId': tx.categoryId,           'accountId': tx.accountId,           'toAccountId': tx.toAccountId,           'happenedAt': tx.happenedAt.toIso8601String(),           'note': tx.note,           'updatedAt': DateTime.now().toIso8601String(),         }       ))     );   } } 

网络优化

class NetworkOptimizer {   static const int maxRetries = 3;   static const Duration retryDelay = Duration(seconds: 2);    static Future<T> withRetry<T>(Future<T> Function() operation) async {     int attempts = 0;          while (attempts < maxRetries) {       try {         return await operation();       } catch (e) {         attempts++;                  if (attempts >= maxRetries) {           rethrow;         }                  // 指数退避         await Future.delayed(retryDelay * (1 << attempts));       }     }          throw Exception('Max retries exceeded');   }    static Future<bool> isNetworkAvailable() async {     try {       final result = await InternetAddress.lookup('supabase.co');       return result.isNotEmpty && result[0].rawAddress.isNotEmpty;     } catch (_) {       return false;     }   } } 

用户体验设计

同步状态展示

class SyncStatusWidget extends ConsumerWidget {   final int ledgerId;    const SyncStatusWidget({Key? key, required this.ledgerId}) : super(key: key);    @override   Widget build(BuildContext context, WidgetRef ref) {     final syncStatus = ref.watch(syncStatusProvider(ledgerId));      return syncStatus.when(       data: (status) => _buildStatusIndicator(status),       loading: () => const SyncLoadingIndicator(),       error: (error, _) => SyncErrorIndicator(error: error.toString()),     );   }    Widget _buildStatusIndicator(SyncStatus status) {     switch (status.type) {       case SyncStatusType.synced:         return Row(           mainAxisSize: MainAxisSize.min,           children: [             Icon(Icons.cloud_done, color: Colors.green, size: 16),             SizedBox(width: 4),             Text('已同步', style: TextStyle(fontSize: 12, color: Colors.green)),           ],         );              case SyncStatusType.localOnly:         return Row(           mainAxisSize: MainAxisSize.min,           children: [             Icon(Icons.cloud_off, color: Colors.orange, size: 16),             SizedBox(width: 4),             Text('仅本地', style: TextStyle(fontSize: 12, color: Colors.orange)),           ],         );              case SyncStatusType.needsUpload:         return Row(           mainAxisSize: MainAxisSize.min,           children: [             Icon(Icons.cloud_upload, color: Colors.blue, size: 16),             SizedBox(width: 4),             Text('待上传', style: TextStyle(fontSize: 12, color: Colors.blue)),           ],         );              case SyncStatusType.needsDownload:         return Row(           mainAxisSize: MainAxisSize.min,           children: [             Icon(Icons.cloud_download, color: Colors.purple, size: 16),             SizedBox(width: 4),             Text('有更新', style: TextStyle(fontSize: 12, color: Colors.purple)),           ],         );              default:         return SizedBox.shrink();     }   } } 

同步操作界面

class SyncActionsSheet extends ConsumerWidget {   final int ledgerId;    const SyncActionsSheet({Key? key, required this.ledgerId}) : super(key: key);    @override   Widget build(BuildContext context, WidgetRef ref) {     final syncStatus = ref.watch(syncStatusProvider(ledgerId));      return DraggableScrollableSheet(       initialChildSize: 0.4,       minChildSize: 0.2,       maxChildSize: 0.8,       builder: (context, scrollController) {         return Container(           decoration: BoxDecoration(             color: Theme.of(context).scaffoldBackgroundColor,             borderRadius: BorderRadius.vertical(top: Radius.circular(20)),           ),           child: Column(             children: [               // 拖拽指示器               Container(                 width: 40,                 height: 4,                 margin: EdgeInsets.symmetric(vertical: 12),                 decoration: BoxDecoration(                   color: Colors.grey[300],                   borderRadius: BorderRadius.circular(2),                 ),               ),                              // 标题               Text(                 '云端同步',                 style: Theme.of(context).textTheme.headlineSmall,               ),                              Expanded(                 child: ListView(                   controller: scrollController,                   padding: EdgeInsets.all(16),                   children: [                     _buildSyncActions(context, ref, syncStatus),                   ],                 ),               ),             ],           ),         );       },     );   }    Widget _buildSyncActions(BuildContext context, WidgetRef ref, AsyncValue<SyncStatus> syncStatus) {     return syncStatus.when(       data: (status) {         switch (status.type) {           case SyncStatusType.localOnly:             return Column(               children: [                 _buildActionCard(                   title: '上传备份',                   subtitle: '将本地数据上传到云端',                   icon: Icons.cloud_upload,                   color: Colors.blue,                   onTap: () => _uploadBackup(ref),                 ),               ],             );                      case SyncStatusType.needsDownload:             return Column(               children: [                 _buildActionCard(                   title: '下载恢复',                   subtitle: '从云端恢复数据（会覆盖本地数据）',                   icon: Icons.cloud_download,                   color: Colors.purple,                   onTap: () => _downloadRestore(context, ref),                 ),                 SizedBox(height: 16),                 _buildActionCard(                   title: '强制上传',                   subtitle: '用本地数据覆盖云端备份',                   icon: Icons.upload,                   color: Colors.orange,                   onTap: () => _forceUpload(context, ref),                 ),               ],             );                      default:             return _buildSyncInfo(status);         }       },       loading: () => Center(child: CircularProgressIndicator()),       error: (error, _) => Text('错误: $error'),     );   }    Widget _buildActionCard({     required String title,     required String subtitle,     required IconData icon,     required Color color,     required VoidCallback onTap,   }) {     return Card(       child: ListTile(         leading: CircleAvatar(           backgroundColor: color.withOpacity(0.1),           child: Icon(icon, color: color),         ),         title: Text(title),         subtitle: Text(subtitle),         trailing: Icon(Icons.arrow_forward_ios, size: 16),         onTap: onTap,       ),     );   } } 

最佳实践总结

1. 架构设计原则

• 本地优先：确保应用离线可用
• 渐进式同步：支持部分同步，不影响核心功能
• 状态透明：让用户清楚了解同步状态

2. 安全性考虑

• 端到端加密：敏感数据客户端加密
• 密钥管理：使用安全的密钥派生和存储
• 权限控制：确保用户只能访问自己的数据

3. 性能优化

• 增量同步：只传输变更数据
• 压缩上传：减少网络传输量
• 后台同步：不影响用户操作

4. 用户体验

• 状态可见：清晰的同步状态指示
• 操作简单：一键同步，自动处理
• 错误友好：明确的错误提示和恢复建议

实际应用效果

在BeeCount项目中，Supabase云同步系统带来了显著的价值：

1. 用户满意度提升：多设备无缝切换，用户数据永不丢失
2. 技术债务减少：基于成熟的BaaS服务，减少自建后台成本
3. 安全性保障：端到端加密确保财务数据安全
4. 开发效率：快速集成，专注业务逻辑开发

结语

Supabase作为开源的BaaS解决方案，为Flutter应用提供了完整的后端服务能力。通过合理的架构设计、安全的加密策略和良好的用户体验设计，我们可以构建出既安全又好用的云同步功能。

BeeCount的实践证明，选择合适的技术栈和设计模式，能够在保证数据安全的前提下，为用户提供便捷的多设备同步体验。这对于任何需要数据同步的应用都具有重要的参考价值。

关于BeeCount项目

项目特色

• 🎯 现代架构: 基于Riverpod + Drift + Supabase的现代技术栈
• 📱 跨平台支持: iOS、Android双平台原生体验
• 🔄 云端同步: 支持多设备数据实时同步
• 🎨 个性化定制: Material Design 3主题系统
• 📊 数据分析: 完整的财务数据可视化
• 🌍 国际化: 多语言本地化支持

技术栈一览

• 框架: Flutter 3.6.1+ / Dart 3.6.1+
• 状态管理: Flutter Riverpod 2.5.1
• 数据库: Drift (SQLite) 2.20.2
• 云服务: Supabase 2.5.6
• 图表: FL Chart 0.68.0
• CI/CD: GitHub Actions

开源信息

BeeCount是一个完全开源的项目，欢迎开发者参与贡献：

• 项目主页: https://github.com/TNT-Likely/BeeCount
• 开发者主页: https://github.com/TNT-Likely
• 发布下载: GitHub Releases

参考资源

官方文档

• Supabase官方文档 - Supabase完整使用指南
• Flutter加密指南 - Flutter安全开发实践

学习资源

• Supabase Flutter教程 - 官方Flutter集成教程
• 数据同步最佳实践 - 实时数据同步案例

---

本文是BeeCount技术文章系列的第3篇，后续将深入探讨主题系统、数据可视化等话题。如果你觉得这篇文章有帮助，欢迎关注项目并给个Star！