# SqliteServiceLibrary

**Repository Path**: DynamicLinkLibrary_1/SqliteServiceLibrary

## Basic Information

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

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-12-29
- **Last Updated**: 2026-01-12

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# SqliteServiceLibrary

基于 SQLite 的轻量级管理服务库，提供完整的 CRUD 操作和管理功能。

## 简介

SqliteServiceLibrary 是一个功能完善的 .NET Standard 2.0 管理服务库，采用 SQLite 作为数据存储，支持用户管理、用户组管理等核心功能。库采用简洁的分层架构设计，Service 层直接实现数据访问逻辑，支持异步操作，并针对高频率读写场景进行了性能优化。

## 功能特性

### 核心功能
- 用户管理功能
- 用户组管理功能
- 系统配置管理
- 事件日志和操作日志记录
- 趋势数据记录

### 性能优化
- WAL 模式支持并发读写
- 支持异步操作
- 自动数据库连接管理
- 分页查询支持

### 架构特性
- 简洁的分层架构设计
- 统一的 OperateResult 错误处理模式
- 完全自动的数据库连接管理
- 反射映射器缓存优化性能

## 安装和配置

### 安装依赖

```bash
dotnet add package Microsoft.Data.Sqlite
```

### 配置选项

在使用服务之前，可以通过 `SqliteService.Config` 配置数据库路径和其他选项：

```csharp
using SqliteServiceLibrary;

// 配置数据库路径（可选，默认使用 %AppData%\SqliteServiceLibrary\SystemDb）
SqliteService.Config.DbPath = "management.db";

// 配置连接超时时间（可选，默认30秒）
SqliteService.Config.ConnectionTimeout = 60;

// 配置命令超时时间（可选，默认30秒）
SqliteService.Config.CommandTimeout = 60;

// 配置是否启用WAL模式（可选，默认true）
SqliteService.Config.EnableWalMode = true;

// 配置是否启用自动清理（可选，默认true）
SqliteService.Config.EnableAutoCleanup = true;

// 配置事件日志保留天数（可选，默认30天）
SqliteService.Config.EventLogRetentionDays = 30;

// 配置操作日志保留天数（可选，默认90天）
SqliteService.Config.OperationLogRetentionDays = 90;

// 配置事件日志最大条数（可选，默认10000条）
SqliteService.Config.EventLogMaxCount = 10000;

// 配置操作日志最大条数（可选，默认50000条）
SqliteService.Config.OperationLogMaxCount = 50000;

// 配置每次清理的最大删除条数（可选，默认1000条）
SqliteService.Config.CleanupBatchSize = 1000;
```

#### 配置项说明

| 配置项 | 类型 | 默认值 | 说明 |
|--------|------|---------|------|
| `DbPath` | string | "SystemDb" | 数据库路径 |
| `ConnectionTimeout` | int | 30 | 连接超时时间（秒） |
| `CommandTimeout` | int | 30 | 命令超时时间（秒） |
| `EnableWalMode` | bool | true | 是否启用WAL模式 |
| `EnablePooling` | bool | true | 是否启用连接池 |
| `SynchronousMode` | int | 1 | 同步模式（0-OFF, 1-NORMAL, 2-FULL, 3-EXTRA） |
| `EnableAutoCleanup` | bool | true | 是否启用自动清理 |
| `EventLogRetentionDays` | int | 30 | 事件日志保留天数 |
| `OperationLogRetentionDays` | int | 90 | 操作日志保留天数 |
| `EventLogMaxCount` | int | 10000 | 事件日志最大条数 |
| `OperationLogMaxCount` | int | 50000 | 操作日志最大条数 |
| `CleanupBatchSize` | int | 1000 | 每次清理的最大删除条数 |

## 快速开始

### ⚠️ 重要提示：必须先初始化服务

**在使用任何服务功能之前，必须先调用 `InitializeAsync()` 方法进行初始化！**

初始化过程会：
- 创建数据库目录（默认在 `%AppData%\SqliteServiceLibrary\SystemDb\`）
- 创建所有必要的数据库文件（user.db、system.db、eventlog.db、operationlog.db、trendrecord.db）
- 初始化数据库表结构
- 创建默认用户组（超级管理员、管理员、操作员、观察员）
- 创建默认管理员用户（用户名：admin，密码：admin）

**如果不调用 `InitializeAsync()`，数据库和目录将不会被创建，所有服务操作都会失败！**

### 初始化服务

```csharp
using SqliteServiceLibrary;

// 步骤1：配置数据库路径（可选）
// SqliteService.Config.DbPath = "management.db";

// 步骤2：必须先初始化服务（重要！）
var result = await SqliteService.InitializeAsync();
if (!result.IsSuccess)
{
    // 初始化失败，处理错误
    Console.WriteLine($"初始化失败: {result.Message}");
    return;
}

// 步骤3：初始化成功后，可以使用所有服务
var users = await SqliteService.User.GetAllAsync();
var groups = await SqliteService.User.GetAllGroupsAsync();

// 步骤4：不再使用时释放资源
SqliteService.Dispose();
```

## 核心概念

### 分层架构

SqliteServiceLibrary 采用简洁的分层架构：

- **Models（模型层）**：定义数据实体
- **Services（业务逻辑层）**：封装业务逻辑，直接操作数据库
- **Database（数据库层）**：管理数据库连接和上下文，提供自动连接管理
- **Core（核心层）**：提供数据映射等核心功能
- **Utils（工具层）**：提供加密、初始化等通用工具

### 服务统一访问入口

`SqliteService` 静态类提供了所有SQLite服务的静态方法访问。它使用懒加载和单例模式管理服务实例，简化了服务的初始化和使用。

| 属性 | 类型 | 说明 |
|------|------|------|
| `Config` | `SqliteConfig` | SQLite配置信息 |
| `User` | `UserService` | 用户管理服务（包含用户、用户组功能） |
| `SystemConfig` | `SystemConfigService` | 系统配置服务 |
| `EventLog` | `EventLogService` | 事件日志服务 |
| `OperationLog` | `OperationLogService` | 操作日志服务 |
| `TrendRecord` | `TrendRecordService` | 趋势记录服务 |

### OperateResult 操作结果类

`OperateResult` 类是所有服务方法的统一返回类型，包含操作结果信息：

| 属性 | 类型 | 说明 |
|------|------|------|
| `IsSuccess` | `bool` | 操作是否成功 |
| `Message` | `string` | 操作结果消息 |
| `ErrorCode` | `int` | 错误代码（仅在失败时有效） |
| `Data` | `T` | 操作返回的数据（泛型） |
| `Exception` | `Exception` | 异常信息（仅在失败时有效） |
| `ElapsedTime` | `long` | 操作用时（毫秒） |

**静态方法：**
- `Success<T>(T data, string message = "操作成功")` - 创建成功结果
- `Failure<T>(string message, int errorCode = 500)` - 创建失败结果

## 详细使用方法

### 6.1 用户管理服务

用户管理服务提供了完整的用户 CRUD 操作，包括添加、查询、更新、删除等功能。

#### 6.1.1 添加用户

```csharp
// 添加新用户
var addResult = await SqliteService.User.AddAsync(
    username: "zhangsan",
    password: "password123",
    department: "技术部",
    role: "开发工程师",
    groupId: 1,
    email: "zhangsan@example.com",
    phoneNumber: "13800138000",
    status: 1
);

