新增：Markdown编辑器/数据库优化/安全修复

- Markdown 编辑器：实时预览、PDF 导出、独立查看器 - 数据库优化：动态连接池、查询缓存、Redis Pipeline - 窗口置顶功能 - 文件系统增强：右键菜单、编辑器集成、收藏夹重构 - 安全修复：XSS 防护、路径穿越、HTML 注入 - 代码质量：正则预编译、缓存锁优化、死代码清理
2026-03-31 09:18:06 +08:00
parent 5f94ccf13b
commit e5dbe89a6f
59 changed files with 5289 additions and 1316 deletions
--- a/internal/dbclient/pool_config.go
+++ b/internal/dbclient/pool_config.go
@@ -34,22 +34,40 @@ type PoolConfig struct {
 	SlowConnThreshold time.Duration
 	// 连接池最大容量（防止资源耗尽）
 	MaxPoolCapacity int
+	
+	// 动态连接池配置
+	EnableDynamicScaling bool     // 是否启用动态连接池调整
+	DynamicScaleFactor  float64  // 动态调整因子（0.5-2.0）
+	ScaleUpThreshold    float64  // 扩容阈值（0-1.0，当使用率超过此值时扩容）
+	ScaleDownThreshold  float64  // 缩容阈值（0-1.0，当使用率低于此值时缩容）
+	MinScaleUpInterval   time.Duration // 最小扩容间隔（防止频繁调整）
+	MinScaleDownInterval time.Duration // 最小缩容间隔
+	MaxIdleTimeForScale  time.Duration // 用于动态调整的最大空闲时间
 }

 // DefaultPoolConfig 返回默认连接池配置
 func DefaultPoolConfig() *PoolConfig {
 	return &PoolConfig{
-		MaxOpenConns:         20,                  // 最大20个连接
-		MaxIdleConns:         10,                  // 最大10个空闲
-		ConnMaxLifetime:       30 * time.Minute,    // 连接最长30分钟
-		ConnMaxIdleTime:       10 * time.Minute,    // 空闲10分钟关闭
-		MinIdleConns:         2,                   // 保持2个最小空闲
-		ConnTimeout:           5 * time.Second,      // 连接超时5秒
-		HealthCheckInterval:    30 * time.Second,     // 30秒健康检查一次
+		MaxOpenConns:         50,                  // 最大50个连接（提高并发）
+		MaxIdleConns:         20,                  // 最大20个空闲（提高响应速度）
+		ConnMaxLifetime:       60 * time.Minute,    // 连接最长60分钟（延长连接生命周期）
+		ConnMaxIdleTime:       15 * time.Minute,    // 空闲15分钟关闭（更长的空闲时间）
+		MinIdleConns:         5,                   // 保持5个最小空闲（更好的响应性能）
+		ConnTimeout:           3 * time.Second,      // 连接超时3秒（更快失败）
+		HealthCheckInterval:   20 * time.Second,     // 20秒健康检查一次（更频繁的健康检查）
 		EnableWarmup:         true,                // 启用预热
 		EnableSlowConnLog:     true,                // 启用慢连接日志
-		SlowConnThreshold:     500 * time.Millisecond, // 超过500ms算慢连接
-		MaxPoolCapacity:      50,                  // 连接池最大容量
+		SlowConnThreshold:     200 * time.Millisecond, // 超过200ms算慢连接（更严格的性能要求）
+		MaxPoolCapacity:      100,                 // 连接池最大容量（支持更高并发）
+		
+		// 动态连接池配置（更智能的调整策略）
+		EnableDynamicScaling: true,               // 启用动态调整
+		DynamicScaleFactor:   1.8,                // 调整因子1.8倍（更激进的扩容）
+		ScaleUpThreshold:     0.7,                // 使用率超过70%扩容（更早扩容）
+		ScaleDownThreshold:   0.4,                // 使用率低于40%缩容（避免频繁调整）
+		MinScaleUpInterval:   1 * time.Minute,     // 最小扩容间隔1分钟（更快的响应）
+		MinScaleDownInterval: 3 * time.Minute,     // 最小缩容间隔3分钟（稳定缩容）
+		MaxIdleTimeForScale:  20 * time.Minute,    // 用于调整的最大空闲时间
 	}
 }

