# fast-electorn

**Repository Path**: czykeith/fast-electorn

## Basic Information

- **Project Name**: fast-electorn
- **Description**: No description available
- **Primary Language**: JavaScript
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-12-04
- **Last Updated**: 2026-02-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Fast Electron 应用框架

Fast Electron 是一个基于 Electron 的快速开发框架，提供了丰富的功能和组件，旨在简化 Electron 应用的开发流程，提高开发效率。

## 📋 目录

- [功能特性](#功能特性)
- [HTTP客户端工具使用指南](#http客户端工具使用指南)
- [全局数据管理器使用指南](#全局数据管理器使用指南)
- [进程管理器使用指南](#进程管理器使用指南)
- [UPnP端口映射管理器使用指南](#upnp端口映射管理器使用指南)
- [本地数据库管理器使用指南](#本地数据库管理器使用指南)
- [WebSocket管理器使用指南](#websocket管理器使用指南)
- [消息管理器使用指南](#消息管理器使用指南)
- [系统资源监控管理器使用指南](#系统资源监控管理器使用指南)
- [自定义对话框使用指南](#自定义对话框使用指南)
- [HTTP服务管理器使用指南](#http服务管理器使用指南)
- [自定义窗口标题栏使用指南](#自定义窗口标题栏使用指南)
- [菜单选择对话框使用指南](#菜单选择对话框使用指南)
- [日志管理器使用指南](#日志管理器使用指南)

## ✨ 功能特性

Fast Electron 框架提供了以下核心功能模块：

- **HTTP客户端工具** - 简洁易用的网络请求接口，支持常见的HTTP方法
- **全局数据管理** - 应用内数据共享机制，支持数据订阅和响应式更新
- **进程管理** - 子进程执行、监控和管理，支持自动重试机制
- **UPnP端口映射管理** - 完整的UPnP端口映射解决方案，支持端口段映射和自动续期
- **本地数据库管理** - 高性能基于文件的数据库，支持高级查询、批量操作和自动备份
- **WebSocket连接管理** - 完整的WebSocket解决方案，支持重连、心跳检测、消息队列和请求-响应模式
- **消息管理器** - 主进程与渲染进程双向通信，提供简单易用的消息传递接口
- **系统资源监控管理** - 系统资源信息收集，包括CPU和内存使用情况
- **HTTP服务管理器** - 轻量级HTTP服务器，支持动态API接口管理
- **自定义窗口标题栏** - 完全自定义的窗口标题栏，支持最小化、最大化、关闭等操作
- **自定义对话框系统** - 提示框、确认框、通知和菜单选择对话框
- **日志管理器** - 全局日志输出到文件，支持日志级别、日志轮转和自动清理

---

## HTTP客户端工具使用指南

HTTP客户端工具提供了一个简单易用的网络请求接口，支持常见的HTTP方法（GET、POST、PUT、DELETE等），并提供了完善的配置管理和错误处理机制。

### 创建HTTP客户端实例

```javascript
// 在主进程或渲染进程中
import { HttpClient } from './electron/utils/HttpClient.js';

// 创建默认配置的HTTP客户端实例
const httpClient = new HttpClient();

// 或者带配置选项
const httpClientWithConfig = new HttpClient({
  baseURL: 'https://api.example.com',
  headers: {
    'Authorization': 'Bearer your-token',
    'Content-Type': 'application/json'
  },
  timeout: 5000  // 5秒超时
});
```

### GET请求

```javascript
// 基本GET请求
const userData = await httpClient.get('/users/123');
console.log('用户数据:', userData);

// 带查询参数的GET请求
const searchResults = await httpClient.get('/search', {
  q: 'keyword',
  limit: 10
});
console.log('搜索结果:', searchResults);

// 带自定义选项的GET请求
const response = await httpClient.get('/data', {}, {
  headers: {
    'Custom-Header': 'value'
  },
  timeout: 3000
});
```

### POST请求

```javascript
// 发送JSON数据
const newUser = await httpClient.post('/users', {
  name: '张三',
  email: 'zhangsan@example.com'
});
console.log('新用户:', newUser);

// 发送表单数据
const formData = new FormData();
formData.append('name', '张三');
formData.append('email', 'zhangsan@example.com');

const result = await httpClient.post('/users', formData, {
  headers: {
    'Content-Type': 'multipart/form-data'
  }
});
```

### PUT请求

```javascript
// 更新用户信息
const updatedUser = await httpClient.put('/users/123', {
  name: '李四',
  email: 'lisi@example.com'
});
console.log('更新后的用户:', updatedUser);
```

### DELETE请求

```javascript
// 删除用户
const result = await httpClient.delete('/users/123');
console.log('删除结果:', result);
```

### 配置管理

```javascript
// 设置默认请求头
httpClient.setDefaultHeaders({
  'Authorization': 'Bearer new-token',
  'X-API-Key': 'your-api-key'
});

// 设置基础URL
httpClient.setBaseURL('https://new-api.example.com');

// 设置超时时间
httpClient.setTimeout(8000); // 8秒超时
```

### 错误处理

```javascript
try {
  const data = await httpClient.get('/users/123');
  console.log('用户数据:', data);
} catch (error) {
  if (error.message.includes('timeout')) {
    console.error('请求超时');
  } else if (error.message.includes('HTTP Error')) {
    console.error('HTTP错误:', error.message);
  } else {
    console.error('其他错误:', error);
  }
}
```

### 完整使用示例

```javascript
import { HttpClient } from './electron/utils/HttpClient.js';

// 创建HTTP客户端实例
const apiClient = new HttpClient({
  baseURL: 'https://jsonplaceholder.typicode.com',
  headers: {
    'Content-Type': 'application/json'
  },
  timeout: 5000
});

// 获取用户列表
async function fetchUsers() {
  try {
    const users = await apiClient.get('/users');
    console.log('用户列表:', users);
    return users;
  } catch (error) {
    console.error('获取用户列表失败:', error);
    throw error;
  }
}

// 创建新用户
async function createUser(userData) {
  try {
    const newUser = await apiClient.post('/users', userData);
    console.log('创建的新用户:', newUser);
    return newUser;
  } catch (error) {
    console.error('创建用户失败:', error);
    throw error;
  }
}

// 使用示例
fetchUsers().then(users => {
  console.log(`获取到 ${users.length} 个用户`);
  
  // 创建一个新用户
  return createUser({
    name: '张三',
    username: 'zhangsan',
    email: 'zhangsan@example.com'
  });
}).catch(error => {
  console.error('操作失败:', error);
});
```


## 全局数据管理器使用指南

全局数据管理器提供了一个简单的数据共享机制，可以在整个应用程序中共享数据。

### 创建全局数据管理器实例

```javascript
// 通常在应用启动时创建全局实例
import { dataManager } from './electron/managers/DataManager.js';
```

### 设置和获取数据

```javascript
// 设置数据
dataManager.set('userName', '张三');
dataManager.set('userPreferences', { theme: 'dark', language: 'zh-CN' });

// 获取数据
const userName = dataManager.get('userName');
const userPreferences = dataManager.get('userPreferences');
console.log(userName); // 输出: 张三
console.log(userPreferences); // 输出: { theme: 'dark', language: 'zh-CN' }
```

### 删除数据

```javascript
// 删除数据
dataManager.remove('userName');
const userName = dataManager.get('userName');
console.log(userName); // 输出: undefined
```

### 订阅数据变化

```javascript
// 订阅数据变化
const callback = (newValue) => {
  console.log('数据发生变化:', newValue);
};
dataManager.subscribe('userName', callback);

// 当数据发生变化时，订阅的回调函数会被调用
dataManager.set('userName', '李四'); // 输出: 数据发生变化: 李四

// 取消订阅
dataManager.unsubscribe('userName', callback);
```

### 获取所有数据

```javascript
// 获取所有数据
const allData = dataManager.getAll();
console.log(allData); // 输出所有存储的数据
```

## 进程管理器使用指南

进程管理器可以帮助您轻松地执行、停止和监控子进程，并支持进程异常退出时的自动重试机制。支持输出到文件或控制台，提供完善的进程状态监控和事件系统。

### 创建进程管理器实例

```javascript
// 在主进程中
import { ProcessManager } from './electron/managers/ProcessManager.js';
const processManager = new ProcessManager();
```

### 执行新进程

```javascript
// 执行一个新进程
const proc = processManager.execute('my-process', 'node', ['app.js'], {
  cwd: '/path/to/working/directory',
  env: { NODE_ENV: 'production' }
});
```

### 配置进程重试机制

```javascript
// 为特定进程设置重试配置
processManager.setRetryConfig('my-process', {
  maxRetries: 5,      // 最大重试次数，默认3次
  retryInterval: 3000 // 重试间隔（毫秒），默认5000ms
});
```

### 监听进程事件

```javascript
// 监听进程启动事件
processManager.on('process-start', ({ id, process }) => {
  console.log(`进程 ${id} 已启动`);
});

// 监听进程停止事件
processManager.on('process-stop', ({ id, code, signal }) => {
  console.log(`进程 ${id} 已停止，退出码：${code}`);
});

// 监听进程错误事件
processManager.on('process-error', ({ id, error }) => {
  console.error(`进程 ${id} 发生错误：`, error);
});

// 监听标准输出
processManager.on('stdout', ({ id, data }) => {
  console.log(`进程 ${id} 输出：${data}`);
});

// 监听错误输出
processManager.on('stderr', ({ id, data }) => {
  console.error(`进程 ${id} 错误输出：${data}`);
});
```

### 停止进程

```javascript
// 正常停止进程
await processManager.stop('my-process');

// 强制停止进程
await processManager.stop('my-process', { force: true });

// 设置超时时间停止进程
await processManager.stop('my-process', { timeout: 10000 });
```

### 查询进程状态

```javascript
// 获取特定进程状态
const status = processManager.getStatus('my-process');
console.log(status); 
// 输出示例：
// {
//   id: 'my-process',
//   command: 'node',
//   args: ['app.js'],
//   status: 'running',
//   startTime: 2025-12-11T08:30:00.000Z,
//   endTime: undefined,
//   exitCode: undefined,
//   exitSignal: undefined,
//   retryCount: 0  // 重试次数
// }

// 获取所有进程状态
const allStatuses = processManager.getAllStatus();
console.log(allStatuses);
```

### 获取进程输出

```javascript
// 获取进程的标准输出
const stdout = processManager.getStdout('my-process');
console.log('标准输出：', stdout);

// 获取进程的错误输出
const stderr = processManager.getStderr('my-process');
console.log('错误输出：', stderr);
```

### 配置参数输出

进程管理器支持多种输出配置选项：

```javascript
// 禁用自动输出到控制台
const proc = processManager.execute('my-process', 'node', ['app.js'], {
  output: false // 不自动输出到控制台
});

// 将所有输出写入单个文件
const proc2 = processManager.execute('my-process2', 'node', ['app.js'], {
  outputFile: '/path/to/output.log' // 将 stdout 和 stderr 都写入同一个文件
});

// 分别将 stdout 和 stderr 写入不同文件
const proc3 = processManager.execute('my-process3', 'node', ['app.js'], {
  stdoutFile: '/path/to/stdout.log',  // 标准输出文件
  stderrFile: '/path/to/stderr.log'  // 错误输出文件
});

// 同时输出到控制台和文件
const proc4 = processManager.execute('my-process4', 'node', ['app.js'], {
  outputFile: '/path/to/output.log'  // 输出到文件
  // output 默认为 true，所以也会输出到控制台
});
```

注意：如果同时指定了 `outputFile` 和 `stdoutFile`/`stderrFile`，则优先使用 `outputFile`，忽略 `stdoutFile` 和 `stderrFile`。

### 进程自动重试机制

进程管理器内置了自动重试机制，当进程异常退出时会自动尝试重启：

1. 当进程因错误或非零退出码退出时触发重试
2. 根据配置的最大重试次数进行有限重试
3. 每次重试之间有一定的时间间隔
4. 重试过程中会记录重试次数

```javascript
// 配置重试机制
processManager.setRetryConfig('critical-service', {
  maxRetries: 5,      // 最多重试5次
  retryInterval: 3000 // 每次重试间隔3秒
});

// 执行关键服务进程
processManager.execute('critical-service', './service.exe', [], {
  cwd: '/path/to/service'
});
```

当 `critical-service` 进程意外退出时，系统会自动尝试重启，直到达到最大重试次数为止。

## UPnP端口映射管理器使用指南

UPnP端口映射管理器提供了一套完整的UPnP端口映射解决方案，包括单个端口映射、端口段映射、自动续期、状态监控等功能，支持TCP和UDP协议。

### 创建UPnP管理器实例

```javascript
// 在主进程中
import { UPnPManager } from './electron/managers/UpnpManager.js';

// 创建UPnP管理器实例
const upnpManager = new UPnPManager();
```

### 检查UPnP设备是否可用

```javascript
// 检查UPnP设备是否可用
const isAvailable = await upnpManager.isAvailable();
if (isAvailable) {
  console.log('UPnP设备可用');
} else {
  console.log('UPnP设备不可用');
}
```

### 映射单个端口

```javascript
// 映射单个TCP端口
const success = await upnpManager.mapPort(8080, 8080, 'TCP', 'Web Server', 3600);
if (success) {
  console.log('端口映射成功');
} else {
  console.log('端口映射失败');
}

// 映射单个UDP端口（永久映射）
const udpSuccess = await upnpManager.mapPort(53, 53, 'UDP', 'DNS Server', 0);
if (udpSuccess) {
  console.log('UDP端口映射成功');
} else {
  console.log('UDP端口映射失败');
}
```

### 映射端口段

```javascript
// 映射端口段 (8000-8010 -> 8000-8010)
const results = await upnpManager.mapPortRange(8000, 8010, 8000, 'TCP', 'Media Server', 3600);
console.log('端口段映射结果:', results);

// 处理映射结果
results.forEach(result => {
  if (result.success) {
    console.log(`端口 ${result.externalPort} 映射成功`);
  } else {
    console.error(`端口 ${result.externalPort} 映射失败:`, result.error);
  }
});
```

### 删除单个端口映射

```javascript
// 删除TCP端口映射
const success = await upnpManager.unmapPort(8080, 'TCP');
if (success) {
  console.log('端口映射删除成功');
} else {
  console.log('端口映射删除失败');
}
```

### 删除端口段映射

```javascript
// 删除端口段映射
const results = await upnpManager.unmapPortRange(8000, 8010, 'TCP');
console.log('端口段映射删除结果:', results);

// 处理删除结果
results.forEach(result => {
  if (result.success) {
    console.log(`端口 ${result.externalPort} 映射删除成功`);
  } else {
    console.error(`端口 ${result.externalPort} 映射删除失败:`, result.error);
  }
});
```

### 获取当前映射信息

```javascript
// 获取所有当前映射
const mappings = await upnpManager.getCurrentMappings();
console.log('当前端口映射:', mappings);

// 获取已映射的端口列表（本地缓存）
const mappedPorts = upnpManager.getMappedPorts();
console.log('已映射端口:', mappedPorts);
```

### 获取管理器状态

```javascript
// 获取管理器当前状态
const status = upnpManager.getStatus();
console.log('UPnP管理器状态:', status);
// 可能的状态值：
// uninitialized - 未初始化
// initialized - 已初始化
// available - 可用
// mapped - 已映射端口
// closed - 已关闭
// error - 错误
```

### 关闭UPnP管理器

```javascript
// 关闭UPnP管理器，清理资源
upnpManager.close();
```

### 完整使用示例

```javascript
import { UPnPManager } from './electron/managers/UpnpManager.js';

// 创建UPnP管理器实例
const upnpManager = new UPnPManager();

async function setupPortMapping() {
  try {
    // 检查UPnP是否可用
    const isAvailable = await upnpManager.isAvailable();
    if (!isAvailable) {
      console.log('UPnP不可用，跳过端口映射');
      return;
    }
    
    // 映射Web服务器端口
    const webSuccess = await upnpManager.mapPort(8080, 8080, 'TCP', 'Web Server', 3600);
    console.log('Web服务器端口映射:', webSuccess ? '成功' : '失败');
    
    // 映射RTSP流媒体端口段
    const rtspResults = await upnpManager.mapPortRange(8554, 8564, 8554, 'TCP', 'RTSP Server', 3600);
    console.log('RTSP端口段映射结果:');
    rtspResults.forEach(result => {
      console.log(`  ${result.externalPort}: ${result.success ? '成功' : '失败'}`);
    });
    
    // 映射DNS端口（永久映射）
    const dnsSuccess = await upnpManager.mapPort(53, 53, 'UDP', 'DNS Server', 0);
    console.log('DNS端口映射:', dnsSuccess ? '成功' : '失败');
    
    // 显示当前所有映射
    const mappings = await upnpManager.getCurrentMappings();
    console.log('当前所有端口映射:');
    mappings.forEach(mapping => {
      console.log(`  ${mapping.public.port}/${mapping.protocol}: ${mapping.description}`);
    });
  } catch (error) {
    console.error('设置端口映射时出错:', error);
  }
}

// 执行端口映射设置
setupPortMapping();
```

## 本地数据库管理器使用指南

本地数据库管理器提供了一个高性能、功能丰富的基于文件的数据库解决方案，支持高级查询、批量操作、自动备份等功能。采用延迟写入机制和原子性写入，确保数据安全性和性能。

### 创建数据库实例

```javascript
// 在主进程中
import { DatabaseManager } from './electron/managers/DatabaseManager.js';

// 创建数据库实例
const db = new DatabaseManager('myapp');

// 或者带完整配置选项
const dbWithConfig = new DatabaseManager('myapp', {
  dataDir: '/path/to/data',        // 数据存储目录，默认为 app.getAppPath()/databases
  prettyPrint: true,                // 是否格式化JSON输出，默认为false
  autoSave: true,                   // 是否自动保存，默认为true
  saveDelay: 100,                   // 自动保存延迟（毫秒），默认100ms，用于批量操作性能优化
  enableBackup: true,               // 是否启用自动备份，默认为true
  backupInterval: 300000            // 备份间隔（毫秒），默认300000ms（5分钟）
});
```

### 插入数据

```javascript
// 插入一条记录，自动生成ID（优化后的ID生成算法）
const userId = db.insert('users', {
  name: '张三',
  email: 'zhangsan@example.com',
  age: 25
});

console.log('用户ID:', userId);

// 插入一条记录，指定ID
db.insert('users', {
  name: '李四',
  email: 'lisi@example.com',
  age: 30
}, 'user001');

// 批量插入记录（新增功能，性能优化）
const newUserIds = db.insertMany('users', [
  { name: '王五', email: 'wangwu@example.com', age: 28 },
  { name: '赵六', email: 'zhaoliu@example.com', age: 32 },
  { name: '孙七', email: 'sunqi@example.com', age: 29 }
]);
console.log('批量插入的ID:', newUserIds);
```

### 查询数据

#### 基础查询

```javascript
// 查询所有用户
const allUsers = db.find('users');
console.log('所有用户:', allUsers);

// 根据条件查询
const youngUsers = db.find('users', { age: 25 });
console.log('25岁的用户:', youngUsers);

// 使用函数作为查询条件
const adultUsers = db.find('users', (user) => user.age >= 18);
console.log('成年用户:', adultUsers);

// 查询单条记录
const user = db.findOne('users', { name: '张三' });
console.log('张三的信息:', user);

// 根据ID直接获取（新增功能，避免全表扫描，性能优化）
const userById = db.findById('users', userId);
console.log('通过ID获取用户:', userById);

// 获取记录数量
const userCount = db.count('users');
console.log('用户总数:', userCount);
```

#### 高级查询（新增功能）

```javascript
// 数值范围查询
const middleAgedUsers = db.find('users', {
  age: { $gte: 25, $lt: 40 }  // 年龄大于等于25且小于40
});

// 不等于查询
const nonAdmins = db.find('users', {
  role: { $ne: 'admin' }
});

// 数组包含查询
const vipUsers = db.find('users', {
  level: { $in: ['gold', 'platinum', 'diamond'] }
});

// 数组不包含查询
const normalUsers = db.find('users', {
  level: { $nin: ['vip', 'premium'] }
});

// 正则表达式查询（模糊搜索）
const zhangUsers = db.find('users', {
  name: { $regex: '张', $flags: 'i' }  // 不区分大小写
});

// 组合查询条件
const complexQuery = db.find('users', {
  age: { $gte: 18, $lte: 65 },
  name: { $regex: '张', $flags: 'i' },
  status: { $ne: 'deleted' }
});
```

#### 排序和分页（新增功能）

```javascript
// 按年龄升序排序
const sortedByAge = db.find('users', {}, {
  sort: { field: 'age', order: 'asc' }
});

// 按创建时间降序排序（简化写法）
const recentUsers = db.find('users', {}, {
  sort: '_createdAt',  // 直接指定字段名，默认为降序
  limit: 10            // 只返回前10条
});

// 分页查询
const page1 = db.find('users', {}, {
  sort: { field: '_createdAt', order: 'desc' },
  limit: 20,
  skip: 0              // 第一页，跳过0条
});

const page2 = db.find('users', {}, {
  sort: { field: '_createdAt', order: 'desc' },
  limit: 20,
  skip: 20             // 第二页，跳过20条
});

// 组合使用：高级查询 + 排序 + 分页
const searchResults = db.find('users', {
  age: { $gte: 18, $lt: 65 },
  name: { $regex: '张', $flags: 'i' }
}, {
  sort: { field: 'age', order: 'desc' },
  limit: 10,
  skip: 0
});
```

### 更新数据

#### 基础更新

```javascript
// 更新单条记录
db.update('users', { name: '张三' }, { age: 26 });

// 更新多条记录
db.update('users', { age: 25 }, { age: 26 });

// 只更新第一条匹配的记录
db.update('users', { age: 25 }, { age: 26 }, { multi: false });

// 更新所有记录
db.update('users', {}, { status: 'active' });

// Upsert：如果没有匹配记录则插入（新增功能）
db.update('users', { email: 'newuser@example.com' }, {
  name: '新用户',
  age: 25
}, { upsert: true });
```

#### 更新操作符（新增功能）

```javascript
// $inc: 递增/递减数值
db.update('users', { name: '张三' }, {
  $inc: { loginCount: 1, score: 10 }  // loginCount加1，score加10
});

// $set: 设置字段值
db.update('users', { name: '张三' }, {
  $set: { 
    lastLogin: new Date().toISOString(),
    status: 'online'
  }
});

// $unset: 删除字段
db.update('users', { name: '张三' }, {
  $unset: { temporaryData: true }  // 删除temporaryData字段
});

// $push: 向数组字段追加元素
db.update('users', { name: '张三' }, {
  $push: { tags: 'vip' }  // 向tags数组添加'vip'
});

// 组合使用多个操作符
db.update('users', { name: '张三' }, {
  $inc: { loginCount: 1 },
  $set: { lastLogin: new Date().toISOString() },
  $push: { loginHistory: new Date().toISOString() }
});
```

#### 批量更新（新增功能）

```javascript
// 批量执行多个更新操作
const updateCount = db.updateMany('users', [
  {
    query: { age: 25 },
    updates: { $inc: { score: 5 } }
  },
  {
    query: { age: { $gte: 30 } },
    updates: { $set: { level: 'senior' } },
    options: { multi: true }
  }
]);
console.log(`批量更新了 ${updateCount} 条记录`);
```

### 删除数据

```javascript
// 删除特定条件的记录
const removedCount = db.remove('users', { age: 25 });
console.log(`删除了 ${removedCount} 条记录`);

// 删除所有记录
db.remove('users', {});

// 使用高级查询条件删除
db.remove('users', {
  status: { $ne: 'active' },
  lastLogin: { $lt: '2024-01-01' }
});
```

### 数据备份和恢复（新增功能）

```javascript
// 手动创建备份
const backupPath = db.createBackup();
console.log('备份文件路径:', backupPath);

// 从备份恢复
const restored = db.restoreFromBackup(backupPath);
if (restored) {
  console.log('数据恢复成功');
} else {
  console.log('数据恢复失败');
}

// 从最新备份恢复（不指定备份路径）
db.restoreFromBackup();
```

### 数据库管理（新增功能）

```javascript
// 获取数据库统计信息
const stats = db.getStats();
console.log('数据库统计:', stats);
// 输出示例：
// {
//   collections: {
//     users: 100,
//     products: 50
//   },
//   totalRecords: 150,
//   databaseSize: 102400  // 文件大小（字节）
// }

// 清理数据库（移除空集合）
const compacted = db.compact();
console.log('数据库已压缩:', compacted);

// 获取所有集合名称
const collections = db.getCollections();
console.log('所有集合:', collections);

// 清空集合
db.clearCollection('users');

// 手动保存数据库（当autoSave为false时有用，或需要立即保存）
db.save();

// 重新加载数据库（从文件重新读取）
db.reload();

// 删除整个数据库
db.drop();

// 销毁实例，清理资源（包括定时器）
db.destroy();
```

### 性能优化特性

1. **延迟写入机制**：使用防抖机制，批量操作时自动合并写入，减少磁盘I/O
2. **原子性写入**：使用临时文件+原子替换，确保数据不会因写入中断而损坏
3. **ID直接访问**：`findById()` 方法避免全表扫描，O(1)时间复杂度
4. **批量操作**：`insertMany()` 和 `updateMany()` 支持批量操作，自动优化保存时机

### 完整使用示例

```javascript
import { DatabaseManager } from './electron/managers/DatabaseManager.js';

// 创建数据库实例
const db = new DatabaseManager('myapp', {
  autoSave: true,
  saveDelay: 100,
  enableBackup: true,
  backupInterval: 300000
});

// 初始化用户数据
async function initUsers() {
  // 批量插入用户
  const userIds = db.insertMany('users', [
    { name: '张三', email: 'zhangsan@example.com', age: 25, role: 'user' },
    { name: '李四', email: 'lisi@example.com', age: 30, role: 'admin' },
    { name: '王五', email: 'wangwu@example.com', age: 28, role: 'user' }
  ]);
  
  // 使用ID直接获取（性能优化）
  const user1 = db.findById('users', userIds[0]);
  console.log('用户1:', user1);
}

// 查询和分页
function getUserList(page = 1, pageSize = 10) {
  return db.find('users', {}, {
    sort: { field: '_createdAt', order: 'desc' },
    limit: pageSize,
    skip: (page - 1) * pageSize
  });
}

// 高级搜索
function searchUsers(keyword, minAge, maxAge) {
  return db.find('users', {
    name: { $regex: keyword, $flags: 'i' },
    age: { $gte: minAge, $lte: maxAge }
  }, {
    sort: { field: 'age', order: 'asc' }
  });
}

// 更新用户登录信息
function updateUserLogin(email) {
  db.update('users', { email }, {
    $inc: { loginCount: 1 },
    $set: { lastLogin: new Date().toISOString() }
  });
}

// 获取统计信息
function getStats() {
  const stats = db.getStats();
  console.log(`数据库包含 ${stats.totalRecords} 条记录`);
  console.log(`文件大小: ${(stats.databaseSize / 1024).toFixed(2)} KB`);
  return stats;
}

// 定期备份
setInterval(() => {
  const backupPath = db.createBackup();
  console.log('自动备份完成:', backupPath);
}, 3600000); // 每小时备份一次

// 应用退出时确保数据已保存
process.on('beforeExit', () => {
  db.save();
  db.destroy();
});
```

### 注意事项

1. **自动备份**：默认每5分钟自动备份，只保留最近10个备份文件
2. **延迟保存**：默认延迟100ms保存，批量操作时会自动优化
3. **ID唯一性**：指定ID插入时，如果ID已存在会抛出错误
4. **数据完整性**：使用原子性写入，确保写入过程中断电不会损坏数据
5. **性能考虑**：大量数据查询建议使用分页，避免一次性加载过多数据
6. **资源清理**：应用退出时调用 `destroy()` 方法清理定时器和资源

## WebSocket管理器使用指南

WebSocket管理器提供了一套完整的WebSocket连接管理方案，包括连接、重连、心跳检测、消息队列、事件系统、消息路由、请求-响应模式等功能。支持指数退避重连策略和详细的连接统计信息。

### 创建WebSocket管理器实例

```javascript
// 在主进程或渲染进程中
import { WebsocketManager } from './electron/managers/WebsocketManager.js';

// 创建WebSocket管理器实例
const wsManager = new WebsocketManager('ws://localhost:8080');

// 或者带完整配置选项
const wsManagerWithConfig = new WebsocketManager('ws://localhost:8080', {
  reconnectInterval: 10000,          // 基础重连间隔时间(毫秒)，默认10000
  maxReconnectAttempts: 5,            // 最大重连次数，默认5
  infiniteReconnect: false,           // 是否无限重连，默认false
  exponentialBackoff: true,           // 是否启用指数退避重连，默认true
  maxReconnectInterval: 60000,        // 最大重连间隔(毫秒)，默认60000
  heartbeatInterval: 30000,           // 心跳间隔时间(毫秒)，默认30000
  heartbeatTimeout: 5000,             // 心跳超时时间(毫秒)，默认5000
  enableMessageQueue: true,           // 是否启用消息队列，默认true
  maxQueueSize: 1000,                 // 消息队列最大长度，默认1000
  requestTimeout: 10000,              // 请求-响应超时时间(毫秒)，默认10000
  protocols: ['chat', 'superchat'],   // WebSocket子协议数组（可选）
  headers: {                          // 自定义请求头（可选，仅Node.js环境）
    'Authorization': 'Bearer token'
  }
});
```

### 连接到WebSocket服务器

```javascript
// 建立连接
wsManager.connect();
```

### 处理连接事件

#### 兼容旧版API（单个回调）

```javascript
// 设置连接成功回调
wsManager.onOpen(() => {
  console.log('WebSocket连接已建立');
});

// 设置接收消息回调
wsManager.onMessage((event) => {
  console.log('收到消息:', event.data);
});

// 设置连接关闭回调
wsManager.onClose(() => {
  console.log('WebSocket连接已关闭');
});

// 设置错误处理回调
wsManager.onError((error) => {
  console.error('WebSocket发生错误:', error);
});

// 设置重连回调
wsManager.onReconnect((attempt) => {
  console.log(`正在尝试第${attempt}次重连`);
});

// 设置重连失败回调
wsManager.onReconnectFailed(() => {
  console.log('WebSocket重连失败');
});
```

#### 新版事件系统（支持多个监听器）

```javascript
// 添加多个监听器
const unsubscribe1 = wsManager.on('open', (event) => {
  console.log('监听器1: 连接已建立');
});

const unsubscribe2 = wsManager.on('open', (event) => {
  console.log('监听器2: 连接已建立');
});

// 移除监听器
unsubscribe1(); // 或使用 wsManager.off('open', listener)

// 监听消息事件
wsManager.on('message', (event) => {
  console.log('收到消息:', event.data);
});

// 监听错误事件
wsManager.on('error', (error) => {
  console.error('发生错误:', error);
});
```

### 消息类型路由（新增功能）

根据消息类型自动路由到不同的处理器：

```javascript
// 注册消息类型处理器
wsManager.onMessageType('notification', (message) => {
  console.log('收到通知:', message);
  // 显示通知UI
});

wsManager.onMessageType('chat', (message) => {
  console.log('收到聊天消息:', message);
  // 更新聊天界面
});

wsManager.onMessageType('error', (message) => {
  console.error('服务器错误:', message);
  // 显示错误提示
});

// 当收到 { type: 'notification', content: '新消息' } 时，
// 会自动调用对应的处理器，无需在通用message回调中手动判断
```

### 发送消息

#### 基础发送

```javascript
// 发送文本消息
wsManager.send('Hello Server');

// 发送JSON对象
wsManager.send({
  type: 'message',
  data: 'Hello Server'
});

// 发送二进制数据
const buffer = new ArrayBuffer(8);
wsManager.send(buffer);
```

#### 消息队列（新增功能）

当连接断开时，消息会自动加入队列，重连后自动发送：

```javascript
// 默认情况下，连接断开时消息会加入队列
wsManager.send({ type: 'important', data: '重要消息' });

// 禁用队列（连接断开时直接失败）
wsManager.send({ type: 'test' }, { queued: false });

// 获取队列长度
const queueLength = wsManager.getQueueLength();
console.log('队列中还有', queueLength, '条消息');

// 清空队列
wsManager.clearQueue();
```

#### 批量发送（新增功能）

```javascript
// 批量发送消息
const messages = [
  { type: 'msg1', data: '消息1' },
  { type: 'msg2', data: '消息2' },
  { type: 'msg3', data: '消息3' }
];

const successCount = wsManager.sendBatch(messages);
console.log(`成功发送 ${successCount} 条消息`);
```

### 请求-响应模式（新增功能）

发送消息后等待服务器响应，类似HTTP请求：

```javascript
// 发送请求并等待响应
try {
  const response = await wsManager.sendRequest({
    type: 'getUserInfo',
    userId: '123'
  });
  console.log('收到响应:', response);
} catch (error) {
  console.error('请求失败:', error.message);
}

// 自定义超时时间
const response = await wsManager.sendRequest(
  { type: 'query', data: 'test' },
  { timeout: 5000 }
);

// 服务器端需要返回带requestId的响应：
// { requestId: 123, data: { ... } }
// 或错误响应：
// { requestId: 123, error: '错误信息' }
```

### 控制连接状态

```javascript
// 手动关闭连接
wsManager.close();

// 手动重新连接
wsManager.reconnect();

// 获取当前连接状态
const isConnected = wsManager.getStatus();
console.log('连接状态:', isConnected);

// 获取WebSocket readyState
const readyState = wsManager.getReadyState();
// 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED

// 获取重试次数
const attempts = wsManager.getReconnectAttempts();
console.log('当前重试次数:', attempts);
```

### 连接统计信息（新增功能）

```javascript
// 获取连接统计信息
const stats = wsManager.getStats();
console.log('统计信息:', stats);
// 输出示例：
// {
//   isConnected: true,
//   reconnectAttempts: 0,
//   queueLength: 5,
//   pendingRequests: 2,
//   connectTime: 1699123456789,
//   disconnectTime: null,
//   totalMessagesSent: 150,
//   totalMessagesReceived: 200,
//   totalBytesSent: 20480,
//   totalBytesReceived: 40960,
//   reconnectCount: 3,
//   uptime: 3600000,
//   readyState: 1
// }

// 重置统计信息
wsManager.resetStats();
```

### 完整使用示例

```javascript
import { WebsocketManager } from './electron/managers/WebsocketManager.js';

// 创建WebSocket管理器实例
const wsManager = new WebsocketManager('ws://localhost:8080', {
  reconnectInterval: 5000,
  maxReconnectAttempts: 5,
  exponentialBackoff: true,
  enableMessageQueue: true
});

// 使用事件系统添加多个监听器
wsManager.on('open', () => {
  console.log('连接已建立');
  
  // 连接成功后发送认证信息
  wsManager.sendRequest({
    type: 'auth',
    token: 'your-token'
  }).then(response => {
    console.log('认证成功:', response);
  }).catch(error => {
    console.error('认证失败:', error);
  });
});

wsManager.on('close', () => {
  console.log('连接已关闭');
});

wsManager.on('error', (error) => {
  console.error('发生错误:', error);
});

wsManager.on('reconnect', (attempt) => {
  console.log(`正在尝试第${attempt}次重连`);
});

// 注册消息类型处理器
wsManager.onMessageType('notification', (message) => {
  console.log('收到通知:', message);
  // 显示通知UI
});

wsManager.onMessageType('chat', (message) => {
  console.log('收到聊天消息:', message);
  // 更新聊天界面
});

// 通用消息处理（所有消息都会触发）
wsManager.on('message', (event) => {
  console.log('收到消息事件:', event);
});

// 建立连接
wsManager.connect();

// 发送消息（如果连接断开会自动加入队列）
wsManager.send({
  type: 'chat',
  message: 'Hello World'
});

// 使用请求-响应模式
async function getUserInfo(userId) {
  try {
    const userInfo = await wsManager.sendRequest({
      type: 'getUserInfo',
      userId: userId
    }, { timeout: 5000 });
    return userInfo;
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return null;
  }
}

// 获取统计信息
setInterval(() => {
  const stats = wsManager.getStats();
  console.log('连接统计:', {
    uptime: Math.round(stats.uptime / 1000) + '秒',
    messagesSent: stats.totalMessagesSent,
    messagesReceived: stats.totalMessagesReceived,
    queueLength: stats.queueLength
  });
}, 60000);

// 应用退出时清理资源
process.on('beforeExit', () => {
  wsManager.destroy();
});
```

### 优化特性说明

1. **事件系统**：支持多个监听器，可以灵活添加/移除事件处理器
2. **消息队列**：连接断开时自动缓存消息，重连后自动发送，确保消息不丢失
3. **消息路由**：根据消息类型自动路由到不同的处理器，代码更清晰
4. **请求-响应模式**：类似HTTP请求，发送消息后等待响应，支持超时和错误处理
5. **指数退避重连**：智能重连策略，避免频繁重连对服务器造成压力
6. **连接统计**：详细的连接统计信息，便于监控和调试
7. **批量发送**：支持批量发送消息，提高效率

### 注意事项

1. **消息队列**：默认启用消息队列，连接断开时会自动缓存消息，队列满时会丢弃最旧的消息
2. **请求超时**：请求-响应模式的默认超时为10秒，可根据需要调整
3. **指数退避**：默认启用指数退避重连，重连间隔会逐渐增加，但不超过`maxReconnectInterval`
4. **资源清理**：应用退出时建议调用 `destroy()` 方法清理所有资源
5. **消息格式**：请求-响应模式需要服务器返回包含 `requestId` 的响应消息


## 消息管理器使用指南

消息管理器支持主进程与渲染进程之间的双向通信，提供简单易用的消息传递接口。

### 创建消息管理器实例

```javascript
// 在主进程中
import { MessageManager } from './electron/managers/MessageManager.js';
import { ipcMain } from 'electron';

// 创建消息管理器实例（需要传入 ipcMain）
const messageManager = new MessageManager(ipcMain);
```

### 主进程向渲染进程发送消息

#### 单向发送（不等待响应）

```javascript
// 向窗口发送单向消息
messageManager.sendToRendererOneway(mainWindow, 'channel-name', data1, data2, ...);
```

#### 双向发送（等待响应）

```javascript
// 发送消息并等待响应（默认30秒超时）
try {
  const result = await messageManager.sendToRenderer(mainWindow, 'channel-name', data1, data2, ...);
  console.log('收到渲染进程响应:', result);
} catch (error) {
  console.error('消息发送失败或超时:', error);
}
```

### 渲染进程向主进程发送消息

在渲染进程中可以通过全局暴露的 `messageManager` 对象：

```javascript
// 在渲染进程中发送消息并等待响应
try {
  const result = await window.messageManager.sendToMain('channel-name', data1, data2, ...);
  console.log('收到主进程响应:', result);
} catch (error) {
  console.error('消息发送失败:', error);
}
```

### 处理来自对方进程的消息

#### 主进程处理来自渲染进程的消息

```javascript
// 在主进程中注册消息处理器
messageManager.handleFromRenderer('channel-name', async (...args) => {
  // 处理消息
  console.log('收到来自渲染进程的消息:', args);
  
  // 返回结果给渲染进程
  return { success: true, result: 'processed' };
});

// 处理带多个参数的消息
messageManager.handleFromRenderer('get-user-info', async (userId, includeProfile) => {
  const userInfo = await getUserInfoFromDatabase(userId, includeProfile);
  return userInfo;
});
```

#### 渲染进程处理来自主进程的消息

```javascript
// 在渲染进程中注册消息处理器（双向消息）
window.messageManager.handleFromMain('channel-name', async (...args) => {
  // 处理消息
  console.log('收到来自主进程的消息:', args);
  
  // 返回结果给主进程
  return { received: true, timestamp: Date.now() };
});

// 在渲染进程中注册单向消息处理器
window.messageManager.handleOnewayFromMain('notification', (...args) => {
  // 处理单向消息，无需返回值
  console.log('收到通知:', args);
});
```

### 管理处理器

```javascript
// 移除单个处理器
messageManager.removeHandler('channel-name');

// 移除所有处理器
messageManager.removeAllHandlers();
```

### 完整示例

主进程代码：
```javascript
import { MessageManager } from './electron/managers/MessageManager.js';
import { ipcMain, app } from 'electron';

// 创建消息管理器
const messageManager = new MessageManager(ipcMain);

// 注册消息处理器
messageManager.handleFromRenderer('get-user-info', async (userId) => {
  // 从数据库获取用户信息
  const userInfo = await getUserInfoFromDatabase(userId);
  return userInfo;
});

// 向渲染进程发送消息
async function sendNotification(window, title, message) {
  try {
    const result = await messageManager.sendToRenderer(
      window,
      'notification',
      { title, message }
    );
    console.log('通知已确认:', result);
  } catch (error) {
    console.error('发送通知失败:', error);
  }
}

// 发送单向消息
function sendOnewayNotification(window, title, message) {
  messageManager.sendToRendererOneway(window, 'notification', { title, message });
}

// 应用退出时清理
app.on('before-quit', () => {
  messageManager.removeAllHandlers();
});
```

渲染进程代码：
```javascript
// 注册消息处理器（双向消息）
window.messageManager.handleFromMain('notification', async (data) => {
  // 显示通知
  alert(`${data.title}: ${data.message}`);
  
  // 返回确认信息
  return { received: true, timestamp: Date.now() };
});

// 注册单向消息处理器
window.messageManager.handleOnewayFromMain('update-status', (status) => {
  // 更新状态，无需返回值
  document.getElementById('status').textContent = status;
});

// 向主进程发送消息
document.getElementById('getUserBtn').addEventListener('click', async () => {
  try {
    const userInfo = await window.messageManager.sendToMain('get-user-info', '123');
    console.log('获取到用户信息:', userInfo);
    // 在页面上显示用户信息
    document.getElementById('userInfo').innerText = JSON.stringify(userInfo);
  } catch (error) {
    console.error('获取用户信息失败:', error);
  }
});
```

### 特性说明

1. **双向通信**：支持主进程与渲染进程之间的双向消息传递
2. **单向通信**：支持不等待响应的单向消息发送
3. **超时机制**：双向消息默认30秒超时，超时后自动拒绝Promise
4. **错误处理**：自动处理错误并传递给调用者
5. **应用退出保护**：应用退出时自动跳过消息发送，避免错误

### 注意事项

1. **超时处理**：双向消息默认30秒超时，超时会自动拒绝Promise
2. **错误处理**：所有消息操作都应该使用 try-catch 包裹
3. **资源清理**：应用退出时建议调用 `removeAllHandlers()` 清理所有处理器
4. **参数传递**：支持传递多个参数，使用展开运算符 `...args`
5. **应用退出**：应用退出时（`app.isQuitting`），消息发送会自动跳过，避免错误


## 系统资源监控管理器使用指南

系统资源监控管理器提供了一套完整的系统资源信息收集方案，包括CPU和内存使用情况。

### 创建系统资源监控管理器实例

```javascript
// 在主进程中
import { SystemMonitorManager } from './electron/managers/SystemMonitorManager.js';
const systemMonitor = new SystemMonitorManager();
```

### 获取CPU使用率

```javascript
// 获取CPU使用率
const cpuUsage = await systemMonitor.getCpuUsage();
console.log('CPU使用率:', cpuUsage);
// 输出示例：
// {
//   usagePercent: 25,  // CPU使用百分比
//   cores: 8           // CPU核心数
// }
```

### 获取内存使用情况

```javascript
// 获取内存使用情况
const memoryUsage = await systemMonitor.getMemoryUsage();
console.log('内存使用情况:', memoryUsage);
// 输出示例：
// {
//   usagePercent: 60,  // 内存使用百分比
//   total: 16.0,       // 总内存(GB)
//   used: 9.6,         // 已使用内存(GB)
//   free: 6.4          // 空闲内存(GB)
// }
```

### 获取完整的系统资源信息

```javascript
// 获取完整的系统资源信息
const resources = await systemMonitor.getSystemResources();
console.log('系统资源信息:', resources);
// 输出示例：
// {
//   cpu: {
//     usagePercent: 25,
//     cores: 8
//   },
//   memory: {
//     usagePercent: 60,
//     total: 16.0,
//     used: 9.6,
//     free: 6.4
//   }
// }
```

## 自定义对话框使用指南

自定义对话框提供了与应用程序窗口风格一致的提示框和确认框功能，支持在主进程和渲染进程中使用。

### 在渲染进程中使用

#### 显示提示框

```javascript
// 基本用法
await window.customDialog.alert({
  title: '提示',
  message: '操作成功完成！'
});

// 带类型的提示框
await window.customDialog.alert({
  title: '成功',
  message: '数据保存成功！',
  type: 'success',  // 'info', 'success', 'warning', 'error'
  buttonText: '知道了'
});

// 警告提示
await window.customDialog.alert({
  title: '警告',
  message: '请确认您的操作',
  type: 'warning'
});

// 错误提示
await window.customDialog.alert({
  title: '错误',
  message: '操作失败，请重试',
  type: 'error'
});
```

#### 显示确认框

```javascript
// 基本用法
const result = await window.customDialog.confirm({
  title: '确认',
  message: '确定要删除这条记录吗？'
});

if (result) {
  console.log('用户点击了确定');
} else {
  console.log('用户点击了取消或关闭');
}

// 自定义按钮文本
const result = await window.customDialog.confirm({
  title: '确认删除',
  message: '此操作不可恢复，确定要继续吗？',
  confirmText: '删除',
  cancelText: '取消',
  type: 'warning'
});

// 带类型的确认框
const result = await window.customDialog.confirm({
  title: '保存更改',
  message: '您有未保存的更改，确定要离开吗？',
  type: 'warning',
  confirmText: '离开',
  cancelText: '取消'
});
```

#### 显示通知

```javascript
// 自动关闭的通知（3秒后自动关闭）
await window.customDialog.notify({
  title: '通知',
  message: '这是一条自动关闭的通知消息',
  type: 'success',
  duration: 3000  // 3秒后自动关闭
});

// 手动关闭的通知（不设置 duration 或设置为 0）
await window.customDialog.notify({
  title: '通知',
  message: '这是一条需要手动关闭的通知',
  type: 'info'
  // duration 不设置或设置为 0 表示需要手动关闭
});

// 不同类型的通知
await window.customDialog.notify({
  title: '成功',
  message: '操作成功完成！',
  type: 'success',
  duration: 2000
});

await window.customDialog.notify({
  title: '警告',
  message: '请注意检查您的操作',
  type: 'warning',
  duration: 4000
});

await window.customDialog.notify({
  title: '错误',
  message: '操作失败，请重试',
  type: 'error',
  duration: 5000
});
```

### 在主进程中使用

```javascript
// 在主进程中导入DialogManager
import { DialogManager } from './electron/utils/DialogManager.js';

// 创建对话框管理器实例（需要在有messageManager和window之后）
const dialogManager = new DialogManager({
  messageManager: msgManager,
  window: mainWindow
});

// 或者先创建实例，后续设置
const dialogManager = new DialogManager();
dialogManager.setMessageManager(msgManager);
dialogManager.setWindow(mainWindow);

// 显示提示框
await dialogManager.alert({
  title: '提示',
  message: '操作成功完成！',
  type: 'success'
});

// 显示确认框
const confirmed = await dialogManager.confirm({
  title: '确认',
  message: '确定要执行此操作吗？',
  type: 'warning'
});

if (confirmed) {
  console.log('用户确认了操作');
} else {
  console.log('用户取消了操作');
}

// 显示通知（自动关闭）
await dialogManager.notify({
  title: '通知',
  message: '操作已完成',
  type: 'success',
  duration: 3000  // 3秒后自动关闭
});

// 显示通知（手动关闭）
await dialogManager.notify({
  title: '重要通知',
  message: '请查看重要信息',
  type: 'warning'
  // 不设置 duration 或设置为 0 表示需要手动关闭
});
```

### 对话框类型说明

- **info**: 信息提示（蓝色图标）
- **success**: 成功提示（绿色图标）
- **warning**: 警告提示（黄色图标）
- **error**: 错误提示（红色图标）

### 配置选项

#### alert 方法选项

```javascript
{
  title: string,        // 对话框标题，默认'提示'
  message: string,      // 消息内容
  type: string,         // 类型: 'info', 'success', 'warning', 'error'，默认'info'
  buttonText: string    // 按钮文本，默认'确定'
}
```

#### confirm 方法选项

```javascript
{
  title: string,        // 对话框标题，默认'确认'
  message: string,      // 消息内容
  type: string,         // 类型: 'info', 'success', 'warning', 'error'，默认'info'
  confirmText: string,  // 确认按钮文本，默认'确定'
  cancelText: string    // 取消按钮文本，默认'取消'
}
```

#### notify 方法选项

```javascript
{
  title: string,        // 通知标题，默认'通知'
  message: string,      // 消息内容
  type: string,         // 类型: 'info', 'success', 'warning', 'error'，默认'info'
  duration: number      // 自动关闭时间（毫秒），0或不设置表示不自动关闭，需要手动关闭
}
```

### 完整使用示例

#### 渲染进程示例

```javascript
// 删除确认示例
async function deleteItem(itemId) {
  const confirmed = await window.customDialog.confirm({
    title: '确认删除',
    message: '确定要删除这个项目吗？此操作不可恢复。',
    type: 'warning',
    confirmText: '删除',
    cancelText: '取消'
  });
  
  if (confirmed) {
    try {
      // 执行删除操作
      await deleteItemFromServer(itemId);
      await window.customDialog.alert({
        title: '成功',
        message: '项目已成功删除',
        type: 'success'
      });
    } catch (error) {
      await window.customDialog.alert({
        title: '错误',
        message: '删除失败：' + error.message,
        type: 'error'
      });
    }
  }
}

// 表单提交确认示例
async function submitForm(formData) {
  const confirmed = await window.customDialog.confirm({
    title: '提交表单',
    message: '确定要提交表单吗？',
    type: 'info'
  });
  
  if (confirmed) {
    try {
      await saveFormData(formData);
      await window.customDialog.alert({
        title: '成功',
        message: '表单提交成功！',
        type: 'success'
      });
    } catch (error) {
      await window.customDialog.alert({
        title: '提交失败',
        message: error.message,
        type: 'error'
      });
    }
  }
}

// 通知使用示例
async function showNotification() {
  // 显示自动关闭的成功通知
  await window.customDialog.notify({
    title: '操作成功',
    message: '数据已保存',
    type: 'success',
    duration: 2000  // 2秒后自动关闭
  });
  
  // 显示需要手动关闭的重要通知
  await window.customDialog.notify({
    title: '重要提示',
    message: '请检查您的设置',
    type: 'warning'
    // 不设置 duration，需要手动关闭
  });
}
```

#### 主进程示例

```javascript
// 在主进程中
import { DialogManager } from './electron/utils/DialogManager.js';

// 假设在startApp.js中已经初始化了dialogManager
async function handleCriticalOperation() {
  try {
    // 执行关键操作前确认
    const confirmed = await dialogManager.confirm({
      title: '警告',
      message: '此操作将影响系统稳定性，确定要继续吗？',
      type: 'warning',
      confirmText: '继续',
      cancelText: '取消'
    });
    
    if (confirmed) {
      // 执行操作
      await performCriticalOperation();
      
      // 显示成功提示
      await dialogManager.alert({
        title: '成功',
        message: '操作已成功完成',
        type: 'success'
      });
      
      // 或者使用通知（自动关闭）
      await dialogManager.notify({
        title: '成功',
        message: '操作已成功完成',
        type: 'success',
        duration: 3000
      });
    }
  } catch (error) {
    await dialogManager.alert({
      title: '错误',
      message: '操作失败：' + error.message,
      type: 'error'
    });
    
    // 或者使用通知显示错误
    await dialogManager.notify({
      title: '错误',
      message: '操作失败：' + error.message,
      type: 'error',
      duration: 5000
    });
  }
}
```

### 特性

- 与自定义窗口风格完全一致（深色主题、渐变背景、相同颜色方案）
- 支持队列显示（多个对话框依次显示，不会重叠）
- 支持ESC键关闭确认框
- 响应式设计，适配移动端
- 平滑的动画过渡效果
- 支持自定义按钮文本和图标类型
- 主进程和渲染进程统一API
- 通知功能支持自动关闭和手动关闭
- 通知可以同时显示多个，不会排队

### 注意事项

1. 在主进程中使用时，需要先初始化DialogManager并设置messageManager和window
2. 对话框会自动排队显示，避免多个对话框同时显示造成界面混乱
3. 确认框可以通过ESC键或点击关闭按钮取消
4. 对话框样式会自动应用，无需额外引入样式文件
5. 通知不会排队，可以同时显示多个通知
6. 通知可以通过关闭按钮手动关闭，也可以设置 duration 参数实现自动关闭
7. 通知的 duration 参数单位为毫秒，设置为 0 或不设置表示需要手动关闭

## HTTP服务管理器使用指南

HTTP服务管理器提供了一个轻量级的HTTP服务器解决方案，支持动态添加API接口和处理函数，可以快速构建RESTful API服务。

### 创建HTTP服务器管理器实例

```javascript
// 在主进程中
import { HttpServerManager } from './electron/managers/HttpServerManager.js';

// 创建HTTP服务器管理器实例
const httpServer = new HttpServerManager({
  port: 8080 // 指定监听端口，默认3000
});
```

### 启动和停止服务器

```javascript
// 启动HTTP服务器
await httpServer.start();
console.log('HTTP服务器已启动');

// 停止HTTP服务器
await httpServer.stop();
console.log('HTTP服务器已停止');
```

### 监听服务器事件

```javascript
// 监听服务器启动事件
httpServer.on('start', ({ port }) => {
  console.log(`HTTP服务器已启动，监听端口: ${port}`);
});

// 监听服务器停止事件
httpServer.on('stop', () => {
  console.log('HTTP服务器已停止');
});

// 监听错误事件
httpServer.on('error', (error) => {
  console.error('HTTP服务器错误:', error);
});

// 监听路由添加事件
httpServer.on('route-added', ({ method, path }) => {
  console.log(`路由已添加: ${method} ${path}`);
});
```

### 添加API接口

#### GET接口

```javascript
// 添加GET接口
httpServer.addRoute('GET', '/api/status', async (req, res) => {
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: {
      status: 'running',
      timestamp: Date.now()
    }
  });
});
```

#### POST接口

```javascript
// 添加POST接口
httpServer.addRoute('POST', '/api/users', async (req, res) => {
  // req.body 包含解析后的JSON数据
  const { name, email } = req.body || {};
  
  // 处理业务逻辑...
  const newUser = {
    id: Date.now(),
    name,
    email,
    createdAt: new Date().toISOString()
  };
  
  httpServer.sendJson(res, 201, {
    code: '00000',
    message: '用户创建成功',
    data: newUser
  });
});
```

#### 带路径参数的接口

```javascript
// 添加带路径参数的GET接口
httpServer.addRoute('GET', '/api/users/:id', async (req, res) => {
  // req.params 包含路径参数
  const userId = req.params.id;
  
  // 查询用户...
  const user = {
    id: userId,
    name: '示例用户',
    email: 'user@example.com'
  };
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: user
  });
});

// 添加PUT接口（更新）
httpServer.addRoute('PUT', '/api/users/:id', async (req, res) => {
  const userId = req.params.id;
  const updateData = req.body;
  
  // 更新用户...
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '用户更新成功',
    data: { id: userId, ...updateData }
  });
});

// 添加DELETE接口
httpServer.addRoute('DELETE', '/api/users/:id', async (req, res) => {
  const userId = req.params.id;
  
  // 删除用户...
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '用户删除成功'
  });
});
```

#### 处理查询参数（URL问号参数）

查询参数会自动解析并存储在 `req.query` 对象中，支持所有HTTP方法。

```javascript
// 添加带查询参数的接口
// 例如：GET /api/search?keyword=test&page=1&limit=10
httpServer.addRoute('GET', '/api/search', async (req, res) => {
  // req.query 包含所有查询参数
  // 对于 URL: /api/search?keyword=test&page=1&limit=10
  // req.query 将是: { keyword: 'test', page: '1', limit: '10' }
  const { keyword, page = 1, limit = 10 } = req.query;
  
  // 注意：查询参数都是字符串类型，需要时进行类型转换
  const results = {
    keyword: keyword || '',
    page: parseInt(page) || 1,
    limit: parseInt(limit) || 10,
    items: []
  };
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: results
  });
});

// 多个查询参数的示例
// 例如：GET /api/users?status=active&role=admin&page=1&limit=20
httpServer.addRoute('GET', '/api/users', async (req, res) => {
  const { status, role, page = '1', limit = '10', sort = 'id' } = req.query;
  
  // 处理查询参数
  const filters = {
    status: status || 'all',
    role: role || 'all',
    page: parseInt(page),
    limit: parseInt(limit),
    sort: sort
  };
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: {
      filters,
      list: []
    }
  });
});

// 带路径参数和查询参数的组合
// 例如：GET /api/users/123?include=profile,posts&format=json
httpServer.addRoute('GET', '/api/users/:id', async (req, res) => {
  const userId = req.params.id;  // 路径参数: '123'
  const { include, format } = req.query;  // 查询参数: { include: 'profile,posts', format: 'json' }
  
  // 处理include参数（可能是逗号分隔的字符串）
  const includes = include ? include.split(',') : [];
  
  const user = {
    id: userId,
    name: '示例用户',
    // 根据include参数决定返回哪些字段
    profile: includes.includes('profile') ? { email: 'user@example.com' } : undefined,
    posts: includes.includes('posts') ? [] : undefined
  };
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: user
  });
});

// 处理布尔值查询参数
// 例如：GET /api/items?published=true&featured=false
httpServer.addRoute('GET', '/api/items', async (req, res) => {
  const { published, featured } = req.query;
  
  // 将字符串 'true'/'false' 转换为布尔值
  const filters = {
    published: published === 'true',
    featured: featured === 'true'
  };
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: { filters }
  });
});

// 处理数组查询参数（同一个参数名出现多次）
// 例如：GET /api/tags?tags=javascript&tags=nodejs&tags=express
httpServer.addRoute('GET', '/api/tags', async (req, res) => {
  // HttpServerManager 自动将同名参数转换为数组
  // req.query.tags 可能是字符串（单个值）或数组（多个值）
  const tags = req.query.tags;
  
  // 统一处理：确保 tags 是数组格式
  const tagsArray = Array.isArray(tags) ? tags : (tags ? [tags] : []);
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: { 
      tags: tagsArray,
      count: tagsArray.length
    }
  });
});

// 混合使用单个和多个参数
// 例如：GET /api/search?q=test&category=tech&category=news&sort=date
httpServer.addRoute('GET', '/api/search', async (req, res) => {
  const { q, category, sort } = req.query;
  
  // category 可能是字符串或数组
  const categories = Array.isArray(category) ? category : (category ? [category] : []);
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: {
      keyword: q || '',
      categories,
      sort: sort || 'relevance'
    }
  });
});
```

### 添加中间件

```javascript
// 添加中间件（在路由处理之前执行）
httpServer.addMiddleware(async (req, res, next) => {
  console.log(`请求: ${req.method} ${req.pathname}`);
  
  // 可以在这里添加认证、日志等逻辑
  // 例如：检查API密钥
  const apiKey = req.headers['x-api-key'];
  if (!apiKey || apiKey !== 'your-secret-key') {
    httpServer.sendJson(res, 401, {
      code: '401',
      message: '未授权'
    });
    return;
  }
  
  // 调用next()继续处理请求
  await next();
});
```

### 动态管理路由

```javascript
// 动态添加路由
function addDynamicRoute() {
  httpServer.addRoute('GET', '/api/dynamic', async (req, res) => {
    httpServer.sendJson(res, 200, {
      code: '00000',
      message: '这是动态添加的路由',
      data: { timestamp: Date.now() }
    });
  });
}

// 移除路由
function removeRoute() {
  httpServer.removeRoute('GET', '/api/dynamic');
}

// 清除所有路由
function clearAllRoutes() {
  httpServer.clearRoutes();
}
```

### 获取服务器信息

```javascript
// 获取服务器状态
const status = httpServer.getStatus();
console.log(status);
// 输出示例：
// {
//   isRunning: true,
//   port: 8080,
//   routeCount: 5,
//   middlewareCount: 1
// }

// 获取所有已注册的路由
const routes = httpServer.getRoutes();
console.log(routes);
// 输出示例：
// [
//   { method: 'GET', path: '/api/status' },
//   { method: 'POST', path: '/api/users' },
//   { method: 'GET', path: '/api/users/:id' }
// ]
```

### 错误处理

```javascript
// 在路由处理函数中处理错误
httpServer.addRoute('GET', '/api/error', async (req, res) => {
  try {
    // 模拟可能抛出错误的操作
    throw new Error('这是一个示例错误');
  } catch (error) {
    // 手动处理错误
    httpServer.sendJson(res, 500, {
      code: '50000',
      message: '操作失败',
      error: error.message
    });
  }
});

// 或者让系统自动处理错误（会返回500状态码）
httpServer.addRoute('GET', '/api/auto-error', async (req, res) => {
  // 如果这里抛出未捕获的错误，系统会自动处理
  throw new Error('自动处理的错误');
});
```

### 请求对象说明

在路由处理函数中，`req` 对象包含以下属性：

```javascript
{
  method: 'GET',              // HTTP方法
  pathname: '/api/users/123', // 请求路径
  query: {                     // 查询参数对象
    page: '1',
    limit: '10'
  },
  params: {                   // 路径参数对象（如 :id）
    id: '123'
  },
  body: {},                   // 请求体（POST/PUT/PATCH请求）
  headers: {},                // 请求头
  url: 'http://localhost:8080/api/users/123?page=1' // 完整URL
}
```

### 完整使用示例

```javascript
import { HttpServerManager } from './electron/managers/HttpServerManager.js';

// 创建HTTP服务器管理器实例
const httpServer = new HttpServerManager({
  port: 8080
});

// 监听服务器事件
httpServer.on('start', ({ port }) => {
  console.log(`HTTP服务器已启动，监听端口: ${port}`);
});

// 添加认证中间件
httpServer.addMiddleware(async (req, res, next) => {
  // 跳过OPTIONS请求
  if (req.method === 'OPTIONS') {
    await next();
    return;
  }
  
  // 检查API密钥
  const apiKey = req.headers['x-api-key'];
  if (req.pathname.startsWith('/api/') && (!apiKey || apiKey !== 'secret-key')) {
    httpServer.sendJson(res, 401, {
      code: '401',
      message: '未授权，需要有效的API密钥'
    });
    return;
  }
  
  await next();
});

// 添加状态检查接口
httpServer.addRoute('GET', '/api/status', async (req, res) => {
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '服务运行正常',
    data: {
      status: 'running',
      timestamp: Date.now(),
      uptime: process.uptime()
    }
  });
});

// 添加用户列表接口
httpServer.addRoute('GET', '/api/users', async (req, res) => {
  const { page = 1, limit = 10 } = req.query;
  
  // 模拟查询用户列表
  const users = [
    { id: 1, name: '张三', email: 'zhangsan@example.com' },
    { id: 2, name: '李四', email: 'lisi@example.com' }
  ];
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: {
      list: users,
      page: parseInt(page),
      limit: parseInt(limit),
      total: users.length
    }
  });
});

// 添加创建用户接口
httpServer.addRoute('POST', '/api/users', async (req, res) => {
  const { name, email } = req.body || {};
  
  if (!name || !email) {
    httpServer.sendJson(res, 400, {
      code: '40000',
      message: '参数不完整'
    });
    return;
  }
  
  const newUser = {
    id: Date.now(),
    name,
    email,
    createdAt: new Date().toISOString()
  };
  
  httpServer.sendJson(res, 201, {
    code: '00000',
    message: '用户创建成功',
    data: newUser
  });
});

// 添加获取单个用户接口
httpServer.addRoute('GET', '/api/users/:id', async (req, res) => {
  const userId = req.params.id;
  
  // 模拟查询用户
  const user = {
    id: userId,
    name: '示例用户',
    email: 'user@example.com'
  };
  
  httpServer.sendJson(res, 200, {
    code: '00000',
    message: '成功',
    data: user
  });
});

// 启动服务器
async function startApiServer() {
  try {
    await httpServer.start();
    console.log('API服务器启动成功');
    console.log('已注册的路由:', httpServer.getRoutes());
  } catch (error) {
    console.error('启动API服务器失败:', error);
  }
}

// 停止服务器
async function stopApiServer() {
  try {
    await httpServer.stop();
    console.log('API服务器已停止');
  } catch (error) {
    console.error('停止API服务器失败:', error);
  }
}

// 在应用启动时启动服务器
startApiServer();

// 在应用退出时停止服务器
process.on('SIGINT', async () => {
  await stopApiServer();
  process.exit(0);
});
```

### 特性说明

1. **动态路由管理**：支持运行时动态添加和移除API接口
2. **路径参数支持**：支持 `:param` 形式的路径参数
3. **自动请求解析**：自动解析JSON和表单数据
4. **中间件支持**：支持添加中间件函数，用于认证、日志等
5. **CORS支持**：自动处理跨域请求
6. **错误处理**：统一的错误处理机制
7. **事件系统**：基于EventEmitter，支持监听服务器事件
8. **轻量级**：不依赖外部框架，使用Node.js原生http模块

### 注意事项

1. HTTP服务器默认监听所有网络接口（0.0.0.0），如需限制访问，请使用防火墙或反向代理
2. 路径参数使用 `:param` 格式，如 `/api/users/:id`
3. 请求体解析支持 `application/json` 和 `application/x-www-form-urlencoded` 格式
4. 中间件按添加顺序执行，必须调用 `next()` 才能继续处理请求
5. 服务器停止时会自动清理所有路由和中间件

## 自定义窗口标题栏使用指南

Fast Electron 提供了完整的自定义窗口标题栏功能，支持最小化、最大化、关闭等操作，并且与应用程序风格完全一致。

### 功能特性

- 自定义窗口标题栏，完全替代系统原生标题栏
- 支持窗口拖拽移动
- 支持最小化、最大化/还原、关闭操作
- 退出确认对话框（可选择最小化到托盘或退出程序）
- 与应用程序整体风格保持一致（深色主题、渐变背景）
- 自动适配内容区域高度，避免内容被标题栏遮挡

### 配置启用

在应用配置中启用自定义窗口：

```javascript
// 在配置文件中设置
{
  "customWindow": true,  // 启用自定义窗口
  "appName": "我的应用"  // 应用名称（显示在标题栏）
}
```

### 在渲染进程中使用

#### 修改窗口标题

```javascript
// 修改窗口标题
window.customWindow.setTitle('新的窗口标题');
```

### 窗口控制

窗口控制按钮（最小化、最大化、关闭）会自动添加到标题栏，无需手动配置。

### 退出确认

当用户点击关闭按钮时，会自动显示退出确认对话框，用户可以选择：
- **最小化到托盘**：将窗口最小化到系统托盘
- **退出程序**：完全退出应用程序

退出确认对话框会自动与应用程序风格保持一致。

## 菜单选择对话框使用指南

菜单选择对话框提供了一个美观的菜单式选择界面，支持多个选项、图标、描述等功能。

### 在渲染进程中使用

#### 基本用法

```javascript
// 显示菜单选择对话框
const result = await window.customDialog.menu({
  title: '选择操作',
  message: '请选择要执行的操作',
  iconType: 'info',
  items: [
    {
      id: 'option1',
      title: '选项一',
      description: '这是选项一的描述',
      icon: '📁',
      value: 'option1'
    },
    {
      id: 'option2',
      title: '选项二',
      description: '这是选项二的描述',
      icon: '⚙️',
      value: 'option2'
    }
  ]
});

if (result) {
  console.log('用户选择了:', result);
} else {
  console.log('用户取消了选择');
}
```

#### 带危险操作的菜单

```javascript
const result = await window.customDialog.menu({
  title: '确认操作',
  message: '请选择操作类型',
  iconType: 'warning',
  items: [
    {
      id: 'save',
      title: '保存',
      description: '保存当前更改',
      icon: '💾',
      value: 'save'
    },
    {
      id: 'delete',
      title: '删除',
      description: '永久删除此项目',
      icon: '🗑️',
      value: 'delete',
      danger: true  // 标记为危险操作，会显示红色高亮
    }
  ]
});
```

#### 禁用选项

```javascript
const result = await window.customDialog.menu({
  title: '选择操作',
  items: [
    {
      id: 'enabled',
      title: '可用选项',
      description: '这个选项可以点击',
      icon: '✓',
      value: 'enabled'
    },
    {
      id: 'disabled',
      title: '禁用选项',
      description: '这个选项已被禁用',
      icon: '✕',
      value: 'disabled',
      disabled: true  // 禁用此选项
    }
  ]
});
```

#### 自定义返回值

```javascript
const result = await window.customDialog.menu({
  title: '选择操作',
  items: [
    {
      id: 'action1',
      title: '操作一',
      value: { type: 'action', id: 1 }  // 自定义返回值
    },
    {
      id: 'action2',
      title: '操作二',
      value: { type: 'action', id: 2 }  // 自定义返回值
    }
  ]
});

// result 将是 { type: 'action', id: 1 } 或 { type: 'action', id: 2 }
```

### 配置选项

```javascript
{
  title: string,              // 对话框标题，默认'请选择'
  message: string,            // 描述信息（可选）
  iconType: string,           // 图标类型: 'info', 'success', 'warning', 'error'，默认'info'
  items: Array,               // 菜单项数组（必需）
  showClose: boolean,         // 是否显示关闭按钮，默认true
  closeOnOverlay: boolean     // 点击遮罩层是否关闭，默认true
}
```

### 菜单项配置

```javascript
{
  id: string,                 // 菜单项唯一标识（必需）
  title: string,              // 菜单项标题（必需）
  description: string,        // 菜单项描述（可选）
  icon: string,               // 菜单项图标（字符或emoji，可选）
  value: any,                 // 返回值（可选，默认使用id）
  disabled: boolean,          // 是否禁用，默认false
  danger: boolean             // 是否为危险操作，默认false
}
```

### 完整使用示例

```javascript
// 退出确认菜单
async function showExitMenu() {
  const result = await window.customDialog.menu({
    title: '退出确认',
    message: '请选择操作：',
    iconType: 'warning',
    items: [
      {
        id: 'minimize',
        title: '最小化到托盘',
        description: '将窗口最小化到系统托盘',
        icon: '⬇',
        value: 'minimize'
      },
      {
        id: 'exit',
        title: '退出程序',
        description: '完全退出应用程序',
        icon: '✕',
        value: 'exit',
        danger: true
      }
    ]
  });
  
  if (result === 'minimize') {
    // 执行最小化操作
    console.log('用户选择最小化');
  } else if (result === 'exit') {
    // 执行退出操作
    console.log('用户选择退出');
  } else {
    // 用户取消了操作
    console.log('用户取消了操作');
  }
}

// 文件操作菜单
async function showFileMenu() {
  const result = await window.customDialog.menu({
    title: '文件操作',
    iconType: 'info',
    items: [
      {
        id: 'new',
        title: '新建',
        description: '创建新文件',
        icon: '📄',
        value: 'new'
      },
      {
        id: 'open',
        title: '打开',
        description: '打开现有文件',
        icon: '📂',
        value: 'open'
      },
      {
        id: 'save',
        title: '保存',
        description: '保存当前文件',
        icon: '💾',
        value: 'save'
      },
      {
        id: 'delete',
        title: '删除',
        description: '删除当前文件',
        icon: '🗑️',
        value: 'delete',
        danger: true
      }
    ]
  });
  
  switch (result) {
    case 'new':
      // 处理新建操作
      break;
    case 'open':
      // 处理打开操作
      break;
    case 'save':
      // 处理保存操作
      break;
    case 'delete':
      // 处理删除操作
      break;
  }
}
```

### 特性说明

- **美观的界面**：与应用程序整体风格完全一致（深色主题、渐变背景）
- **丰富的选项**：支持图标、标题、描述、危险标记、禁用状态
- **灵活的返回值**：可以自定义返回值，支持任意类型
- **交互友好**：支持ESC键关闭、点击遮罩层关闭
- **响应式设计**：适配不同屏幕尺寸
- **平滑动画**：淡入淡出和缩放动画效果

### 注意事项

1. `items` 数组不能为空，至少需要一个菜单项
2. 每个菜单项必须提供 `id` 和 `title`
3. 如果菜单项没有提供 `value`，将使用 `id` 作为返回值
4. 禁用的菜单项无法点击，会显示为半透明状态
5. 危险操作的菜单项会显示红色高亮效果
6. 用户点击关闭按钮、ESC键或遮罩层时，返回 `null`


## 日志管理器使用指南

日志管理器提供了全局的日志输出到文件功能，支持不同日志级别、日志轮转、自动清理等功能。

### 创建日志管理器实例

```javascript
// 在主进程中
import { getLogger } from './electron/managers/LoggerManager.js';

// 获取全局日志管理器实例（单例模式）
const logger = getLogger({
  logDir: './logs',           // 日志目录，默认为 app.getPath('userData')/logs
  logFileName: 'app',         // 日志文件名（不含扩展名），默认 'app'
  logFileExt: '.log',         // 日志文件扩展名，默认 '.log'
  level: 'info',              // 日志级别：'debug', 'info', 'warn', 'error'，默认 'info'
  console: true,              // 是否输出到控制台，默认 true
  file: true,                 // 是否输出到文件，默认 true
  format: 'detailed',         // 日志格式：'simple' 或 'detailed'，默认 'detailed'
  rotateByDate: true,         // 是否按日期轮转日志，默认 true
  maxDays: 7,                // 保留日志文件天数，0 表示不删除，默认 7
  colors: true                // 是否启用控制台颜色输出，默认 true
});
```

### 使用日志管理器

```javascript
// 记录不同级别的日志
logger.debug('这是一条调试日志', { data: 'debug info' });
logger.info('这是一条信息日志', '附加信息');
logger.warn('这是一条警告日志');
logger.error('这是一条错误日志', new Error('错误详情'));

// 日志会自动输出到控制台和文件
// 文件路径示例：./logs/app_2025-12-23.log
```

### 动态配置日志管理器

```javascript
// 设置日志级别
logger.setLevel('debug');  // 现在会记录所有级别的日志
logger.setLevel('warn');   // 只记录警告和错误日志

// 获取当前日志级别
const currentLevel = logger.getLevel();
console.log('当前日志级别:', currentLevel);

// 启用/禁用控制台输出
logger.setConsole(false);  // 禁用控制台输出，只输出到文件
logger.setConsole(true);   // 启用控制台输出

// 启用/禁用文件输出
logger.setFile(false);     // 禁用文件输出，只输出到控制台
logger.setFile(true);      // 启用文件输出
```

### 日志级别说明

日志级别从低到高：
- **debug**: 调试信息，最详细的日志
- **info**: 一般信息，正常的程序运行信息
- **warn**: 警告信息，可能的问题但不影响运行
- **error**: 错误信息，需要关注的错误

只有当前设置的日志级别及以上的日志才会被记录。例如，如果设置为 `info`，则只会记录 `info`、`warn` 和 `error` 级别的日志。

### 日志格式

#### 详细格式（detailed，默认）

```
[2025-12-23 14:30:45.123] [INFO] 这是一条信息日志 附加信息
[2025-12-23 14:30:46.456] [ERROR] 这是一条错误日志 {"message":"错误详情"}
```

#### 简单格式（simple）

```
[2025-12-23 14:30:45.123] [INFO] 这是一条信息日志 附加信息
```

### 日志文件管理

```javascript
// 获取当前日志文件路径
const currentLogPath = logger.getCurrentLogPath();
console.log('当前日志文件:', currentLogPath);

// 获取所有日志文件列表（按时间倒序）
const logFiles = logger.getLogFiles();
console.log('所有日志文件:', logFiles);

// 手动清理旧日志文件（保留指定天数）
const deletedCount = logger.cleanupOldLogs(7);  // 删除7天前的日志
console.log(`删除了 ${deletedCount} 个旧日志文件`);
```

### 监听日志事件

```javascript
// 监听日志记录事件
logger.on('log', ({ level, message, args, timestamp }) => {
  console.log('日志已记录:', { level, message, timestamp });
});

// 监听日志文件创建事件
logger.on('log-file-created', ({ path }) => {
  console.log('新的日志文件已创建:', path);
});

// 监听日志清理事件
logger.on('logs-cleaned', ({ count }) => {
  console.log(`清理了 ${count} 个旧日志文件`);
});

// 监听错误事件
logger.on('error', (error) => {
  console.error('日志管理器错误:', error);
});
```

### 日志轮转

日志管理器支持按日期自动轮转日志文件：

- 每天自动创建新的日志文件
- 文件名格式：`app_2025-12-23.log`（如果启用按日期轮转）
- 自动清理超过保留天数的旧日志文件

### 完整使用示例

```javascript
import { getLogger } from './electron/managers/LoggerManager.js';

// 在应用启动时初始化日志管理器
const logger = getLogger({
  level: 'info',
  console: true,
  file: true,
  rotateByDate: true,
  maxDays: 7
});

// 记录应用启动
logger.info('应用启动', { version: '1.0.0', timestamp: Date.now() });

// 在关键操作中记录日志
async function processData(data) {
  try {
    logger.debug('开始处理数据', { dataSize: data.length });
    
    // 处理数据...
    const result = await doSomething(data);
    
    logger.info('数据处理完成', { resultCount: result.length });
    return result;
  } catch (error) {
    logger.error('数据处理失败', error);
    throw error;
  }
}

// 在错误处理中使用
process.on('uncaughtException', (error) => {
  logger.error('未捕获的异常', error);
});

process.on('unhandledRejection', (reason, promise) => {
  logger.error('未处理的Promise拒绝', { reason, promise });
});

// 在应用关闭时清理资源
app.on('before-quit', () => {
  logger.info('应用正在关闭');
  logger.destroy();
});
```

### 特性说明

1. **全局单例**：使用 `getLogger()` 获取全局单例，确保整个应用使用同一个日志管理器
2. **多级别日志**：支持 debug、info、warn、error 四个级别
3. **双重输出**：可同时输出到控制台和文件
4. **自动轮转**：支持按日期自动轮转日志文件
5. **自动清理**：自动清理超过保留天数的旧日志文件
6. **颜色输出**：控制台输出支持颜色显示（可配置）
7. **事件系统**：基于 EventEmitter，支持监听日志相关事件
8. **高性能**：使用流式写入，支持大容量日志输出

### 注意事项

1. 日志管理器应该在应用启动早期初始化
2. 日志文件会按日期自动轮转，无需手动管理
3. 建议在生产环境中设置合适的日志级别（如 `warn` 或 `error`）
4. 定期清理旧日志文件可以节省磁盘空间
5. 如果应用异常退出，日志管理器会自动关闭文件流