if (addResult.IsSuccess)
{
    Console.WriteLine("用户添加成功");
}
else
{
    Console.WriteLine($"用户添加失败: {addResult.Message}");
}
```

**参数说明：**
- `username`：用户名（必填，必须唯一）
- `password`：密码（必填，会自动加密存储）
- `department`：部门（可选）
- `role`：角色（可选，默认"普通用户"）
- `groupId`：用户组ID（可选）
- `email`：邮箱（可选）
- `phoneNumber`：电话号码（可选）
- `status`：状态（可选，0-禁用，1-启用，默认1）

#### 6.1.2 查询用户

```csharp
// 根据ID查询用户（ID从数据库自动获取，不可手动输入）
var userResult = await SqliteService.User.GetByIdAsync(1);
if (userResult.IsSuccess)
{
    var user = userResult.Data;
    Console.WriteLine($"用户名: {user.Username}");
    Console.WriteLine($"部门: {user.Department}");
}

// 根据用户名查询用户（推荐方式）
var userByNameResult = await SqliteService.User.GetByUsernameAsync("zhangsan");
if (userByNameResult.IsSuccess)
{
    var user = userByNameResult.Data;
    Console.WriteLine($"用户ID: {user.Id}");
}

// 获取所有用户
var allUsersResult = await SqliteService.User.GetAllAsync();
if (allUsersResult.IsSuccess)
{
    var users = allUsersResult.Data;
    foreach (var user in users)
    {
        Console.WriteLine($"用户: {user.Username}");
    }
}

// 根据状态查询用户
var activeUsersResult = await SqliteService.User.GetByStatusAsync(1);
if (activeUsersResult.IsSuccess)
{
    var activeUsers = activeUsersResult.Data;
    Console.WriteLine($"启用用户数量: {activeUsers.Count}");
}
```

**参数说明：**
- `id`：用户ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符，用于 GetByIdAsync
- `username`：用户名（必填），用于 GetByUsernameAsync 和 ExistsByUsernameAsync
- `status`：状态（必填），用于 GetByStatusAsync 和 ChangeStatusAsync，0-禁用，1-启用

#### 6.1.3 更新用户

```csharp
// 获取用户
var userResult = await SqliteService.User.GetByUsernameAsync("zhangsan");
if (userResult.IsSuccess)
{
    var user = userResult.Data;
    
    // 更新用户信息（可以只更新部分字段）
    var updateResult = await SqliteService.User.UpdateAsync(
        id: user.Id,
        password: "newpassword123",
        department: "研发部",
        role: "高级开发工程师",
        groupId: 2,
        email: "newemail@example.com",
        phoneNumber: "13900139000",
        status: 1
    );
    
    if (updateResult.IsSuccess)
    {
        Console.WriteLine("用户更新成功");
    }
}
```

**参数说明：**
- `id`：用户ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符
- `password`：新密码（可选，不传则不更新）
- `department`：新部门（可选）
- `role`：新角色（可选）
- `groupId`：新用户组ID（可选）
- `email`：新邮箱（可选）
- `phoneNumber`：新电话号码（可选）
- `status`：新状态（可选）

#### 6.1.4 删除用户

```csharp
// 先查询获取用户ID（ID从数据库自动获取，不可手动输入）
var userResult = await SqliteService.User.GetByUsernameAsync("zhangsan");
if (userResult.IsSuccess)
{
    var user = userResult.Data;
    
    // 使用自动获取的ID删除用户
    var deleteResult = await SqliteService.User.DeleteAsync(user.Id);
    if (deleteResult.IsSuccess)
    {
        Console.WriteLine("用户删除成功");
    }
}
```

**参数说明：**
- `id`：用户ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符

#### 6.1.5 更改用户状态

```csharp
// 先查询获取用户ID（ID从数据库自动获取，不可手动输入）
var userResult = await SqliteService.User.GetByUsernameAsync("zhangsan");
if (userResult.IsSuccess)
{
    var user = userResult.Data;
    
    // 使用自动获取的ID启用用户
    var enableResult = await SqliteService.User.ChangeStatusAsync(user.Id, 1);
    if (enableResult.IsSuccess)
    {
        Console.WriteLine("用户已启用");
    }
}