@@ -94,6 +112,13 @@ type MySQLConnectionPool struct {
 	stats      PoolStats
 	stopCh     chan struct{}
 	wg         sync.WaitGroup
+	
+	// 动态调整相关
+	lastScaleUpTime    time.Time       // 上次扩容时间
+	lastScaleDownTime  time.Time       // 上次缩容时间
+	currentTargetSize  int             // 当前目标连接数
+	usageHistory      []float64       // 使用率历史记录（用于智能调整）
+	adaptiveWeights    map[uint]float64 // 连接权重（基于性能表现）
 }

 // NewMySQLConnectionPool 创建新的 MySQL 连接池
@@ -103,10 +128,13 @@ func NewMySQLConnectionPool(config *PoolConfig) *MySQLConnectionPool {
 	}

 	pool := &MySQLConnectionPool{
-		config:  config,
-		entries: make([]*MySQLPoolEntry, 0, config.MaxPoolCapacity),
-		connMap: make(map[uint]*MySQLClient),
-		stopCh:  make(chan struct{}),
+		config:           config,
+		entries:          make([]*MySQLPoolEntry, 0, config.MaxPoolCapacity),
+		connMap:          make(map[uint]*MySQLClient),
+		stopCh:           make(chan struct{}),
+		currentTargetSize: config.MinIdleConns,
+		usageHistory:    make([]float64, 0, 100), // 保留最近100个使用率记录
+		adaptiveWeights: make(map[uint]float64),
 	}

 	return pool
