refactor: 系统性清理common包中的死代码和未使用变量

主要清理内容：
- logging包：移除DetailedFormatter、JSONFormatter及相关方法
- output包：清理Manager和Statistics中的未使用方法
- parsers包：移除各Parser中的Validate()和GetStatistics()方法
- proxy包：清理Factory和Global中的所有未使用函数
- ProgressManager：移除未使用的进度条方法和字段
- globals：清理未使用的status变量

技术改进：
- 使用deadcode和golangci-lint工具系统性检测
- 保持代码结构清晰，添加清理注释
- 修复相关依赖引用问题
- 确保编译通过和功能正常

代码减少：移除约40个死代码函数和多个未使用字段

Common/Parse.go

@@ -507,6 +507,6 @@ func applyLogLevel() {
 
 		// 更新全局日志管理器
 		globalLogger = newLogger
-		status = newLogger.GetScanStatus()
+		// status变量已移除，如需获取状态请直接调用newLogger.GetScanStatus()
 	}
 }

Common/ProgressManager.go

@@ -31,8 +31,6 @@ type ProgressManager struct {
 	
 	// 输出缓冲相关
 	outputMutex      sync.Mutex
-	pendingOutputs   []string
-	needProgressRedraw bool
 }
 
 var (
@@ -96,22 +94,9 @@ func (pm *ProgressManager) UpdateProgress(increment int64) {
 	pm.renderProgress()
 }
 
-// SetProgress 设置当前进度
+// =============================================================================================
-func (pm *ProgressManager) SetProgress(current int64) {
+// 已删除的死代码（未使用）：SetProgress 设置当前进度
-	if !pm.enabled || !pm.isActive {
+// =============================================================================================
-		return
-	}
-	
-	pm.mu.Lock()
-	defer pm.mu.Unlock()
-	
-	pm.current = current
-	if pm.current > pm.total {
-		pm.current = pm.total
-	}
-	
-	pm.renderProgress()
-}
 
 // FinishProgress 完成进度条
 func (pm *ProgressManager) FinishProgress() {
@@ -140,17 +125,9 @@ func (pm *ProgressManager) setupProgressSpace() {
 	pm.lastContentLine = 0
 }
 
-// moveToContentArea 移动到内容输出区域
+// =============================================================================================
-func (pm *ProgressManager) moveToContentArea() {
+// 已删除的死代码（未使用）：moveToContentArea 和 moveToProgressLine 方法
-	// 对于简化的实现，直接在当前位置输出内容
+// =============================================================================================
-	// 不需要复杂的光标移动
-}
-
-// moveToProgressLine 移动到进度条位置
-func (pm *ProgressManager) moveToProgressLine() {
-	// 移动到行首准备重绘进度条
-	fmt.Print("\r")
-}
 
 // renderProgress 渲染进度条（使用锁避免输出冲突）
 func (pm *ProgressManager) renderProgress() {
@@ -279,9 +256,9 @@ func UpdateProgressBar(increment int64) {
 	GetProgressManager().UpdateProgress(increment)
 }
 
-func SetProgressBar(current int64) {
+// =============================================================================================
-	GetProgressManager().SetProgress(current)
+// 已删除的死代码（未使用）：SetProgressBar 全局函数
-}
+// =============================================================================================
 
 func FinishProgressBar() {
 	GetProgressManager().FinishProgress()

Common/common.go

@@ -151,7 +151,6 @@ func InitOutput() error {
 		return err
 	}
 	ResultOutput = manager
-	output.SetGlobalManager(manager)
 	return nil
 }
 

Common/globals.go

@@ -85,7 +85,6 @@ var (
 	OutputMutex  sync.Mutex
 
 	// 日志状态
-	status      = logging.NewScanStatus()
 	Num, End    int64
 	StartTime   = time.Now()
 	

Common/logging/Formatter.go

@@ -68,58 +68,8 @@ func (f *StandardFormatter) getLevelPrefix(level LogLevel) string {
 	}
 }
 
-// DetailedFormatter 详细日志格式化器
+// =============================================================================================
-type DetailedFormatter struct {
+// 已删除的死代码（未使用）：
-	StandardFormatter
+// DetailedFormatter 及其 Format() 方法
-	includeSource   bool
+// JSONFormatter 及其 SetStartTime() 和 Format() 方法
-	includeMetadata bool
+// =============================================================================================
-}
-
-// Format 格式化日志条目（包含详细信息）
-func (f *DetailedFormatter) Format(entry *LogEntry) string {
-	baseFormat := f.StandardFormatter.Format(entry)
-
-	if f.includeSource && entry.Source != "" {
-		baseFormat += fmt.Sprintf(" [%s]", entry.Source)
-	}
-
-	if f.includeMetadata && len(entry.Metadata) > 0 {
-		baseFormat += fmt.Sprintf(" %v", entry.Metadata)
-	}
-
-	return baseFormat
-}
-
-// JSONFormatter JSON格式化器
-type JSONFormatter struct {
-	startTime time.Time
-}
-
-// SetStartTime 设置开始时间
-func (f *JSONFormatter) SetStartTime(startTime time.Time) {
-	f.startTime = startTime
-}
-
-// Format 格式化为JSON格式
-func (f *JSONFormatter) Format(entry *LogEntry) string {
-	elapsed := time.Since(f.startTime)
-
-	jsonStr := fmt.Sprintf(`{"level":"%s","time":"%s","elapsed_ms":%d,"content":"%s"`,
-		entry.Level,
-		entry.Time.Format("2006-01-02T15:04:05.000Z07:00"),
-		elapsed.Milliseconds(),
-		entry.Content)
-
-	if entry.Source != "" {
-		jsonStr += fmt.Sprintf(`,"source":"%s"`, entry.Source)
-	}
-
-	if len(entry.Metadata) > 0 {
-		jsonStr += `,"metadata":`
-		// 这里为简化处理，使用简单的格式
-		jsonStr += fmt.Sprintf(`%v`, entry.Metadata)
-	}
-
-	jsonStr += "}"
-	return jsonStr
-}

Common/logging/Logger.go

@@ -6,7 +6,6 @@ import (
 	"log"
 	"path/filepath"
 	"runtime"
-	"strings"
 	"sync"
 	"time"
 
@@ -50,13 +49,9 @@ func NewLogger(config *LoggerConfig) *Logger {
 	return logger
 }
 
-// SetFormatter 设置格式化器
+// =============================================================================================
-func (l *Logger) SetFormatter(formatter LogFormatter) {
+// 已删除的死代码（未使用）：SetFormatter 方法
-	l.mu.Lock()
+// =============================================================================================
-	defer l.mu.Unlock()
-	l.formatter = formatter
-	l.formatter.SetStartTime(l.config.StartTime)
-}
 
 // AddHandler 添加日志处理器
 func (l *Logger) AddHandler(handler LogHandler) {
@@ -308,32 +303,6 @@ func (h *ConsoleHandler) IsEnabled() bool {
 	return h.enabled
 }
 
-// 错误检查函数（保持原有逻辑）
+// =============================================================================================
-func CheckErrs(err error) error {
+// 已删除的死代码（未使用）：CheckErrs 错误检查函数
-	if err == nil {
+// =============================================================================================
-		return nil
-	}
-
-	// 已知需要重试的错误列表
-	errs := []string{
-		"closed by the remote host", "too many connections",
-		"EOF", "A connection attempt failed",
-		"established connection failed", "connection attempt failed",
-		"Unable to read", "is not allowed to connect to this",
-		"no pg_hba.conf entry",
-		"No connection could be made",
-		"invalid packet size",
-		"bad connection",
-	}
-
-	// 检查错误是否匹配
-	errLower := strings.ToLower(err.Error())
-	for _, key := range errs {
-		if strings.Contains(errLower, strings.ToLower(key)) {
-			time.Sleep(1 * time.Second)
-			return err
-		}
-	}
-
-	return nil
-}

Common/logging/Types.go

@@ -104,40 +104,10 @@ func (s *ScanStatus) UpdateError() {
 	s.lastError = time.Now()
 }
 
-// GetLastSuccess 获取最后成功时间
+// =============================================================================================
-func (s *ScanStatus) GetLastSuccess() time.Time {
+// 已删除的死代码（未使用）：
-	s.mu.RLock()
+// GetLastSuccess, GetLastError, SetTotal, SetCompleted, GetProgress 方法
-	defer s.mu.RUnlock()
+// =============================================================================================
-	return s.lastSuccess
-}
-
-// GetLastError 获取最后错误时间
-func (s *ScanStatus) GetLastError() time.Time {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.lastError
-}
-
-// SetTotal 设置总任务数
-func (s *ScanStatus) SetTotal(total int64) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.total = total
-}
-
-// SetCompleted 设置已完成任务数
-func (s *ScanStatus) SetCompleted(completed int64) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.completed = completed
-}
-
-// GetProgress 获取进度信息
-func (s *ScanStatus) GetProgress() (int64, int64) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.completed, s.total
-}
 
 // ProgressDisplay 进度条显示接口
 type ProgressDisplay interface {

Common/output/Manager.go

@@ -202,47 +202,10 @@ func (m *Manager) flushBufferUnsafe() error {
 	return nil
 }
 
-// GetResults 获取扫描结果
+// =============================================================================================
-func (m *Manager) GetResults() ([]*ScanResult, error) {
+// 已删除的死代码（未使用）：
-	return m.GetResultsWithFilter(nil)
+// GetResults, GetResultsWithFilter, GetStatistics, Flush 方法
-}
+// =============================================================================================
-
-// GetResultsWithFilter 获取过滤后的扫描结果
-func (m *Manager) GetResultsWithFilter(filter *ResultFilter) ([]*ScanResult, error) {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	if m.reader == nil {
-		return nil, fmt.Errorf("当前输出格式不支持读取")
-	}
-
-	return m.reader.ReadWithFilter(filter)
-}
-
-// GetStatistics 获取统计信息
-func (m *Manager) GetStatistics() *Statistics {
-	return m.statistics
-}
-
-// Flush 刷新所有缓冲区
-func (m *Manager) Flush() error {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	if !m.initialized || m.closed {
-		return nil
-	}
-
-	// 刷新缓冲区
-	if m.config.EnableBuffer {
-		if err := m.flushBuffer(); err != nil {
-			return err
-		}
-	}
-
-	// 刷新写入器
-	return m.writer.Flush()
-}
 
 // Close 关闭输出管理器
 func (m *Manager) Close() error {
@@ -281,82 +244,11 @@ func (m *Manager) Close() error {
 	return err
 }
 
-// IsInitialized 检查是否已初始化
+// =============================================================================================
-func (m *Manager) IsInitialized() bool {
+// 已删除的死代码（未使用）：
-	m.mu.RLock()
+// IsInitialized, IsClosed, GetConfig, UpdateConfig 方法
-	defer m.mu.RUnlock()
+// =============================================================================================
-	return m.initialized
-}
 
-// IsClosed 检查是否已关闭
+// =============================================================================================
-func (m *Manager) IsClosed() bool {
+// 已删除的死代码（未使用）：globalManager 全局变量及 SetGlobalManager 函数
-	m.mu.RLock()
+// =============================================================================================
-	defer m.mu.RUnlock()
-	return m.closed
-}
-
-// GetConfig 获取配置
-func (m *Manager) GetConfig() *ManagerConfig {
-	m.mu.RLock()
-	defer m.mu.RUnlock()
-
-	// 返回配置副本
-	config := *m.config
-	return &config
-}
-
-// UpdateConfig 更新配置（部分配置可以动态更新）
-func (m *Manager) UpdateConfig(updates map[string]interface{}) error {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	if m.closed {
-		return fmt.Errorf("输出管理器已关闭")
-	}
-
-	// 只允许更新部分配置
-	for key, value := range updates {
-		switch key {
-		case "enable_buffer":
-			if enableBuffer, ok := value.(bool); ok {
-				m.config.EnableBuffer = enableBuffer
-			}
-		case "buffer_size":
-			if bufferSize, ok := value.(int); ok && bufferSize > 0 {
-				m.config.BufferSize = bufferSize
-			}
-		case "auto_flush":
-			if autoFlush, ok := value.(bool); ok {
-				m.config.AutoFlush = autoFlush
-				if autoFlush && m.flushTicker == nil {
-					m.startAutoFlush()
-				} else if !autoFlush && m.flushTicker != nil {
-					m.flushTicker.Stop()
-					m.flushTicker = nil
-				}
-			}
-		case "flush_interval":
-			if flushInterval, ok := value.(time.Duration); ok && flushInterval > 0 {
-				m.config.FlushInterval = flushInterval
-				if m.flushTicker != nil {
-					m.flushTicker.Stop()
-					m.startAutoFlush()
-				}
-			}
-		default:
-			return fmt.Errorf("不支持更新的配置项: %s", key)
-		}
-	}
-
-	return nil
-}
-
-// 全局输出管理器实例
-var (
-	globalManager *Manager
-)
-
-// SetGlobalManager 设置全局输出管理器
-func SetGlobalManager(manager *Manager) {
-	globalManager = manager
-}

Common/output/Types.go

@@ -113,39 +113,7 @@ func (s *Statistics) AddResult(resultType ResultType) {
 	s.LastUpdate = time.Now()
 }
 
-// GetTotalResults 获取总结果数
+// =============================================================================================
-func (s *Statistics) GetTotalResults() int64 {
+// 已删除的死代码（未使用）：
-	s.mu.RLock()
+// GetTotalResults, GetTypeCounts, GetDuration, Reset 方法
-	defer s.mu.RUnlock()
+// =============================================================================================
-	return s.TotalResults
-}
-
-// GetTypeCounts 获取类型计数
-func (s *Statistics) GetTypeCounts() map[ResultType]int64 {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// 返回副本以避免并发问题
-	counts := make(map[ResultType]int64)
-	for k, v := range s.TypeCounts {
-		counts[k] = v
-	}
-	return counts
-}
-
-// GetDuration 获取运行时长
-func (s *Statistics) GetDuration() time.Duration {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.LastUpdate.Sub(s.StartTime)
-}
-
-// Reset 重置统计信息
-func (s *Statistics) Reset() {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.TotalResults = 0
-	s.TypeCounts = make(map[ResultType]int64)
-	s.StartTime = time.Now()
-	s.LastUpdate = time.Now()
-}

Common/parsers/CredentialParser.go

@@ -358,19 +358,6 @@ func (cp *CredentialParser) generateStatistics(usernames, passwords, hashValues
 	}
 }
 
-// Validate 验证解析结果
+// =============================================================================================
-func (cp *CredentialParser) Validate() error {
+// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
-	// 基本验证逻辑
+// =============================================================================================
-	return nil
-}
-
-// GetStatistics 获取解析统计
-func (cp *CredentialParser) GetStatistics() interface{} {
-	cp.mu.RLock()
-	defer cp.mu.RUnlock()
-	
-	return map[string]interface{}{
-		"parser_type": "credential",
-		"options":     cp.options,
-	}
-}

Common/parsers/FileReader.go

@@ -122,63 +122,9 @@ func (fr *FileReader) ReadFile(filename string, options ...*FileReaderOptions) (
 	}
 }
 
-// ReadFiles 并发读取多个文件
+// =============================================================================================
-func (fr *FileReader) ReadFiles(filenames []string, options ...*FileReaderOptions) (map[string]*FileResult, error) {
+// 已删除的死代码（未使用）：ReadFiles 并发读取多个文件的方法
-	if len(filenames) == 0 {
+// =============================================================================================
-		return nil, NewParseError("FILE_ERROR", "文件列表为空", "", 0, ErrEmptyInput)
-	}
-
-	opts := fr.mergeOptions(options...)
-	results := make(map[string]*FileResult)
-	resultsChan := make(chan struct {
-		filename string
-		result   *FileResult
-		err      error
-	}, len(filenames))
-
-	// 并发读取文件
-	var wg sync.WaitGroup
-	semaphore := make(chan struct{}, 4) // 限制并发数
-
-	for _, filename := range filenames {
-		wg.Add(1)
-		go func(fname string) {
-			defer wg.Done()
-			semaphore <- struct{}{} // 获取信号量
-			defer func() { <-semaphore }() // 释放信号量
-
-			result, err := fr.ReadFile(fname, opts)
-			resultsChan <- struct {
-				filename string
-				result   *FileResult
-				err      error
-			}{fname, result, err}
-		}(filename)
-	}
-
-	// 等待所有协程完成
-	go func() {
-		wg.Wait()
-		close(resultsChan)
-	}()
-
-	// 收集结果
-	var errors []error
-	for res := range resultsChan {
-		if res.err != nil {
-			errors = append(errors, res.err)
-		} else {
-			results[res.filename] = res.result
-		}
-	}
-
-	// 如果有错误且所有文件都失败，返回第一个错误
-	if len(errors) > 0 && len(results) == 0 {
-		return nil, errors[0]
-	}
-
-	return results, nil
-}
 
 // readFileSync 同步读取文件
 func (fr *FileReader) readFileSync(filename string, options *FileReaderOptions) (*FileResult, error) {
@@ -340,21 +286,6 @@ func (fr *FileReader) addToCache(filename string, result *FileResult) {
 	fr.cache[filename] = result
 }
 
-// ClearCache 清空缓存
+// =============================================================================================
-func (fr *FileReader) ClearCache() {
+// 已删除的死代码（未使用）：ClearCache 和 GetCacheStats 方法
-	fr.mu.Lock()
+// =============================================================================================
-	defer fr.mu.Unlock()
-	fr.cache = make(map[string]*FileResult)
-}
-
-// GetCacheStats 获取缓存统计
-func (fr *FileReader) GetCacheStats() map[string]interface{} {
-	fr.mu.RLock()
-	defer fr.mu.RUnlock()
-	
-	return map[string]interface{}{
-		"cache_size":     len(fr.cache),
-		"max_cache_size": fr.maxCacheSize,
-		"cache_enabled":  fr.enableCache,
-	}
-}

Common/parsers/NetworkParser.go

@@ -369,18 +369,6 @@ func (np *NetworkParser) isValidCookie(cookie string) bool {
 	return cookieRegex.MatchString(strings.TrimSpace(cookie))
 }
 
-// Validate 验证解析结果
+// =============================================================================================
-func (np *NetworkParser) Validate() error {
+// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
-	return nil
+// =============================================================================================
-}
-
-// GetStatistics 获取解析统计
-func (np *NetworkParser) GetStatistics() interface{} {
-	np.mu.RLock()
-	defer np.mu.RUnlock()
-	
-	return map[string]interface{}{
-		"parser_type": "network",
-		"options":     np.options,
-	}
-}

Common/parsers/TargetParser.go

@@ -868,18 +868,6 @@ func (tp *TargetParser) generateStatistics(hosts, urls []string, ports, excludeP
 	}
 }
 
-// Validate 验证解析结果
+// =============================================================================================
-func (tp *TargetParser) Validate() error {
+// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
-	return nil
+// =============================================================================================
-}
-
-// GetStatistics 获取解析统计
-func (tp *TargetParser) GetStatistics() interface{} {
-	tp.mu.RLock()
-	defer tp.mu.RUnlock()
-	
-	return map[string]interface{}{
-		"parser_type": "target",
-		"options":     tp.options,
-	}
-}

Common/parsers/ValidationParser.go

@@ -286,18 +286,6 @@ func (vp *ValidationParser) validateScanMode(scanMode string) error {
 }
 
 
-// Validate 验证解析结果
+// =============================================================================================
-func (vp *ValidationParser) Validate() error {
+// 已删除的死代码（未使用）：Validate 和 GetStatistics 方法
-	return nil
+// =============================================================================================
-}
-
-// GetStatistics 获取解析统计
-func (vp *ValidationParser) GetStatistics() interface{} {
-	vp.mu.RLock()
-	defer vp.mu.RUnlock()
-	
-	return map[string]interface{}{
-		"parser_type": "validation",
-		"options":     vp.options,
-	}
-}

Common/proxy/Factory.go

@@ -1,186 +1,14 @@
 package proxy
 
-import (
+// 已清理未使用的导入
-	"fmt"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-)
 
-// ParseProxyURL 解析代理URL
+// =============================================================================================
-func ParseProxyURL(proxyURL string) (*ProxyConfig, error) {
+// 已删除的死代码（未使用）：
-	if proxyURL == "" {
+// - ParseProxyURL: 解析代理URL
-		return DefaultProxyConfig(), nil
+// - CreateProxyManager: 创建代理管理器  
-	}
+// - ValidateProxyConfig: 验证代理配置
-	
+// - GetProxyTypeFromString: 从字符串获取代理类型
-	u, err := url.Parse(proxyURL)
+// - BuildProxyURL: 构建代理URL
-	if err != nil {
+// - IsProxyEnabled: 检查是否启用了代理
-		return nil, NewProxyError(ErrTypeConfig, "代理URL解析失败", 6001, err)
+// - GetDefaultProxyConfigForType: 获取指定类型的默认配置
-	}
+// =============================================================================================
-	
-	config := DefaultProxyConfig()
-	
-	// 设置代理类型
-	switch strings.ToLower(u.Scheme) {
-	case "http":
-		config.Type = ProxyTypeHTTP
-	case "https":
-		config.Type = ProxyTypeHTTPS
-	case "socks5":
-		config.Type = ProxyTypeSOCKS5
-	default:
-		return nil, NewProxyError(ErrTypeConfig, 
-			fmt.Sprintf("不支持的代理协议: %s", u.Scheme), 6002, nil)
-	}
-	
-	// 设置地址
-	config.Address = u.Host
-	
-	// 设置认证信息
-	if u.User != nil {
-		config.Username = u.User.Username()
-		config.Password, _ = u.User.Password()
-	}
-	
-	// 解析查询参数中的配置
-	query := u.Query()
-	
-	// 超时设置
-	if timeout := query.Get("timeout"); timeout != "" {
-		if t, err := time.ParseDuration(timeout); err == nil {
-			config.Timeout = t
-		}
-	}
-	
-	// 最大重试次数
-	if retries := query.Get("retries"); retries != "" {
-		if r, err := strconv.Atoi(retries); err == nil {
-			config.MaxRetries = r
-		}
-	}
-	
-	// 保活时间
-	if keepalive := query.Get("keepalive"); keepalive != "" {
-		if ka, err := time.ParseDuration(keepalive); err == nil {
-			config.KeepAlive = ka
-		}
-	}
-	
-	return config, nil
-}
-
-// CreateProxyManager 创建代理管理器
-func CreateProxyManager(proxyURL string) (ProxyManager, error) {
-	config, err := ParseProxyURL(proxyURL)
-	if err != nil {
-		return nil, err
-	}
-	
-	return NewProxyManager(config), nil
-}
-
-// ValidateProxyConfig 验证代理配置
-func ValidateProxyConfig(config *ProxyConfig) error {
-	if config == nil {
-		return NewProxyError(ErrTypeConfig, "配置不能为空", 6003, nil)
-	}
-	
-	// 验证代理类型
-	if config.Type < ProxyTypeNone || config.Type > ProxyTypeSOCKS5 {
-		return NewProxyError(ErrTypeConfig, "无效的代理类型", 6004, nil)
-	}
-	
-	// 如果不是直连，必须有地址
-	if config.Type != ProxyTypeNone && config.Address == "" {
-		return NewProxyError(ErrTypeConfig, "代理地址不能为空", 6005, nil)
-	}
-	
-	// 验证超时时间
-	if config.Timeout <= 0 {
-		return NewProxyError(ErrTypeConfig, "超时时间必须大于0", 6006, nil)
-	}
-	
-	// 验证重试次数
-	if config.MaxRetries < 0 {
-		return NewProxyError(ErrTypeConfig, "最大重试次数不能为负数", 6007, nil)
-	}
-	
-	// 验证连接池配置
-	if config.MaxIdleConns < 0 {
-		return NewProxyError(ErrTypeConfig, "最大空闲连接数不能为负数", 6008, nil)
-	}
-	
-	return nil
-}
-
-// GetProxyTypeFromString 从字符串获取代理类型
-func GetProxyTypeFromString(typeStr string) ProxyType {
-	switch strings.ToLower(typeStr) {
-	case "none", "direct":
-		return ProxyTypeNone
-	case "http":
-		return ProxyTypeHTTP
-	case "https":
-		return ProxyTypeHTTPS
-	case "socks5":
-		return ProxyTypeSOCKS5
-	default:
-		return ProxyTypeNone
-	}
-}
-
-// BuildProxyURL 构建代理URL
-func BuildProxyURL(config *ProxyConfig) string {
-	if config == nil || config.Type == ProxyTypeNone {
-		return ""
-	}
-	
-	var scheme string
-	switch config.Type {
-	case ProxyTypeHTTP:
-		scheme = "http"
-	case ProxyTypeHTTPS:
-		scheme = "https"
-	case ProxyTypeSOCKS5:
-		scheme = "socks5"
-	default:
-		return ""
-	}
-	
-	url := fmt.Sprintf("%s://", scheme)
-	
-	if config.Username != "" {
-		if config.Password != "" {
-			url += fmt.Sprintf("%s:%s@", config.Username, config.Password)
-		} else {
-			url += fmt.Sprintf("%s@", config.Username)
-		}
-	}
-	
-	url += config.Address
-	
-	return url
-}
-
-// IsProxyEnabled 检查是否启用了代理
-func IsProxyEnabled(config *ProxyConfig) bool {
-	return config != nil && config.Type != ProxyTypeNone && config.Address != ""
-}
-
-// GetDefaultProxyConfigForType 获取指定类型的默认配置
-func GetDefaultProxyConfigForType(proxyType ProxyType, address string) *ProxyConfig {
-	config := DefaultProxyConfig()
-	config.Type = proxyType
-	config.Address = address
-	
-	// 根据类型调整默认配置
-	switch proxyType {
-	case ProxyTypeHTTP, ProxyTypeHTTPS:
-		config.Timeout = 15 * time.Second
-	case ProxyTypeSOCKS5:
-		config.Timeout = 30 * time.Second
-	}
-	
-	return config
-}

Common/proxy/Global.go

@@ -1,9 +1,6 @@
 package proxy
 
 import (
-	"context"
-	"crypto/tls"
-	"net"
 	"sync"
 )
 
@@ -13,137 +10,18 @@ var (
 	once          sync.Once
 )
 
-// InitGlobalProxy 初始化全局代理管理器
+// =============================================================================================
-func InitGlobalProxy(proxyURL string) error {
+// 已删除的死代码（未使用）：
-	globalMutex.Lock()
+// - InitGlobalProxy: 初始化全局代理管理器
-	defer globalMutex.Unlock()
+// - GetGlobalProxy: 获取全局代理管理器
-	
+// - UpdateGlobalProxyConfig: 更新全局代理配置
-	config, err := ParseProxyURL(proxyURL)
+// - CloseGlobalProxy: 关闭全局代理管理器
-	if err != nil {
+// - GetGlobalProxyStats: 获取全局代理统计信息
-		return err
+// - DialWithProxy: 使用全局代理拨号
-	}
+// - DialContextWithProxy: 使用全局代理和上下文拨号
-	
+// - DialTLSWithProxy: 使用全局代理建立TLS连接
-	if err := ValidateProxyConfig(config); err != nil {
+// - DialTLSContextWithProxy: 使用全局代理和上下文建立TLS连接
-		return err
+// - IsProxyEnabledGlobally: 检查全局是否启用了代理
-	}
+// - GetGlobalProxyType: 获取全局代理类型
-	
+// - GetGlobalProxyAddress: 获取全局代理地址
-	// 关闭旧的管理器
+// =============================================================================================
-	if globalManager != nil {
-		globalManager.Close()
-	}
-	
-	globalManager = NewProxyManager(config)
-	return nil
-}
-
-// GetGlobalProxy 获取全局代理管理器
-func GetGlobalProxy() ProxyManager {
-	globalMutex.RLock()
-	defer globalMutex.RUnlock()
-	
-	if globalManager == nil {
-		// 使用默认配置初始化
-		once.Do(func() {
-			globalManager = NewProxyManager(DefaultProxyConfig())
-		})
-	}
-	
-	return globalManager
-}
-
-// UpdateGlobalProxyConfig 更新全局代理配置
-func UpdateGlobalProxyConfig(config *ProxyConfig) error {
-	if err := ValidateProxyConfig(config); err != nil {
-		return err
-	}
-	
-	manager := GetGlobalProxy()
-	return manager.UpdateConfig(config)
-}
-
-// CloseGlobalProxy 关闭全局代理管理器
-func CloseGlobalProxy() error {
-	globalMutex.Lock()
-	defer globalMutex.Unlock()
-	
-	if globalManager != nil {
-		err := globalManager.Close()
-		globalManager = nil
-		return err
-	}
-	
-	return nil
-}
-
-// GetGlobalProxyStats 获取全局代理统计信息
-func GetGlobalProxyStats() *ProxyStats {
-	manager := GetGlobalProxy()
-	return manager.Stats()
-}
-
-// 便捷函数
-
-// DialWithProxy 使用全局代理拨号
-func DialWithProxy(network, address string) (net.Conn, error) {
-	manager := GetGlobalProxy()
-	dialer, err := manager.GetDialer()
-	if err != nil {
-		return nil, err
-	}
-	
-	return dialer.Dial(network, address)
-}
-
-// DialContextWithProxy 使用全局代理和上下文拨号
-func DialContextWithProxy(ctx context.Context, network, address string) (net.Conn, error) {
-	manager := GetGlobalProxy()
-	dialer, err := manager.GetDialer()
-	if err != nil {
-		return nil, err
-	}
-	
-	return dialer.DialContext(ctx, network, address)
-}
-
-// DialTLSWithProxy 使用全局代理建立TLS连接
-func DialTLSWithProxy(network, address string, config *tls.Config) (net.Conn, error) {
-	manager := GetGlobalProxy()
-	dialer, err := manager.GetTLSDialer()
-	if err != nil {
-		return nil, err
-	}
-	
-	return dialer.DialTLS(network, address, config)
-}
-
-// DialTLSContextWithProxy 使用全局代理和上下文建立TLS连接
-func DialTLSContextWithProxy(ctx context.Context, network, address string, config *tls.Config) (net.Conn, error) {
-	manager := GetGlobalProxy()
-	dialer, err := manager.GetTLSDialer()
-	if err != nil {
-		return nil, err
-	}
-	
-	return dialer.DialTLSContext(ctx, network, address, config)
-}
-
-// IsProxyEnabledGlobally 检查全局是否启用了代理
-func IsProxyEnabledGlobally() bool {
-	manager := GetGlobalProxy()
-	stats := manager.Stats()
-	return stats.ProxyType != "none"
-}
-
-// GetGlobalProxyType 获取全局代理类型
-func GetGlobalProxyType() string {
-	manager := GetGlobalProxy()
-	stats := manager.Stats()
-	return stats.ProxyType
-}
-
-// GetGlobalProxyAddress 获取全局代理地址
-func GetGlobalProxyAddress() string {
-	manager := GetGlobalProxy()
-	stats := manager.Stats()
-	return stats.ProxyAddress
-}

Common/proxy/TLSDialer.go

@@ -83,7 +83,6 @@ func (t *tlsDialerWrapper) updateAverageConnectTime(duration time.Duration) {
 type trackedConn struct {
 	net.Conn
 	stats     *ProxyStats
-	startTime time.Time
 	bytesSent int64
 	bytesRecv int64
 }