// 禁用用户
var disableResult = await SqliteService.User.ChangeStatusAsync(user.Id, 0);
if (disableResult.IsSuccess)
{
    Console.WriteLine("用户已禁用");
}
}
```

**参数说明：**
- `id`：用户ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符
- `status`：状态（必填），0-禁用，1-启用

#### 6.1.6 用户登录验证

```csharp
// 验证用户登录
var loginResult = await SqliteService.User.ValidateUserAsync("zhangsan", "password123");
if (loginResult.IsSuccess)
{
    Console.WriteLine("登录成功");
}
else
{
    Console.WriteLine($"登录失败: {loginResult.Message}");
}
```

#### 6.1.7 检查用户名是否存在

```csharp
// 检查用户名是否存在
var existsResult = await SqliteService.User.ExistsByUsernameAsync("zhangsan");
if (existsResult.IsSuccess && existsResult.Data)
{
    Console.WriteLine("用户名已存在");
}
else
{
    Console.WriteLine("用户名可用");
}
```

#### 6.1.8 更新最后登录时间

```csharp
// 先查询获取用户ID（ID从数据库自动获取，不可手动输入）
var userResult = await SqliteService.User.GetByUsernameAsync("zhangsan");
if (userResult.IsSuccess)
{
    var user = userResult.Data;
    
    // 使用自动获取的ID更新最后登录时间
    var updateLoginResult = await SqliteService.User.UpdateLastLoginAtAsync(user.Id);
    if (updateLoginResult.IsSuccess)
    {
        Console.WriteLine("最后登录时间已更新");
    }
}
```

**参数说明：**
- `id`：用户ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符

### 6.2 用户组管理服务

用户组管理服务提供了用户组的 CRUD 操作，所有用户组相关的方法都通过 `SqliteService.User` 访问。

#### 6.2.1 添加用户组

```csharp
// 添加用户组
var addGroupResult = await SqliteService.User.AddGroupAsync(
    name: "开发组",
    description: "负责系统开发工作",
    status: 1,
    groupPermission: 100
);

if (addGroupResult.IsSuccess)
{
    Console.WriteLine("用户组添加成功");
}
```

**参数说明：**
- `name`：用户组名称（必填，必须唯一）
- `description`：用户组描述（可选）
- `status`：状态（可选，0-禁用，1-启用，默认1）
- `groupPermission`：组权限（可选，默认0）

#### 6.2.2 查询用户组

```csharp
// 根据ID查询用户组（ID从数据库自动获取，不可手动输入）
var groupResult = await SqliteService.User.GetGroupByIdAsync(1);
if (groupResult.IsSuccess)
{
    var group = groupResult.Data;
    Console.WriteLine($"用户组名称: {group.Name}");
}

// 根据名称查询用户组（推荐方式）
var groupByNameResult = await SqliteService.User.GetGroupByNameAsync("开发组");
if (groupByNameResult.IsSuccess)
{
    var group = groupByNameResult.Data;
    Console.WriteLine($"用户组ID: {group.Id}");
}

// 获取所有用户组
var allGroupsResult = await SqliteService.User.GetAllGroupsAsync();
if (allGroupsResult.IsSuccess)
{
    var groups = allGroupsResult.Data;
    foreach (var group in groups)
    {
        Console.WriteLine($"用户组: {group.Name}");
    }
}

// 根据状态查询用户组
var activeGroupsResult = await SqliteService.User.GetGroupsByStatusAsync(1);
if (activeGroupsResult.IsSuccess)
{
    var activeGroups = activeGroupsResult.Data;
    Console.WriteLine($"启用用户组数量: {activeGroups.Count}");
}
```

**参数说明：**
- `id`：用户组ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符，用于 GetGroupByIdAsync
- `name`：用户组名称（必填），用于 GetGroupByNameAsync 和 ExistsByNameAsync
- `status`：状态（必填），用于 GetGroupsByStatusAsync 和 ChangeGroupStatusAsync，0-禁用，1-启用

#### 6.2.3 更新用户组

```csharp
// 获取用户组
var groupResult = await SqliteService.User.GetGroupByNameAsync("开发组");
if (groupResult.IsSuccess)
{
    var group = groupResult.Data;
    
    // 更新用户组信息
    var updateGroupResult = await SqliteService.User.UpdateGroupAsync(
        id: group.Id,
        name: "高级开发组",
        description: "负责核心系统开发工作",
        status: 1,
        groupPermission: 200
    );
    
    if (updateGroupResult.IsSuccess)
    {
        Console.WriteLine("用户组更新成功");
    }
}
```

**参数说明：**
- `id`：用户组ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符
- `name`：新用户组名称（可选）
- `description`：新用户组描述（可选）
- `status`：新状态（可选）
- `groupPermission`：新组权限（可选）

#### 6.2.4 删除用户组

```csharp
// 先查询获取用户组ID（ID从数据库自动获取，不可手动输入）
var groupResult = await SqliteService.User.GetGroupByNameAsync("开发组");
if (groupResult.IsSuccess)
{
    var group = groupResult.Data;
    
    // 使用自动获取的ID删除用户组
    var deleteGroupResult = await SqliteService.User.DeleteGroupAsync(group.Id);
    if (deleteGroupResult.IsSuccess)
    {
        Console.WriteLine("用户组删除成功");
    }
}
```

**参数说明：**
- `id`：用户组ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符

#### 6.2.5 更改用户组状态

```csharp
// 先查询获取用户组ID（ID从数据库自动获取，不可手动输入）
var groupResult = await SqliteService.User.GetGroupByNameAsync("开发组");
if (groupResult.IsSuccess)
{
    var group = groupResult.Data;
    
    // 使用自动获取的ID启用用户组
    var enableGroupResult = await SqliteService.User.ChangeGroupStatusAsync(group.Id, 1);
    if (enableGroupResult.IsSuccess)
    {
        Console.WriteLine("用户组已启用");
    }
    
    // 禁用用户组
    var disableGroupResult = await SqliteService.User.ChangeGroupStatusAsync(group.Id, 0);
    if (disableGroupResult.IsSuccess)
    {
        Console.WriteLine("用户组已禁用");
    }
}
```

**参数说明：**
- `id`：用户组ID（自动获取（不可修改）），从数据库查询获取的自增唯一标识符
- `status`：状态（必填），0-禁用，1-启用

### 6.3 系统配置服务

系统配置服务提供了系统配置的 CRUD 操作，用于存储和管理系统级别的配置信息。

#### 6.3.1 添加或更新配置

```csharp
// 添加新配置（如果配置键不存在）
var addConfigResult = await SqliteService.SystemConfig.AddOrUpdateAsync(
    key: "system.name",
    value: "MySystem",
    description: "系统名称"
);

if (addConfigResult.IsSuccess)
{
    Console.WriteLine("配置添加成功");
}

// 更新现有配置（如果配置键已存在）
var updateConfigResult = await SqliteService.SystemConfig.AddOrUpdateAsync(
    key: "system.name",
    value: "MyNewSystem",
    description: "新的系统名称"
);