@@ -119,7 +147,15 @@ func (p *MySQLConnectionPool) Acquire(conn *models.DbConnection) (*MySQLPoolEntr

 	startTime := time.Now()

-	// 尝试从池中获取空闲连接
+	// 尝试获取最优连接（启用动态调整时）
+	if p.config.EnableDynamicScaling {
+		if entry, err := p.getOptimalConnection(); err == nil {
+			p.updateWaitStats(startTime)
+			return entry, nil
+		}
+	}
+
+	// 降级到标准逻辑 - 查找空闲连接
 	for _, entry := range p.entries {
 		entry.mu.Lock()
 		if !entry.InUse {
@@ -138,13 +174,13 @@ func (p *MySQLConnectionPool) Acquire(conn *models.DbConnection) (*MySQLPoolEntr
 	// 没有可用连接，创建新连接
 	if len(p.entries) >= p.config.MaxOpenConns {
 		// 已达到最大连接数，等待
-		return nil, p.waitForAvailableConnection(conn)
+		return p.waitForAvailableConnection(conn)
 	}

-	// 创建新连接
+	// 创建新连接（使用传入的连接配置）
 	newEntry, err := p.createNewEntry(conn)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("创建连接失败: %v", err)
 	}

 	p.entries = append(p.entries, newEntry)
@@ -160,15 +196,14 @@ func (p *MySQLConnectionPool) Release(entry *MySQLPoolEntry) error {
 		return nil
 	}

-	entry.mu.Lock()
-	defer entry.mu.Unlock()
-
-	entry.InUse = false
-	entry.LastUsed = time.Now()
-
 	p.mu.Lock()
 	defer p.mu.Unlock()

+	entry.mu.Lock()
+	entry.InUse = false
+	entry.LastUsed = time.Now()
+	entry.mu.Unlock()
+
 	p.updateStats()

 	return nil
@@ -240,35 +275,9 @@ func (p *MySQLConnectionPool) cleanupIdleConnections() {
 	p.updateStats()
 }

-// healthCheck 健康检查
+// healthCheck 健康检查（增强版本）
 func (p *MySQLConnectionPool) healthCheck() {
-	p.mu.RLock()
-	entriesCopy := make([]*MySQLPoolEntry, len(p.entries))
-	copy(entriesCopy, p.entries)
-	p.mu.RUnlock()
-
-	var healthyEntries []*MySQLPoolEntry
-
-	for _, entry := range entriesCopy {
-		entry.mu.Lock()
-		if !entry.InUse {
-			// Ping 测试
-			if err := entry.Client.sqlDB.Ping(); err != nil {
-				// 连接失效，标记为需要关闭
-				entry.mu.Unlock()
-				entry.Client.Close()
-				continue
-			}
-		}
-		entry.mu.Unlock()
-		healthyEntries = append(healthyEntries, entry)
-	}
-
-	// 更新连接池
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	p.entries = healthyEntries
-	p.updateStats()
+	p.enhancedHealthCheck()
 }

 // StartMaintenance 启动维护协程（清理和健康检查）
@@ -277,16 +286,28 @@ func (p *MySQLConnectionPool) StartMaintenance() {
 	go func() {
 		defer p.wg.Done()

-		ticker := time.NewTicker(p.config.HealthCheckInterval)
-		defer ticker.Stop()
+		// 健康检查Ticker
+		healthTicker := time.NewTicker(p.config.HealthCheckInterval)
+		defer healthTicker.Stop()
+
+		// 动态调整Ticker（较短间隔）
+		scaleTicker := time.NewTicker(1 * time.Minute)
+		defer scaleTicker.Stop()

 		for {
 			select {
-			case <-ticker.C:
+			case <-healthTicker.C:
 				// 清理空闲连接
 				p.cleanupIdleConnections()
 				// 健康检查
 				p.healthCheck()
+				
+			case <-scaleTicker.C:
+				// 动态连接池调整
+				if p.config.EnableDynamicScaling {
+					p.adaptiveScaling()
+				}
+				
 			case <-p.stopCh:
 				return
 			}
@@ -323,10 +344,8 @@ func (p *MySQLConnectionPool) createNewEntry(conn *models.DbConnection) (*MySQLP
 	return entry, nil
 }

-// waitForAvailableConnection 等待可用连接
-func (p *MySQLConnectionPool) waitForAvailableConnection(conn *models.DbConnection) error {
-	// 实现简单的等待逻辑（使用 channel）
-	// 创建一个超时上下文
+// waitForAvailableConnection 等待可用连接并获取它
+func (p *MySQLConnectionPool) waitForAvailableConnection(conn *models.DbConnection) (*MySQLPoolEntry, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()

@@ -336,34 +355,29 @@ func (p *MySQLConnectionPool) waitForAvailableConnection(conn *models.DbConnecti
 	for {
 		select {
 		case <-ctx.Done():
-			return ErrPoolExhausted
+			return nil, ErrPoolExhausted
 		case <-ticker.C:
-			// 检查是否有可用连接
-			p.mu.RLock()
-			hasAvailable := false
+			p.mu.Lock()
 			for _, entry := range p.entries {
 				entry.mu.Lock()
 				if !entry.InUse {
-					hasAvailable = true
+					entry.InUse = true
+					entry.LastUsed = time.Now()
 					entry.mu.Unlock()
-					break
+					p.mu.Unlock()
+					return entry, nil
 				}
 				entry.mu.Unlock()
 			}
-			p.mu.RUnlock()
-
-			if hasAvailable {
-				return nil
-			}
+			p.mu.Unlock()
 		}
 	}
 }

-// updateWaitStats 更新等待统计
+// updateWaitStats 更新等待统计（调用方必须持有 p.mu）
 func (p *MySQLConnectionPool) updateWaitStats(startTime time.Time) {
-	waitDuration := time.Since(startTime)
 	p.stats.WaitCount++
-	p.stats.WaitDuration += waitDuration
+	p.stats.WaitDuration += time.Since(startTime)
 }

 // updateStats 更新连接池统计
@@ -387,6 +401,244 @@ func (p *MySQLConnectionPool) updateStats() {
 	p.stats.IdleConns = idle
 }

+// adaptiveScaling 自适应连接池调整
+func (p *MySQLConnectionPool) adaptiveScaling() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	// 计算当前使用率
+	if len(p.entries) == 0 {
+		return
+	}
+
+	usageRate := float64(p.stats.ActiveConns) / float64(len(p.entries))
+	
+	// 记录使用率历史
+	p.usageHistory = append(p.usageHistory, usageRate)
+	if len(p.usageHistory) > 100 {
+		p.usageHistory = p.usageHistory[1:]
+	}
+
+	// 检查是否需要调整
+	now := time.Now()
+	
+	// 扩容逻辑
+	if usageRate >= p.config.ScaleUpThreshold {
+		if now.Sub(p.lastScaleUpTime) >= p.config.MinScaleUpInterval {
+			p.scaleUp()
+			p.lastScaleUpTime = now
+		}
+		return
+	}
+
+	// 缩容逻辑
+	if usageRate <= p.config.ScaleDownThreshold && len(p.entries) > p.config.MinIdleConns {
+		if now.Sub(p.lastScaleDownTime) >= p.config.MinScaleDownInterval {
+			p.scaleDown()
+			p.lastScaleDownTime = now
+		}
+	}
+}
+
+// scaleUp 扩容
+func (p *MySQLConnectionPool) scaleUp() {
+	// scaleUp 仅更新目标大小，实际连接在 Acquire 时按需创建
+	// 移除了创建无效虚拟连接的逻辑
+	currentSize := len(p.entries)
+	scaleFactor := p.config.DynamicScaleFactor
+
+	newSize := int(float64(currentSize) * scaleFactor)
+	newSize = min(newSize, p.config.MaxOpenConns)
+	newSize = max(newSize, currentSize+1)
+
+	p.currentTargetSize = newSize
+	p.updateStats()
+}
+
+// scaleDown 缩容
+func (p *MySQLConnectionPool) scaleDown() {
+	// 计算新目标大小
+	currentSize := len(p.entries)
+	scaleFactor := 1.0 / p.config.DynamicScaleFactor
+	
+	newSize := int(float64(currentSize) * scaleFactor)
+	newSize = max(newSize, p.config.MinIdleConns)
+	newSize = min(newSize, currentSize-1) // 至少减少1个连接
+
+	if newSize < currentSize {
+		// 关闭多余的空闲连接
+		p.closeIdleConnections(currentSize - newSize)
+		p.currentTargetSize = newSize
+		p.updateStats()
+	}
+}
+
+// closeIdleConnections 关闭指定数量的空闲连接
+func (p *MySQLConnectionPool) closeIdleConnections(count int) {
+	// 收集空闲连接
+	idleEntries := make([]*MySQLPoolEntry, 0)
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			idleEntries = append(idleEntries, entry)
+		}
+		entry.mu.Unlock()
+	}
+
+	// 关闭指定数量的空闲连接
+	closedEntries := make(map[*MySQLPoolEntry]bool)
+	for i := 0; i < min(count, len(idleEntries)); i++ {
+		entry := idleEntries[i]
+		entry.mu.Lock()
+		entry.Client.Close()
+		entry.mu.Unlock()
+		closedEntries[entry] = true
+	}
+
+	// 重新构建连接池
+	remainingEntries := make([]*MySQLPoolEntry, 0, len(p.entries))
+	for _, entry := range p.entries {
+		if closedEntries[entry] {
+			continue // 跳过已关闭的连接
+		}
+		remainingEntries = append(remainingEntries, entry)
+	}
+
+	p.entries = remainingEntries
+}
+
+// enhancedHealthCheck 增强的健康检查
+func (p *MySQLConnectionPool) enhancedHealthCheck() {
+	p.mu.RLock()
+	entriesCopy := make([]*MySQLPoolEntry, len(p.entries))
+	copy(entriesCopy, p.entries)
+	p.mu.RUnlock()
+
+	var healthyEntries []*MySQLPoolEntry
+	var performanceWeights []float64
+
+	for _, entry := range entriesCopy {
+		entry.mu.Lock()
+		isIdle := !entry.InUse
+
+		// 测试连接有效性
+		isHealthy := true
+		startTime := time.Now()
+
+		if isIdle {
+			// 空闲连接：简单Ping测试
+			if err := entry.Client.sqlDB.Ping(); err != nil {
+				isHealthy = false
+				// 关闭失效连接
+				entry.Client.Close()
+			}
+		} else {
+			// 使用中的连接：快速测试（避免影响正常查询）
+			func() {
+				ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+				defer cancel()
+				if err := entry.Client.sqlDB.PingContext(ctx); err != nil {
+					isHealthy = false
+				}
+			}()
+		}
+
+		// 计算连接性能权重
+		if isHealthy {
+			healthyEntries = append(healthyEntries, entry)
+
+			// 基于连接性能计算权重
+			responseTime := time.Since(startTime).Microseconds()
+			weight := 1.0 / max(float64(responseTime)/1000.0, 1.0) // 转换为毫秒，避免除零
+
+			performanceWeights = append(performanceWeights, weight)
+		} else {
+			// 不健康的连接
+			if isIdle {
+				entry.Client.Close()
+			}
+		}
+
+		entry.mu.Unlock()
+	}
+
+	// 更新连接池
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	p.entries = healthyEntries
+
+	// 更新自适应权重
+	if len(healthyEntries) > 0 {
+		for i := range healthyEntries {
+			if i < len(performanceWeights) {
+				p.adaptiveWeights[uint(i)] = performanceWeights[i]
+			}
+		}
+	}
+
+	p.updateStats()
+}
+
+// warmUp 连接池预热
+func (p *MySQLConnectionPool) warmUp() {
+	if !p.config.EnableWarmup {
+		return
+	}
+
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	currentIdle := 0
+	for _, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			currentIdle++
+		}
+		entry.mu.Unlock()
+	}
+
+	targetIdle := p.config.MinIdleConns
+	needed := targetIdle - currentIdle
+
+	// warmUp 仅记录目标大小，不在无连接配置的情况下创建无效虚拟连接
+	// 实际连接在 Acquire 时按需创建
+	_ = needed
+
+	p.updateStats()
+}
+
+// getOptimalConnection 获取最优连接（基于性能权重）
+// 注意：调用方必须已持有 p.mu
+func (p *MySQLConnectionPool) getOptimalConnection() (*MySQLPoolEntry, error) {
+	var bestEntry *MySQLPoolEntry
+	var bestWeight float64
+
+	for i, entry := range p.entries {
+		entry.mu.Lock()
+		if !entry.InUse {
+			weight := 1.0 // 默认权重
+			if w, ok := p.adaptiveWeights[uint(i)]; ok {
+				weight = w
+			}
+
+			if bestEntry == nil || weight > bestWeight {
+				bestEntry = entry
+				bestWeight = weight
+			}
+		}
+		entry.mu.Unlock()
+	}
+
+	if bestEntry == nil {
+		return nil, ErrPoolExhausted
+	}
+
+	bestEntry.InUse = true
+	bestEntry.LastUsed = time.Now()
+	return bestEntry, nil
+}
+
 // createMySQLClient 创建 MySQL 客户端的辅助函数
 func createMySQLClient(conn *models.DbConnection) (*MySQLClient, error) {
 	// 解密密码
@@ -424,3 +676,4 @@ func (e *PoolError) Error() string {
 	}
 	return e.Message
 }
+