784 lines
26 KiB
Dart
784 lines
26 KiB
Dart
/**
|
||
* 文档解析工具类
|
||
*
|
||
* 用于解析和处理文本内容，将其转换为可编辑的Quill文档格式。
|
||
* 提供两种解析方法：安全解析（在UI线程使用）和隔离解析（在计算隔离中使用）。
|
||
*/
|
||
import 'dart:async';
|
||
import 'dart:convert';
|
||
import 'dart:isolate';
|
||
import 'package:flutter/foundation.dart';
|
||
import 'package:flutter_quill/flutter_quill.dart';
|
||
import 'package:ainoval/utils/logger.dart';
|
||
import 'package:ainoval/utils/quill_helper.dart';
|
||
|
||
/// 优化的文档解析器
|
||
///
|
||
/// 包含以下优化特性：
|
||
/// 1. LRU缓存机制 - 避免重复解析
|
||
/// 2. 解析队列和优先级控制 - 减少并发竞争
|
||
/// 3. 批量解析 - 提高吞吐量
|
||
/// 4. 智能预解析 - 提前准备常用内容
|
||
/// 5. 解析结果压缩 - 减少内存占用
|
||
class DocumentParser {
|
||
static final DocumentParser _instance = DocumentParser._internal();
|
||
factory DocumentParser() => _instance;
|
||
DocumentParser._internal();
|
||
|
||
// LRU缓存配置
|
||
static const int _maxCacheSize = 50; // 从50
|
||
static const int _maxCacheMemoryMB = 200; // 从100MB增加到200MB
|
||
|
||
// 解析队列配置
|
||
static const int _maxConcurrentParsing = 5; // 从3增加到5个并发解析
|
||
static const Duration _parseTimeout = Duration(seconds: 8); // 从5秒增加到8秒
|
||
|
||
// 缓存存储
|
||
final Map<String, _CachedDocument> _documentCache = {};
|
||
final List<String> _cacheAccessOrder = []; // LRU访问顺序
|
||
|
||
// 解析队列
|
||
final List<_ParseRequest> _parseQueue = [];
|
||
int _currentParsingCount = 0;
|
||
|
||
// 统计信息
|
||
int _cacheHits = 0;
|
||
int _cacheMisses = 0;
|
||
int _totalParseTime = 0;
|
||
int _totalParseCount = 0;
|
||
|
||
/// 解析文档（带缓存和优先级）
|
||
static Future<Document> parseDocumentOptimized(
|
||
String content, {
|
||
int priority = 5, // 优先级 1-10，10最高
|
||
String? cacheKey,
|
||
bool useCache = true,
|
||
}) async {
|
||
return DocumentParser()._parseWithCache(
|
||
content,
|
||
priority: priority,
|
||
cacheKey: cacheKey,
|
||
useCache: useCache,
|
||
);
|
||
}
|
||
|
||
/// 原始解析方法（保持兼容性）
|
||
static Future<Document> parseDocumentInIsolate(String content) async {
|
||
return DocumentParser()._parseWithCache(content, priority: 5);
|
||
}
|
||
|
||
/// 安全解析文档（用于UI线程，兼容性方法）
|
||
static Future<Document> parseDocumentSafely(String content) async {
|
||
return DocumentParser()._parseWithCache(content, priority: 5, useCache: true);
|
||
}
|
||
|
||
/// 同步解析文档（用于控制器初始化）
|
||
///
|
||
/// 这个方法用于需要立即返回Document的场景，如QuillController初始化
|
||
/// 使用简化解析逻辑，避免异步操作
|
||
static Document parseDocumentSync(String content) {
|
||
return DocumentParser()._parseDocumentSimple(content);
|
||
}
|
||
|
||
/// 批量解析文档
|
||
static Future<List<Document>> parseBatchDocuments(
|
||
List<String> contents, {
|
||
int priority = 5,
|
||
List<String>? cacheKeys,
|
||
}) async {
|
||
return DocumentParser()._parseBatch(contents, priority: priority, cacheKeys: cacheKeys);
|
||
}
|
||
|
||
/// 预加载文档到缓存（增强版）
|
||
static Future<void> preloadDocuments(
|
||
List<String> contents, {
|
||
List<String>? cacheKeys,
|
||
int maxPreloadConcurrency = 2, // 限制预加载并发数，避免影响正常解析
|
||
}) async {
|
||
final parser = DocumentParser();
|
||
final futures = <Future<void>>[];
|
||
|
||
for (int i = 0; i < contents.length; i++) {
|
||
final content = contents[i];
|
||
final cacheKey = cacheKeys != null && i < cacheKeys.length
|
||
? cacheKeys[i]
|
||
: parser._generateCacheKey(content);
|
||
|
||
// 检查是否已缓存
|
||
if (!parser._documentCache.containsKey(cacheKey)) {
|
||
// 创建预加载Future
|
||
final preloadFuture = parser._parseWithCache(
|
||
content,
|
||
priority: 1, // 最低优先级后台解析
|
||
cacheKey: cacheKey,
|
||
useCache: true
|
||
).then((_) {
|
||
AppLogger.d('DocumentParser', '预加载完成: $cacheKey');
|
||
}).catchError((e) {
|
||
AppLogger.w('DocumentParser', '预加载失败: $cacheKey, $e');
|
||
});
|
||
|
||
futures.add(preloadFuture);
|
||
|
||
// 控制并发数量，每批处理maxPreloadConcurrency个
|
||
if (futures.length >= maxPreloadConcurrency) {
|
||
await Future.wait(futures);
|
||
futures.clear();
|
||
// 短暂延迟，避免阻塞主线程
|
||
await Future.delayed(const Duration(milliseconds: 10));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 处理剩余的预加载任务
|
||
if (futures.isNotEmpty) {
|
||
await Future.wait(futures);
|
||
}
|
||
|
||
AppLogger.i('DocumentParser', '批量预加载完成，处理了${contents.length}个文档');
|
||
}
|
||
|
||
/// 清理缓存
|
||
static void clearCache() {
|
||
final parser = DocumentParser();
|
||
parser._documentCache.clear();
|
||
parser._cacheAccessOrder.clear();
|
||
parser._cacheHits = 0;
|
||
parser._cacheMisses = 0;
|
||
parser._totalParseTime = 0;
|
||
parser._totalParseCount = 0;
|
||
AppLogger.i('DocumentParser', '缓存已清理');
|
||
}
|
||
|
||
/// 获取缓存统计信息
|
||
static Map<String, dynamic> getCacheStats() {
|
||
final parser = DocumentParser();
|
||
final cacheSize = parser._documentCache.length;
|
||
final memoryUsageMB = parser._calculateCacheMemoryUsage() / 1024 / 1024;
|
||
final hitRate = parser._cacheHits + parser._cacheMisses > 0
|
||
? (parser._cacheHits / (parser._cacheHits + parser._cacheMisses) * 100).toStringAsFixed(1) + '%'
|
||
: '0.0%';
|
||
final avgParseTimeMs = parser._totalParseCount > 0
|
||
? (parser._totalParseTime / parser._totalParseCount).toStringAsFixed(1)
|
||
: '0.0';
|
||
|
||
return {
|
||
'cacheSize': cacheSize,
|
||
'memoryUsageMB': memoryUsageMB.toStringAsFixed(2),
|
||
'hitRate': hitRate,
|
||
'avgParseTimeMs': avgParseTimeMs,
|
||
'queueLength': parser._parseQueue.length,
|
||
'currentParsing': parser._currentParsingCount,
|
||
'totalHits': parser._cacheHits,
|
||
'totalMisses': parser._cacheMisses,
|
||
'totalParseCount': parser._totalParseCount,
|
||
'maxCacheSize': _maxCacheSize,
|
||
'maxMemoryMB': _maxCacheMemoryMB,
|
||
};
|
||
}
|
||
|
||
/// 核心解析方法（带缓存）
|
||
Future<Document> _parseWithCache(
|
||
String content, {
|
||
int priority = 5,
|
||
String? cacheKey,
|
||
bool useCache = true,
|
||
}) async {
|
||
final key = cacheKey ?? _generateCacheKey(content);
|
||
|
||
// 🚀 快速路径：空内容直接返回
|
||
if (content.isEmpty) {
|
||
AppLogger.d('DocumentParser', '快速路径：空内容 $key');
|
||
return Document.fromJson([{'insert': '\n'}]);
|
||
}
|
||
|
||
// 尝试从缓存获取
|
||
if (useCache && _documentCache.containsKey(key)) {
|
||
_updateCacheAccess(key);
|
||
_cacheHits++;
|
||
AppLogger.d('DocumentParser', '缓存命中: $key');
|
||
return _documentCache[key]!.document;
|
||
}
|
||
|
||
_cacheMisses++;
|
||
|
||
// 🚀 快速路径：内容过大时使用简化解析
|
||
if (content.length > 100000) { // 大于100KB使用简化解析
|
||
AppLogger.w('DocumentParser', '内容过大($content.length字符)，使用简化解析: $key');
|
||
try {
|
||
final simpleDocument = _parseDocumentSimple(content);
|
||
if (useCache) {
|
||
_storeInCache(key, simpleDocument, content.length);
|
||
}
|
||
return simpleDocument;
|
||
} catch (e) {
|
||
AppLogger.e('DocumentParser', '简化解析失败: $key', e);
|
||
return Document.fromJson([{'insert': '内容过大，解析失败\n'}]);
|
||
}
|
||
}
|
||
|
||
// 🚀 快速路径：如果是纯文本且不太长，直接解析
|
||
if (content.length < 1000 && !content.trim().startsWith('[') && !content.trim().startsWith('{')) {
|
||
AppLogger.d('DocumentParser', '快速路径：纯文本解析 $key');
|
||
final quickDocument = Document.fromJson([{'insert': '$content\n'}]);
|
||
if (useCache) {
|
||
_storeInCache(key, quickDocument, content.length);
|
||
}
|
||
return quickDocument;
|
||
}
|
||
|
||
// 创建解析请求
|
||
final completer = Completer<Document>();
|
||
final request = _ParseRequest(
|
||
content: content,
|
||
cacheKey: key,
|
||
priority: priority,
|
||
completer: completer,
|
||
useCache: useCache,
|
||
);
|
||
|
||
_parseQueue.add(request);
|
||
_parseQueue.sort((a, b) => b.priority.compareTo(a.priority)); // 按优先级排序
|
||
|
||
_processParseQueue();
|
||
|
||
return completer.future;
|
||
}
|
||
|
||
/// 批量解析
|
||
Future<List<Document>> _parseBatch(
|
||
List<String> contents, {
|
||
int priority = 5,
|
||
List<String>? cacheKeys,
|
||
}) async {
|
||
final futures = <Future<Document>>[];
|
||
|
||
for (int i = 0; i < contents.length; i++) {
|
||
final cacheKey = cacheKeys != null && i < cacheKeys.length ? cacheKeys[i] : null;
|
||
futures.add(_parseWithCache(contents[i], priority: priority, cacheKey: cacheKey));
|
||
}
|
||
|
||
return Future.wait(futures);
|
||
}
|
||
|
||
/// 处理解析队列
|
||
void _processParseQueue() {
|
||
while (_parseQueue.isNotEmpty && _currentParsingCount < _maxConcurrentParsing) {
|
||
final request = _parseQueue.removeAt(0);
|
||
_currentParsingCount++;
|
||
|
||
_executeParseRequest(request);
|
||
}
|
||
}
|
||
|
||
/// 执行解析请求
|
||
void _executeParseRequest(_ParseRequest request) async {
|
||
final stopwatch = Stopwatch()..start();
|
||
|
||
try {
|
||
// 🚀 预估解析时间，如果内容过大直接使用简化解析
|
||
if (request.content.length > 50000) {
|
||
AppLogger.w('DocumentParser', '内容较大(${request.content.length}字符)，使用简化解析: ${request.cacheKey}');
|
||
final document = _parseDocumentSimple(request.content);
|
||
|
||
stopwatch.stop();
|
||
final parseTime = stopwatch.elapsedMilliseconds;
|
||
_totalParseTime += parseTime;
|
||
_totalParseCount++;
|
||
|
||
if (request.useCache) {
|
||
_storeInCache(request.cacheKey, document, request.content.length);
|
||
}
|
||
|
||
AppLogger.d('DocumentParser', '简化解析完成: ${request.cacheKey}, 耗时: ${parseTime}ms');
|
||
request.completer.complete(document);
|
||
return;
|
||
}
|
||
|
||
// 正常解析流程
|
||
final document = await _parseInIsolateWithTimeout(request.content);
|
||
|
||
stopwatch.stop();
|
||
final parseTime = stopwatch.elapsedMilliseconds;
|
||
_totalParseTime += parseTime;
|
||
_totalParseCount++;
|
||
|
||
// 🚨 性能监控：如果解析时间过长，记录警告
|
||
if (parseTime > 1000) {
|
||
AppLogger.w('DocumentParser', '⚠️ 解析时间过长: ${request.cacheKey}, 耗时: ${parseTime}ms, 内容长度: ${request.content.length}');
|
||
}
|
||
|
||
// 存储到缓存
|
||
if (request.useCache) {
|
||
_storeInCache(request.cacheKey, document, request.content.length);
|
||
}
|
||
|
||
AppLogger.d('DocumentParser', '解析完成: ${request.cacheKey}, 耗时: ${parseTime}ms');
|
||
request.completer.complete(document);
|
||
|
||
} catch (e, stackTrace) {
|
||
stopwatch.stop();
|
||
AppLogger.e('DocumentParser', '解析失败: ${request.cacheKey}', e, stackTrace);
|
||
|
||
// 🚀 解析失败时使用简化解析作为备用方案
|
||
try {
|
||
AppLogger.i('DocumentParser', '尝试简化解析备用方案: ${request.cacheKey}');
|
||
final fallbackDocument = _parseDocumentSimple(request.content);
|
||
|
||
if (request.useCache) {
|
||
_storeInCache(request.cacheKey, fallbackDocument, request.content.length);
|
||
}
|
||
|
||
request.completer.complete(fallbackDocument);
|
||
AppLogger.i('DocumentParser', '简化解析备用方案成功: ${request.cacheKey}');
|
||
} catch (fallbackError) {
|
||
// 最后的备用方案：创建错误文档
|
||
final errorDocument = Document.fromJson([
|
||
{'insert': '⚠️ 文档解析失败\n内容加载出现问题，请刷新重试。\n\n原始内容预览：\n'},
|
||
{'insert': request.content.length > 200 ? '${request.content.substring(0, 200)}...\n' : '${request.content}\n'},
|
||
]);
|
||
|
||
request.completer.complete(errorDocument);
|
||
AppLogger.e('DocumentParser', '所有解析方案都失败: ${request.cacheKey}', fallbackError);
|
||
}
|
||
} finally {
|
||
_currentParsingCount--;
|
||
_processParseQueue(); // 处理队列中的下一个请求
|
||
}
|
||
}
|
||
|
||
/// 在隔离中解析（带超时）
|
||
Future<Document> _parseInIsolateWithTimeout(String content) async {
|
||
// 🚀 根据内容大小动态调整超时时间
|
||
Duration timeout;
|
||
if (content.length < 1000) {
|
||
timeout = const Duration(seconds: 2); // 小内容2秒超时
|
||
} else if (content.length < 10000) {
|
||
timeout = const Duration(seconds: 4); // 中等内容4秒超时
|
||
} else {
|
||
timeout = const Duration(seconds: 6); // 大内容6秒超时，不再使用8秒
|
||
}
|
||
|
||
return compute(_isolateParseFunction, content).timeout(
|
||
timeout,
|
||
onTimeout: () {
|
||
AppLogger.w('DocumentParser', '解析超时(${timeout.inSeconds}秒)，使用简化解析，内容长度: ${content.length}');
|
||
return _parseDocumentSimple(content);
|
||
},
|
||
);
|
||
}
|
||
|
||
/// 生成缓存键
|
||
String _generateCacheKey(String content) {
|
||
// 使用内容长度和特征字符生成更稳定的缓存键
|
||
final length = content.length;
|
||
if (length == 0) return 'doc_empty_0';
|
||
|
||
// 采样关键字符位置，避免完整内容哈希
|
||
final sample1 = content.codeUnitAt(0);
|
||
final sample2 = length > 10 ? content.codeUnitAt(length ~/ 4) : 0;
|
||
final sample3 = length > 20 ? content.codeUnitAt(length ~/ 2) : 0;
|
||
final sample4 = length > 30 ? content.codeUnitAt(length * 3 ~/ 4) : 0;
|
||
final sample5 = content.codeUnitAt(length - 1);
|
||
|
||
// 使用字符码点和生成稳定哈希
|
||
int stableHash = length;
|
||
stableHash = (stableHash * 31 + sample1) & 0x7FFFFFFF;
|
||
stableHash = (stableHash * 31 + sample2) & 0x7FFFFFFF;
|
||
stableHash = (stableHash * 31 + sample3) & 0x7FFFFFFF;
|
||
stableHash = (stableHash * 31 + sample4) & 0x7FFFFFFF;
|
||
stableHash = (stableHash * 31 + sample5) & 0x7FFFFFFF;
|
||
|
||
return 'doc_${length}_${stableHash}';
|
||
}
|
||
|
||
/// 存储到缓存
|
||
void _storeInCache(String key, Document document, int contentSize) {
|
||
// 检查缓存大小限制
|
||
_enforceCacheLimits();
|
||
|
||
final cachedDoc = _CachedDocument(
|
||
document: document,
|
||
contentSize: contentSize,
|
||
accessTime: DateTime.now(),
|
||
);
|
||
|
||
_documentCache[key] = cachedDoc;
|
||
_updateCacheAccess(key);
|
||
}
|
||
|
||
/// 更新缓存访问顺序
|
||
void _updateCacheAccess(String key) {
|
||
_cacheAccessOrder.remove(key);
|
||
_cacheAccessOrder.add(key); // 移到最后（最近访问）
|
||
|
||
if (_documentCache.containsKey(key)) {
|
||
_documentCache[key]!.accessTime = DateTime.now();
|
||
}
|
||
}
|
||
|
||
/// 强制执行缓存限制
|
||
void _enforceCacheLimits() {
|
||
// 检查数量限制
|
||
while (_documentCache.length >= _maxCacheSize && _cacheAccessOrder.isNotEmpty) {
|
||
final oldestKey = _cacheAccessOrder.removeAt(0);
|
||
_documentCache.remove(oldestKey);
|
||
}
|
||
|
||
// 检查内存限制
|
||
while (_calculateCacheMemoryUsage() > _maxCacheMemoryMB * 1024 * 1024 && _cacheAccessOrder.isNotEmpty) {
|
||
final oldestKey = _cacheAccessOrder.removeAt(0);
|
||
_documentCache.remove(oldestKey);
|
||
}
|
||
}
|
||
|
||
/// 计算缓存内存使用量
|
||
int _calculateCacheMemoryUsage() {
|
||
return _documentCache.values.fold(0, (sum, doc) => sum + doc.contentSize);
|
||
}
|
||
|
||
/// 简化解析方法 - 用于大内容或解析失败的备用方案
|
||
Document _parseDocumentSimple(String content) {
|
||
try {
|
||
// 🚀 快速检查：如果是空内容
|
||
if (content.trim().isEmpty) {
|
||
return Document.fromJson([{'insert': '\n'}]);
|
||
}
|
||
|
||
// 🚀 快速检查：如果明显是纯文本
|
||
final trimmedContent = content.trim();
|
||
if (!trimmedContent.startsWith('[') && !trimmedContent.startsWith('{')) {
|
||
// 处理纯文本，保留换行
|
||
final lines = content.split('\n');
|
||
final ops = <Map<String, dynamic>>[];
|
||
|
||
for (int i = 0; i < lines.length; i++) {
|
||
if (lines[i].isNotEmpty) {
|
||
ops.add({'insert': lines[i]});
|
||
}
|
||
if (i < lines.length - 1 || content.endsWith('\n')) {
|
||
ops.add({'insert': '\n'});
|
||
}
|
||
}
|
||
|
||
if (ops.isEmpty) {
|
||
ops.add({'insert': '\n'});
|
||
}
|
||
|
||
return Document.fromJson(ops);
|
||
}
|
||
|
||
// 🚀 尝试快速JSON解析
|
||
try {
|
||
final jsonData = jsonDecode(content);
|
||
|
||
if (jsonData is List) {
|
||
// 验证是否是有效的Quill操作数组
|
||
bool isValidOps = true;
|
||
bool hasStyleAttributes = false;
|
||
|
||
for (final op in jsonData) {
|
||
if (op is! Map || !op.containsKey('insert')) {
|
||
isValidOps = false;
|
||
break;
|
||
}
|
||
// 检查是否有样式属性
|
||
if (op is Map && op.containsKey('attributes')) {
|
||
hasStyleAttributes = true;
|
||
final attributes = op['attributes'] as Map<String, dynamic>?;
|
||
if (attributes != null) {
|
||
AppLogger.d('DocumentParser/_parseDocumentSimple',
|
||
'🎨 发现样式属性: ${attributes.keys.join(', ')}');
|
||
|
||
if (attributes.containsKey('color')) {
|
||
AppLogger.d('DocumentParser/_parseDocumentSimple',
|
||
'🎨 文字颜色: ${attributes['color']}');
|
||
}
|
||
if (attributes.containsKey('background')) {
|
||
AppLogger.d('DocumentParser/_parseDocumentSimple',
|
||
'🎨 背景颜色: ${attributes['background']}');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (hasStyleAttributes) {
|
||
AppLogger.i('DocumentParser/_parseDocumentSimple',
|
||
'🎨 简化解析包含样式属性的内容，操作数量: ${jsonData.length}');
|
||
}
|
||
|
||
if (isValidOps) {
|
||
return Document.fromJson(jsonData);
|
||
}
|
||
} else if (jsonData is Map && jsonData.containsKey('ops')) {
|
||
final ops = jsonData['ops'];
|
||
if (ops is List) {
|
||
// 检查ops中的样式属性
|
||
bool hasStyleAttributes = false;
|
||
for (final op in ops) {
|
||
if (op is Map && op.containsKey('attributes')) {
|
||
hasStyleAttributes = true;
|
||
final attributes = op['attributes'] as Map<String, dynamic>?;
|
||
if (attributes != null) {
|
||
AppLogger.d('DocumentParser/_parseDocumentSimple',
|
||
'🎨 ops中发现样式属性: ${attributes.keys.join(', ')}');
|
||
}
|
||
}
|
||
}
|
||
|
||
if (hasStyleAttributes) {
|
||
AppLogger.i('DocumentParser/_parseDocumentSimple',
|
||
'🎨 简化解析ops格式包含样式属性的内容，操作数量: ${ops.length}');
|
||
}
|
||
|
||
return Document.fromJson(ops);
|
||
}
|
||
}
|
||
|
||
// 如果JSON格式不正确，当作文本处理
|
||
return Document.fromJson([
|
||
{'insert': '⚠️ 内容格式异常，显示原始内容：\n'},
|
||
{'insert': content.length > 1000 ? '${content.substring(0, 1000)}...\n' : '$content\n'}
|
||
]);
|
||
|
||
} catch (jsonError) {
|
||
// JSON解析失败，当作纯文本处理
|
||
AppLogger.d('DocumentParser', '简化解析：JSON解析失败，当作纯文本处理');
|
||
return Document.fromJson([
|
||
{'insert': content.length > 10000 ? '${content.substring(0, 10000)}...\n' : '$content\n'}
|
||
]);
|
||
}
|
||
|
||
} catch (e) {
|
||
AppLogger.w('DocumentParser', '简化解析也失败，使用最基础的文档', e);
|
||
return Document.fromJson([
|
||
{'insert': '⚠️ 内容解析失败\n'},
|
||
{'insert': '内容长度: ${content.length} 字符\n'},
|
||
{'insert': '请联系技术支持\n'}
|
||
]);
|
||
}
|
||
}
|
||
|
||
/// 优化缓存键生成 - 使用更稳定的hash算法
|
||
String _generateCacheKeyOptimized(String content) {
|
||
// 统一使用新的稳定缓存键生成方法
|
||
return _generateCacheKey(content);
|
||
}
|
||
|
||
/// 检查缓存健康状况
|
||
static Map<String, dynamic> checkCacheHealth() {
|
||
final parser = DocumentParser();
|
||
final stats = getCacheStats();
|
||
final issues = <String>[];
|
||
|
||
// 检查缓存命中率
|
||
final hitRateNum = parser._cacheHits + parser._cacheMisses > 0
|
||
? (parser._cacheHits / (parser._cacheHits + parser._cacheMisses) * 100)
|
||
: 0.0;
|
||
|
||
if (hitRateNum < 30) {
|
||
issues.add('缓存命中率过低 (${hitRateNum.toStringAsFixed(1)}%)');
|
||
}
|
||
|
||
// 检查平均解析时间
|
||
final avgParseTime = parser._totalParseCount > 0
|
||
? (parser._totalParseTime / parser._totalParseCount)
|
||
: 0.0;
|
||
|
||
if (avgParseTime > 500) {
|
||
issues.add('平均解析时间过长 (${avgParseTime.toStringAsFixed(1)}ms)');
|
||
}
|
||
|
||
// 检查队列长度
|
||
if (parser._parseQueue.length > 10) {
|
||
issues.add('解析队列过长 (${parser._parseQueue.length})');
|
||
}
|
||
|
||
return {
|
||
'isHealthy': issues.isEmpty,
|
||
'issues': issues,
|
||
'stats': stats,
|
||
'recommendations': _generateRecommendations(issues),
|
||
};
|
||
}
|
||
|
||
/// 生成优化建议
|
||
static List<String> _generateRecommendations(List<String> issues) {
|
||
final recommendations = <String>[];
|
||
|
||
if (issues.any((issue) => issue.contains('缓存命中率'))) {
|
||
recommendations.add('增加预加载范围');
|
||
recommendations.add('检查缓存键生成逻辑');
|
||
recommendations.add('考虑增加缓存大小');
|
||
}
|
||
|
||
if (issues.any((issue) => issue.contains('解析时间'))) {
|
||
recommendations.add('检查内容复杂度');
|
||
recommendations.add('考虑内容预处理');
|
||
recommendations.add('增加并发解析数量');
|
||
}
|
||
|
||
if (issues.any((issue) => issue.contains('队列'))) {
|
||
recommendations.add('减少同时触发的解析请求');
|
||
recommendations.add('提高高优先级任务处理速度');
|
||
recommendations.add('检查是否有解析死锁');
|
||
}
|
||
|
||
return recommendations;
|
||
}
|
||
|
||
/// 智能缓存预热 - 新增功能
|
||
static Future<void> warmupCache({
|
||
List<String>? priorityContents,
|
||
int warmupSize = 10,
|
||
}) async {
|
||
final parser = DocumentParser();
|
||
|
||
AppLogger.i('DocumentParser', '开始缓存预热...');
|
||
|
||
// 预热常见的文档格式
|
||
final commonFormats = [
|
||
'[{"insert":"\\n"}]', // 空文档
|
||
'[{"insert":"测试文本\\n"}]', // 简单文本
|
||
'[{"insert":"测试文本\\n","attributes":{"bold":true}}]', // 带格式文本
|
||
'简单纯文本内容', // 纯文本
|
||
'{"insert":"旧格式文档\\n"}', // 旧格式
|
||
];
|
||
|
||
// 预热优先内容
|
||
if (priorityContents != null) {
|
||
await preloadDocuments(
|
||
priorityContents.take(warmupSize).toList(),
|
||
maxPreloadConcurrency: 3,
|
||
);
|
||
}
|
||
|
||
// 预热常见格式
|
||
await preloadDocuments(
|
||
commonFormats,
|
||
cacheKeys: List.generate(commonFormats.length, (i) => 'warmup_format_$i'),
|
||
maxPreloadConcurrency: 2,
|
||
);
|
||
|
||
AppLogger.i('DocumentParser', '缓存预热完成');
|
||
}
|
||
}
|
||
|
||
/// 隔离中的解析函数
|
||
Document _isolateParseFunction(String content) {
|
||
try {
|
||
if (content.isEmpty) {
|
||
return Document.fromJson([{'insert': '\n'}]);
|
||
}
|
||
|
||
// 优化的JSON解析
|
||
if (content.trim().startsWith('[') || content.trim().startsWith('{')) {
|
||
final jsonData = jsonDecode(content);
|
||
List<Map<String, dynamic>> ops;
|
||
|
||
if (jsonData is List) {
|
||
ops = jsonData.cast<Map<String, dynamic>>();
|
||
} else if (jsonData is Map && jsonData.containsKey('ops')) {
|
||
// 处理 {"ops": [...]} 格式
|
||
ops = (jsonData['ops'] as List).cast<Map<String, dynamic>>();
|
||
} else if (jsonData is Map) {
|
||
ops = [jsonData.cast<String, dynamic>()];
|
||
} else {
|
||
// 转换为纯文本处理
|
||
return Document.fromJson([{'insert': '$content\n'}]);
|
||
}
|
||
|
||
// 🚀 新增：检查和记录样式属性
|
||
bool hasStyleAttributes = false;
|
||
for (final op in ops) {
|
||
if (op.containsKey('attributes')) {
|
||
hasStyleAttributes = true;
|
||
final attributes = op['attributes'] as Map<String, dynamic>?;
|
||
if (attributes != null) {
|
||
// 记录发现的样式属性
|
||
AppLogger.d('DocumentParser/_isolateParseFunction',
|
||
'🎨 发现样式属性: ${attributes.keys.join(', ')}');
|
||
|
||
// 特别记录颜色属性
|
||
if (attributes.containsKey('color')) {
|
||
AppLogger.d('DocumentParser/_isolateParseFunction',
|
||
'🎨 文字颜色: ${attributes['color']}');
|
||
}
|
||
if (attributes.containsKey('background')) {
|
||
AppLogger.d('DocumentParser/_isolateParseFunction',
|
||
'🎨 背景颜色: ${attributes['background']}');
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (hasStyleAttributes) {
|
||
AppLogger.i('DocumentParser/_isolateParseFunction',
|
||
'🎨 解析包含样式属性的内容，操作数量: ${ops.length}');
|
||
}
|
||
|
||
// 确保最后一个操作以换行符结尾
|
||
if (ops.isNotEmpty) {
|
||
final lastOp = ops.last;
|
||
if (lastOp.containsKey('insert')) {
|
||
final insertText = lastOp['insert'].toString();
|
||
if (!insertText.endsWith('\n')) {
|
||
// 如果最后一个insert不以换行符结尾，添加一个新的换行符操作
|
||
ops.add({'insert': '\n'});
|
||
}
|
||
} else {
|
||
// 如果最后一个操作不包含insert，添加换行符
|
||
ops.add({'insert': '\n'});
|
||
}
|
||
} else {
|
||
// 如果ops为空，添加一个换行符
|
||
ops = [{'insert': '\n'}];
|
||
}
|
||
|
||
return Document.fromJson(ops);
|
||
}
|
||
|
||
// 处理普通文本
|
||
return Document.fromJson([{'insert': '$content\n'}]);
|
||
|
||
} catch (e) {
|
||
// 解析失败时的备用方案 - 增强错误信息
|
||
AppLogger.e('DocumentParser/_isolateParseFunction',
|
||
'解析失败，内容长度: ${content.length}, 错误: $e');
|
||
|
||
return Document.fromJson([
|
||
{'insert': '解析错误: ${e.toString()}\n'},
|
||
{'insert': content.length > 200 ? '${content.substring(0, 200)}...\n' : '$content\n'},
|
||
]);
|
||
}
|
||
}
|
||
|
||
/// 缓存的文档数据
|
||
class _CachedDocument {
|
||
final Document document;
|
||
final int contentSize;
|
||
DateTime accessTime;
|
||
|
||
_CachedDocument({
|
||
required this.document,
|
||
required this.contentSize,
|
||
required this.accessTime,
|
||
});
|
||
}
|
||
|
||
/// 解析请求
|
||
class _ParseRequest {
|
||
final String content;
|
||
final String cacheKey;
|
||
final int priority;
|
||
final Completer<Document> completer;
|
||
final bool useCache;
|
||
|
||
_ParseRequest({
|
||
required this.content,
|
||
required this.cacheKey,
|
||
required this.priority,
|
||
required this.completer,
|
||
required this.useCache,
|
||
});
|
||
} |