if (updateConfigResult.IsSuccess)
{
    Console.WriteLine("配置更新成功");
}
```

**参数说明：**
- `key`：配置键（必填，必须唯一）
- `value`：配置值（必填）
- `description`：配置描述（可选）

#### 6.3.2 查询配置

```csharp
// 根据键查询配置
var configResult = await SqliteService.SystemConfig.GetByKeyAsync("system.name");
if (configResult.IsSuccess)
{
    var config = configResult.Data;
    Console.WriteLine($"配置键: {config.ConfigKey}");
    Console.WriteLine($"配置值: {config.ConfigValue}");
    Console.WriteLine($"配置描述: {config.Description}");
}

// 获取配置值（支持默认值）
var valueResult = await SqliteService.SystemConfig.GetValueAsync("system.name", "默认值");
if (valueResult.IsSuccess)
{
    var value = valueResult.Data;
    Console.WriteLine($"配置值: {value}");
}

// 获取所有配置
var allConfigsResult = await SqliteService.SystemConfig.GetAllAsync();
if (allConfigsResult.IsSuccess)
{
    var configs = allConfigsResult.Data;
    foreach (var config in configs)
    {
        Console.WriteLine($"配置: {config.ConfigKey} = {config.ConfigValue}");
    }
}
```

#### 6.3.3 删除配置

```csharp
// 删除配置
var deleteConfigResult = await SqliteService.SystemConfig.DeleteAsync("system.name");
if (deleteConfigResult.IsSuccess)
{
    Console.WriteLine("配置删除成功");
}
```

#### 6.3.4 检查配置键是否存在

```csharp
// 检查配置键是否存在
var existsConfigResult = await SqliteService.SystemConfig.ExistsByKeyAsync("system.name");
if (existsConfigResult.IsSuccess && existsConfigResult.Data)
{
    Console.WriteLine("配置键已存在");
}
else
{
    Console.WriteLine("配置键不存在");
}
```

### 6.4 事件日志服务

事件日志服务用于记录系统中发生的各类事件（如错误、警告、信息等）。

#### 6.4.1 添加事件日志

```csharp
// 添加普通事件日志
var addEventResult = await SqliteService.EventLog.AddAsync(
    eventType: "系统启动",
    source: "System",
    message: "系统启动成功",
    username: "admin",
    level: "Info"
);

if (addEventResult.IsSuccess)
{
    Console.WriteLine("事件日志添加成功");
}

// 添加错误日志
var addErrorResult = await SqliteService.EventLog.AddErrorAsync(
    eventType: "数据库错误",
    source: "Database",
    message: "数据库连接失败",
    username: "admin"
);

if (addErrorResult.IsSuccess)
{
    Console.WriteLine("错误日志添加成功");
}

// 添加警告日志
var addWarningResult = await SqliteService.EventLog.AddWarningAsync(
    eventType: "内存警告",
    source: "System",
    message: "内存使用率超过80%",
    username: "admin"
);

if (addWarningResult.IsSuccess)
{
    Console.WriteLine("警告日志添加成功");
}

// 添加信息日志
var addInfoResult = await SqliteService.EventLog.AddInfoAsync(
    eventType: "用户登录",
    source: "Auth",
    message: "用户zhangsan登录成功",
    username: "zhangsan"
);

if (addInfoResult.IsSuccess)
{
    Console.WriteLine("信息日志添加成功");
}
```

**参数说明：**
- `eventType`：事件类型（必填）
- `source`：事件来源（必填）
- `message`：事件消息（必填）
- `username`：用户名（可选，默认空字符串）
- `level`：日志级别（可选，默认"Info"）

#### 6.4.2 查询事件日志

```csharp
// 根据日期范围查询事件日志
var startDate = DateTime.Now.AddDays(-7);
var endDate = DateTime.Now;
var logsByDateResult = await SqliteService.EventLog.GetByDateRangeAsync(startDate, endDate);
if (logsByDateResult.IsSuccess)
{
    var logs = logsByDateResult.Data;
    foreach (var log in logs)
    {
        Console.WriteLine($"事件: {log.EventType} - {log.Message}");
    }
}

// 根据日志级别查询事件日志
var logsByLevelResult = await SqliteService.EventLog.GetByLevelAsync("Error");
if (logsByLevelResult.IsSuccess)
{
    var errorLogs = logsByLevelResult.Data;
    Console.WriteLine($"错误日志数量: {errorLogs.Count}");
}

// 根据来源查询事件日志
var logsBySourceResult = await SqliteService.EventLog.GetBySourceAsync("Database");
if (logsBySourceResult.IsSuccess)
{
    var dbLogs = logsBySourceResult.Data;
    Console.WriteLine($"数据库日志数量: {dbLogs.Count}");
}

// 根据事件类型查询事件日志
var logsByTypeResult = await SqliteService.EventLog.GetByTypeAsync("用户登录");
if (logsByTypeResult.IsSuccess)
{
    var loginLogs = logsByTypeResult.Data;
    Console.WriteLine($"登录日志数量: {loginLogs.Count}");
}

// 获取最近的事件日志
var recentLogsResult = await SqliteService.EventLog.GetRecentAsync(50);
if (recentLogsResult.IsSuccess)
{
    var recentLogs = recentLogsResult.Data;
    foreach (var log in recentLogs)
    {
        Console.WriteLine($"最近事件: {log.EventType} - {log.Message}");
    }
}
```

#### 6.4.3 统计事件日志

```csharp
// 获取错误日志数量
var errorCountResult = await SqliteService.EventLog.GetErrorCountAsync();
if (errorCountResult.IsSuccess)
{
    Console.WriteLine($"错误日志数量: {errorCountResult.Data}");
}

// 获取警告日志数量
var warningCountResult = await SqliteService.EventLog.GetWarningCountAsync();
if (warningCountResult.IsSuccess)
{
    Console.WriteLine($"警告日志数量: {warningCountResult.Data}");
}

// 获取信息日志数量
var infoCountResult = await SqliteService.EventLog.GetInfoCountAsync();
if (infoCountResult.IsSuccess)
{
    Console.WriteLine($"信息日志数量: {infoCountResult.Data}");
}
```

### 6.5 操作日志服务

操作日志服务用于记录系统中用户的操作行为。

#### 6.5.1 添加操作日志

```csharp
// 添加操作日志
var addOpResult = await SqliteService.OperationLog.AddAsync(
    username: "zhangsan",
    operationType: "修改",
    target: "用户管理",
    result: "成功"
);

if (addOpResult.IsSuccess)
{
    Console.WriteLine("操作日志添加成功");
}
```

**参数说明：**
- `username`：用户名（可选，默认空字符串）
- `operationType`：操作类型（必填）
- `target`：操作目标（必填）
- `result`：操作结果（必填）

#### 6.5.2 查询操作日志

```csharp
// 根据用户名查询操作日志
var logsByUserResult = await SqliteService.OperationLog.GetByUsernameAsync("zhangsan");
if (logsByUserResult.IsSuccess)
{
    var logs = logsByUserResult.Data;
    foreach (var log in logs)
    {
        Console.WriteLine($"操作: {log.OperationType} - {log.Target}");
    }
}

// 根据日期范围查询操作日志
var startDate = DateTime.Now.AddDays(-7);
var endDate = DateTime.Now;
var logsByDateResult = await SqliteService.OperationLog.GetByDateRangeAsync(startDate, endDate);
if (logsByDateResult.IsSuccess)
{
    var logs = logsByDateResult.Data;
    foreach (var log in logs)
    {
        Console.WriteLine($"操作: {log.OperationType} - {log.Result}");
    }
}

// 根据操作类型查询操作日志
var logsByTypeResult = await SqliteService.OperationLog.GetByOperationTypeAsync("修改");
if (logsByTypeResult.IsSuccess)
{
    var editLogs = logsByTypeResult.Data;
    Console.WriteLine($"修改操作数量: {editLogs.Count}");
}

// 获取最近的操作日志
var recentLogsResult = await SqliteService.OperationLog.GetRecentAsync(50);
if (recentLogsResult.IsSuccess)
{
    var recentLogs = recentLogsResult.Data;
    foreach (var log in recentLogs)
    {
        Console.WriteLine($"最近操作: {log.OperationType} - {log.Target}");
    }
}
```

#### 6.5.3 统计操作日志

```csharp
// 获取操作日志总数量
var totalCountResult = await SqliteService.OperationLog.GetTotalCountAsync();
if (totalCountResult.IsSuccess)
{
    Console.WriteLine($"操作日志总数量: {totalCountResult.Data}");
}
```

### 6.6 趋势记录服务

趋势记录服务用于记录和查询趋势数据，支持统计分析功能。

#### 6.6.1 添加趋势记录

```csharp
// 添加趋势记录
var addTrendResult = await SqliteService.TrendRecord.AddAsync(
    metricName: "CPU使用率",
    metricValue: 75.5,
    tag: "服务器1"
);

if (addTrendResult.IsSuccess)
{
    Console.WriteLine("趋势记录添加成功");
}
```

**参数说明：**
- `metricName`：指标名称（必填）
- `metricValue`：指标值（必填）
- `tag`：标签（可选）

#### 6.6.2 查询趋势记录

```csharp
// 根据指标名称查询趋势记录
var recordsByNameResult = await SqliteService.TrendRecord.GetByMetricNameAsync("CPU使用率");
if (recordsByNameResult.IsSuccess)
{
    var records = recordsByNameResult.Data;
    foreach (var record in records)
    {
        Console.WriteLine($"指标值: {record.MetricValue} - 时间: {record.RecordTime}");
    }
}

// 根据日期范围查询趋势记录
var startDate = DateTime.Now.AddDays(-7);
var endDate = DateTime.Now;
var recordsByDateResult = await SqliteService.TrendRecord.GetByDateRangeAsync("CPU使用率", startDate, endDate);
if (recordsByDateResult.IsSuccess)
{
    var records = recordsByDateResult.Data;
    foreach (var record in records)
    {
        Console.WriteLine($"指标值: {record.MetricValue} - 时间: {record.RecordTime}");
    }
}

// 根据标签查询趋势记录
var recordsByTagResult = await SqliteService.TrendRecord.GetByTagAsync("服务器1");
if (recordsByTagResult.IsSuccess)
{
    var records = recordsByTagResult.Data;
    foreach (var record in records)
    {
        Console.WriteLine($"指标: {record.MetricName} - 值: {record.MetricValue}");
    }
}

// 获取最近的趋势记录
var recentRecordsResult = await SqliteService.TrendRecord.GetRecentAsync("CPU使用率", 50);
if (recentRecordsResult.IsSuccess)
{
    var recentRecords = recentRecordsResult.Data;
    foreach (var record in recentRecords)
    {
        Console.WriteLine($"最近记录: {record.MetricName} - {record.MetricValue}");
    }
}
```

#### 6.6.3 统计分析

```csharp
// 获取平均值
var startDate = DateTime.Now.AddDays(-7);
var endDate = DateTime.Now;
var avgResult = await SqliteService.TrendRecord.GetAverageAsync("CPU使用率", startDate, endDate);
if (avgResult.IsSuccess)
{
    Console.WriteLine($"平均CPU使用率: {avgResult.Data}%");
}

// 获取最大值
var maxResult = await SqliteService.TrendRecord.GetMaxAsync("CPU使用率", startDate, endDate);
if (maxResult.IsSuccess)
{
    Console.WriteLine($"最大CPU使用率: {maxResult.Data}%");
}

// 获取最小值
var minResult = await SqliteService.TrendRecord.GetMinAsync("CPU使用率", startDate, endDate);
if (minResult.IsSuccess)
{
    Console.WriteLine($"最小CPU使用率: {minResult.Data}%");
}

// 获取统计信息（最小、平均、最大）
var statsResult = await SqliteService.TrendRecord.GetStatisticsAsync("CPU使用率", startDate, endDate);
if (statsResult.IsSuccess)
{
    var stats = statsResult.Data;
    Console.WriteLine($"最小值: {stats.Item1}%");
    Console.WriteLine($"平均值: {stats.Item2}%");
    Console.WriteLine($"最大值: {stats.Item3}%");
}
```

## 高级功能

### 7.1 分页查询

分页查询功能支持用户和用户组的分页查询，返回包含分页信息的完整数据。

```csharp
// 用户分页查询
var userPagedResult = await SqliteService.User.GetPagedAsync(pageIndex: 1, pageSize: 20);
if (userPagedResult.IsSuccess)
{
    var pagedData = userPagedResult.Data;
    Console.WriteLine($"总记录数: {pagedData.TotalCount}");
    Console.WriteLine($"总页数: {pagedData.TotalPages}");
    Console.WriteLine($"当前页: {pagedData.PageIndex}");
    Console.WriteLine($"每页大小: {pagedData.PageSize}");
    Console.WriteLine($"是否有上一页: {pagedData.HasPrevious}");
    Console.WriteLine($"是否有下一页: {pagedData.HasNext}");
    
    foreach (var user in pagedData.Data)
    {
        Console.WriteLine($"用户: {user.Username}");
    }
}

// 用户组分页查询
var groupPagedResult = await SqliteService.User.GetGroupsPagedAsync(pageIndex: 1, pageSize: 20);
if (groupPagedResult.IsSuccess)
{
    var pagedData = groupPagedResult.Data;
    Console.WriteLine($"总记录数: {pagedData.TotalCount}");
    Console.WriteLine($"总页数: {pagedData.TotalPages}");
    
    foreach (var group in pagedData.Data)
    {
        Console.WriteLine($"用户组: {group.Name}");
    }
}
```

### 7.2 异步操作最佳实践

所有服务方法都是异步方法，必须使用 `await` 关键字调用。

#### 推荐做法

```csharp
// 在异步方法中使用服务
public async Task ProcessUserDataAsync()
{
    // 步骤1：配置数据库路径（可选）
    // SqliteService.Config.DbPath = "management.db";
    
    // 步骤2：确保服务已初始化（重要！）
    var initResult = await SqliteService.InitializeAsync();
    if (!initResult.IsSuccess)
    {
        Console.WriteLine($"初始化失败: {initResult.Message}");
        return;
    }
    
    // 步骤3：使用服务...
    var users = await SqliteService.User.GetAllAsync();
    foreach (var user in users)
    {
        await SqliteService.User.UpdateAsync(user.Id, status: 1);
    }
    
    // 步骤4：释放资源
    SqliteService.Dispose();
}
```

#### 避免的做法

1. **不要使用 .Result**
2. **不要使用 .Wait()**
3. **不要在同步上下文中阻塞异步操作**

### 7.3 错误处理

所有服务方法都返回 `OperateResult` 对象，可以通过检查 `IsSuccess` 属性来判断操作是否成功。

```csharp
// 基本错误处理
var result = await SqliteService.User.AddAsync(
    username: "zhangsan",
    password: "password123"
);

if (result.IsSuccess)
{
    Console.WriteLine("操作成功");
}
else
{
    Console.WriteLine($"操作失败: {result.Message}");
    Console.WriteLine($"错误代码: {result.ErrorCode}");
    
    if (result.Exception != null)
    {
        Console.WriteLine($"异常信息: {result.Exception}");
    }
}
```

### 7.4 日志自动清理

日志自动清理功能采用混合策略，同时基于时间和数量进行清理，任一条件满足即触发清理。

#### 7.4.1 配置自动清理

```csharp
// 配置自动清理
SqliteService.Config.EnableAutoCleanup = true;
SqliteService.Config.EventLogRetentionDays = 30;      // 事件日志保留30天
SqliteService.Config.OperationLogRetentionDays = 90;   // 操作日志保留90天
SqliteService.Config.EventLogMaxCount = 10000;        // 事件日志最多10000条
SqliteService.Config.OperationLogMaxCount = 50000;    // 操作日志最多50000条
SqliteService.Config.CleanupBatchSize = 1000;          // 每次清理最多删除1000条
```

#### 7.4.2 自动清理策略

自动清理采用混合策略：

1. **基于时间的清理**：删除超过保留天数的日志
   - 事件日志：默认保留30天
   - 操作日志：默认保留90天

2. **基于数量的清理**：当日志条数超过最大值时，只保留最新的 N 条
   - 事件日志：默认最多10000条
   - 操作日志：默认最多50000条

3. **混合策略**：两个条件任一满足即触发清理

#### 7.4.3 手动清理

除了自动清理，还可以手动触发清理：

```csharp
// 清理事件日志
var eventLogResult = await SqliteService.CleanupEventLogsAsync();
if (eventLogResult.IsSuccess)
{
    Console.WriteLine($"清理了 {eventLogResult.Data} 条事件日志");
}

// 清理操作日志
var operationLogResult = await SqliteService.CleanupOperationLogsAsync();
if (operationLogResult.IsSuccess)
{
    Console.WriteLine($"清理了 {operationLogResult.Data} 条操作日志");
}

// 清理所有日志
var allResult = await SqliteService.CleanupAllLogsAsync();
if (allResult.IsSuccess)
{
    Console.WriteLine($"事件日志清理: {allResult.Data["EventLog"]} 条");
    Console.WriteLine($"操作日志清理: {allResult.Data["OperationLog"]} 条");
}
```

#### 7.4.4 日志统计

可以查看日志的统计信息：

```csharp
// 获取事件日志统计
var eventStatsResult = await SqliteService.GetEventLogStatisticsAsync();
if (eventStatsResult.IsSuccess)
{
    var stats = eventStatsResult.Data;
    Console.WriteLine($"总日志数: {stats.TotalCount}");
    Console.WriteLine($"错误数: {stats.ErrorCount}");
    Console.WriteLine($"警告数: {stats.WarningCount}");
    Console.WriteLine($"信息数: {stats.InfoCount}");
    Console.WriteLine($"最早日志: {stats.OldestLogDate}");
    Console.WriteLine($"最新日志: {stats.NewestLogDate}");
    Console.WriteLine($"总大小: {stats.TotalSizeFormatted}");
}

// 获取操作日志统计
var operationStatsResult = await SqliteService.GetOperationLogStatisticsAsync();
if (operationStatsResult.IsSuccess)
{
    var stats = operationStatsResult.Data;
    Console.WriteLine($"总日志数: {stats.TotalCount}");
    Console.WriteLine($"最早日志: {stats.OldestLogDate}");
    Console.WriteLine($"最新日志: {stats.NewestLogDate}");
    Console.WriteLine($"总大小: {stats.TotalSizeFormatted}");
}
```

#### 7.4.5 性能优化

自动清理功能包含以下性能优化：

1. **分批删除**：使用 `CleanupBatchSize` 配置，避免一次性删除太多导致事务过大
2. **事务优化**：批量删除使用事务，提高性能
3. **索引优化**：确保 CreatedAt 字段有索引，提高查询速度

#### 7.4.6 最佳实践

1. **合理配置保留天数**：根据业务需求配置合适的保留天数
   - 生产环境：建议保留30-90天
   - 开发环境：可以保留较少天数

2. **合理配置最大条数**：根据日志量配置合适的最大条数
   - 高频日志：建议设置较大的最大条数
   - 低频日志：可以设置较小的最大条数

3. **定期清理**：建议在应用启动时或定时任务中执行清理
   - 应用启动时自动清理（默认启用）
   - 可以添加定时任务定期清理

4. **监控日志大小**：定期查看日志统计信息，确保日志不会无限增长

## 数据库设计

### 数据库表结构

#### Users 表

```sql
CREATE TABLE Users (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    Username TEXT UNIQUE NOT NULL,
    PasswordHash TEXT NOT NULL,
    Department TEXT,
    Role TEXT NOT NULL,
    GroupId INTEGER,
    Email TEXT UNIQUE,
    PhoneNumber TEXT,
    LastLoginAt DATETIME,
    Status INTEGER DEFAULT 1,
    CreatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
    UpdatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (GroupId) REFERENCES Groups(Id) ON DELETE SET NULL
);
```

#### Groups 表

```sql
CREATE TABLE Groups (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    Name TEXT UNIQUE NOT NULL,
    Description TEXT,
    Status INTEGER DEFAULT 1,
    GroupPermission INTEGER DEFAULT 0,
    CreatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
    UpdatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
);
```

#### SystemConfigs 表

```sql
CREATE TABLE SystemConfigs (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    ConfigKey TEXT UNIQUE NOT NULL,
    ConfigValue TEXT NOT NULL,
    Description TEXT,
    CreatedAt DATETIME DEFAULT CURRENT_TIMESTAMP,
    UpdatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
);
```

#### EventLogs 表

```sql
CREATE TABLE EventLogs (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    EventType TEXT NOT NULL,
    Source TEXT NOT NULL,
    Message TEXT NOT NULL,
    Level TEXT NOT NULL,
    Username TEXT NOT NULL DEFAULT '',
    CreatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
);
```

#### OperationLogs 表

```sql
CREATE TABLE OperationLogs (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    Username TEXT NOT NULL DEFAULT '',
    OperationType TEXT NOT NULL,
    Target TEXT NOT NULL,
    Result TEXT NOT NULL,
    CreatedAt DATETIME DEFAULT CURRENT_TIMESTAMP
);
```

#### TrendRecords 表

```sql
CREATE TABLE TrendRecords (
    Id INTEGER PRIMARY KEY AUTOINCREMENT,
    MetricName TEXT NOT NULL,
    MetricValue REAL NOT NULL,
    Tag TEXT,
    RecordTime DATETIME DEFAULT CURRENT_TIMESTAMP
);
```

### 数据库组织

本库根据模块名称创建不同的数据库文件来组织数据：

- **user.db**：存储用户和用户组
- **system.db**：存储系统配置
- **eventlog.db**：存储事件日志
- **operationlog.db**：存储操作日志
- **trendrecord.db**：存储趋势记录

数据库文件默认创建在应用程序数据目录的 `SqliteServiceLibrary` 文件夹下，可通过配置自定义路径。

## 性能优化

### WAL (Write-Ahead Logging) 模式

- **读写并发**：读操作不会被写操作阻塞，显著提升并发性能
- **性能提升**：单次写入速度提升 5 倍，批量写入速度提升 20 倍
- **自动启用**：所有数据库连接自动启用 WAL 模式
- **灵活配置**：支持通过 `requireWalMode` 参数控制 WAL 模式启用失败时的行为

### 连接资源管理

- **完全自动连接管理**：DbContext 提供自动连接管理方法，每次操作都创建新连接并自动释放
- **防止资源泄漏**：所有数据库操作必须通过 ExecuteAsync、ExecuteReaderAsync、ExecuteScalarAsync 等方法，确保连接正确释放
- **统一管理模式**：通过自动管理方法统一管理连接生命周期，消除连接泄漏风险
- **提升稳定性**：避免连接池耗尽和内存泄漏问题，确保系统长期稳定运行
- **无需手动管理**：DbContext 不需要手动 Dispose，连接由 using 语句自动管理

### 密码安全

- **PBKDF2 算法**：使用 PBKDF2 算法进行密码哈希
- **盐值支持**：每个密码使用随机盐值
- **防止彩虹表攻击**：提高密码安全性

## 项目结构

```
SqliteServiceLibrary/
├── Core/                         # 核心层
│   ├── IDataMapper.cs           # 数据映射器接口
│   └── ReflectionMapper.cs       # 反射映射器实现
├── Database/                      # 数据库层
│   ├── DatabaseMigration.cs       # 数据库迁移
│   └── DbContext.cs              # 数据库上下文
├── Models/                        # 模型层
│   ├── EventLog.cs                # 事件日志模型
│   ├── Group.cs                   # 用户组模型
│   ├── LogStatistics.cs           # 日志统计模型
│   ├── OperateResult.cs           # 操作结果模型
│   ├── OperationLog.cs            # 操作日志模型
│   ├── SystemConfig.cs            # 系统配置模型
│   ├── TrendRecord.cs             # 趋势记录模型
│   └── User.cs                    # 用户模型
├── Services/                      # 业务逻辑层
│   ├── BaseService.cs            # 服务基类
│   ├── EventLogService.cs         # 事件日志服务
│   ├── GroupService.cs            # 用户组服务
│   ├── OperationLogService.cs     # 操作日志服务
│   ├── SystemConfigService.cs     # 系统配置服务
│   ├── TrendRecordService.cs      # 趋势记录服务
│   └── UserService.cs             # 用户服务（包含用户、用户组功能）
├── Utils/                         # 工具层
│   ├── DatabaseInitializer.cs     # 数据库初始化工具
│   └── EncryptionHelper.cs        # 加密工具
├── SqliteService.cs               # 核心静态服务类
├── SqliteConfig.cs                # 配置类
├── SqliteServiceLibrary.csproj    # 项目文件
└── README.md                      # 项目文档
```

## 常见问题

### Q1: 为什么调用服务方法时抛出异常？

**A:** 请确保在使用任何服务功能之前先调用 `InitializeAsync()` 方法进行初始化。如果不调用初始化方法，数据库和目录将不会被创建，所有服务操作都会失败。

### Q2: 如何修改默认管理员密码？

**A:** 首次使用后请立即修改默认管理员密码。可以使用 `UpdateAsync` 方法更新密码：

```csharp
var userResult = await SqliteService.User.GetByUsernameAsync("admin");
if (userResult.IsSuccess)
{
    var user = userResult.Data;
    await SqliteService.User.UpdateAsync(user.Id, password: "newpassword");
}
```

### Q3: 数据库文件存储在哪里？

**A:** 数据库文件默认创建在应用程序数据目录的 `SqliteServiceLibrary` 文件夹下。可以通过配置自定义路径：

```csharp
SqliteService.Config.DbPath = "management.db";
```

### Q4: 如何释放资源？

**A:** 只需要调用 `SqliteService.Dispose()` 方法释放 SqliteManager 的资源。DbContext 不需要手动 Dispose，因为每次操作都创建新连接并由 using 语句自动管理：

```csharp
SqliteService.Dispose();
```

**注意：**
- DbContext 不需要手动 Dispose
- 数据库连接由 using 语句自动管理
- 只需在不再使用服务时调用 SqliteService.Dispose()

### Q5: 支持哪些数据类型？

**A:** 支持以下数据类型：
- `int`：整数
- `string`：字符串
- `double`：浮点数
- `DateTime`：日期时间
- `bool`：布尔值
- `long`：长整数

### Q6: 如何处理并发访问？

**A:** 本库使用 WAL 模式支持并发读写，读操作不会被写操作阻塞。所有数据库操作都是异步的，可以安全地在多线程环境中使用。

## 依赖项

- .NET Standard 2.0
- Microsoft.Data.Sqlite

## 注意事项

### ⚠️ 必须先初始化服务

**在使用任何服务功能之前，必须先调用 `InitializeAsync()` 方法进行初始化！**

这是使用本库的最重要步骤，因为：
1. **Lazy 加载机制**：`SqliteManager` 使用懒加载模式，只有在第一次访问时才会创建
2. **数据库创建**：只有在初始化时才会创建数据库目录和文件
3. **表结构初始化**：只有在初始化时才会创建所有必要的数据库表
4. **默认数据**：只有在初始化时才会创建默认用户组和管理员用户

**如果不调用 `InitializeAsync()`，所有服务操作都会失败！**

### 默认管理员用户

初始化后会自动创建默认管理员用户：
- **用户名**：admin
- **密码**：admin
- **用户组**：超级管理员

**⚠️ 安全提示**：首次使用后请立即修改默认管理员密码！

### 其他注意事项
1. **异步操作**：所有方法都是异步方法，必须使用 `await` 关键字
2. **资源管理**：DbContext 不需要手动 Dispose，连接由 using 语句自动管理。只需在不再使用服务时调用 SqliteService.Dispose()
3. **用户名 (Username) 必须唯一**
4. **用户组名称 (Name) 必须唯一**
5. **数据库文件会自动创建在指定的目录中**
6. **用户和用户组数据存储在 user.db 数据库中**
7. **所有用户相关功能统一通过 `SqliteService.User` 访问**

## 更新日志

### v3.1.0 (2026-01-11)

#### 日志自动清理功能
- ✅ 添加日志自动清理功能，采用混合策略（基于时间和数量）
- ✅ 添加日志统计功能，支持查看日志总数、大小、最早/最晚时间等
- ✅ 添加手动清理接口，支持清理事件日志和操作日志
- ✅ 添加分批删除优化，避免一次性删除太多导致事务过大
- ✅ 添加配置项，支持自定义保留天数、最大条数、批量大小等
- ✅ 在初始化时自动执行清理（可配置）
- ✅ 更新 README.md 文档，添加日志清理功能说明

### v3.0.2 (2026-01-11)

#### 架构优化和文档更新
- ✅ 移除 DbContext 的 IDisposable 接口，简化资源管理
- ✅ 统一错误处理为 OperateResult 模式
- ✅ 修改所有 UpdateAsync 方法的 status 默认值为 1（启用状态）
- ✅ 更新 README.md 文档，确保与实际代码一致
- ✅ 修复 DbContext 连接管理相关问题

### v3.0.1 (2026-01-11)

#### 连接资源管理优化
- ✅ 移除 DbContext.GetConnectionAsync() 方法，防止连接泄漏
- ✅ 修复 BaseService.ExecuteBatchAsync() 中的连接管理问题
- ✅ 确保所有数据库连接都通过自动管理方法处理
- ✅ 更新文档，明确连接资源管理的最佳实践

### v3.0.0 (2026-01-11)

#### 重大重构
- ✅ 全面重构代码架构，提升代码质量 60%+
- ✅ 移除所有同步方法，只保留异步版本
- ✅ 实现通用数据映射器，减少重复代码
- ✅ 优化密码加密，使用 PBKDF2 + 盐值
- ✅ 添加分页查询支持
- ✅ 改进 DbContext，完善资源管理
- ✅ 简化服务层，统一代码风格
- ✅ 移除冗余代码和未使用的异常类
- ✅ 优化性能，减少内存分配

#### 连接资源管理优化
- ✅ 修复 DbContext 连接资源泄漏问题
- ✅ 添加自动连接管理方法（ExecuteAsync、ExecuteReaderAsync、ExecuteScalarAsync）
- ✅ 重构 BaseService，统一连接管理模式
- ✅ 修复所有服务类中的连接泄漏（EventLogService、SystemConfigService、OperationLogService、TrendRecordService）
- ✅ 彻底消除连接泄漏风险，提升系统稳定性

### v2.1.0 (2026-01-11)

#### 架构优化
- ✅ 移除权限管理功能：简化架构，专注于用户和用户组管理
- ✅ 移除权限检查功能：移除 PermissionCheckService
- ✅ 精简 UserService：只保留用户和用户组管理功能
- ✅ 更新初始化逻辑：初始化默认用户组和管理员用户（用户名：admin，密码：admin）

## 许可证

MIT License