update

2025-03-15 10:17:07 +00:00
parent 1a53a9a8f3
commit 78f5fbf51a
24 changed files with 2915 additions and 282 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,2 @@
 .idea
 .vscode
--- a/README_UNIFIED.md
+++ b/README_UNIFIED.md
@@ -0,0 +1,250 @@
 # GoProxy 统一代理
 GoProxy统一代理是一个高性能、功能丰富的Go代理实现，支持正向代理、反向代理和透明代理模式。本项目整合了原有的多种代理实现，提供了统一、简洁的接口和更完善的功能。
 ## 特性
 - **多种代理模式**：支持正向代理、反向代理和透明代理模式
 - **HTTP/HTTPS支持**：完整支持HTTP和HTTPS协议
 - **WebSocket支持**：支持WebSocket协议的代理转发
 - **负载均衡**：内置多种负载均衡算法，包括轮询、随机等
 - **健康检查**：支持对后端服务进行健康检查，自动剔除不健康的节点
 - **缓存机制**：支持HTTP响应缓存，提高访问速度
 - **DNS解析**：支持自定义DNS解析和DNS缓存
 - **规则路由**：支持基于规则的请求路由和转发
 - **监控指标**：内置指标收集，方便监控和调优
 - **优雅关闭**：支持优雅启动和关闭，保证请求不丢失
 - **热重载**：支持配置热重载，无需重启服务
 ## 安装
 ```bash
 go get github.com/darkit/goproxy
 ```
 ## 快速开始
 ### 创建正向代理
 ```go
 package main
 import (
    "log"
    "net/http"
    "github.com/darkit/goproxy"
 )
 func main() {
    // 创建正向代理
    proxy, err := goproxy.NewForwardProxy(":8080")
    if err != nil {
        log.Fatalf("创建代理失败: %v", err)
    }
    // 启动HTTP服务器
    log.Println("正向代理启动在 :8080")
    if err := http.ListenAndServe(":8080", proxy); err != nil {
        log.Fatalf("服务器启动失败: %v", err)
    }
 }
 ```
 ### 创建反向代理
 ```go
 package main
 import (
    "log"
    "net/http"
    "github.com/darkit/goproxy"
 )
 func main() {
    // 创建反向代理
    proxy, err := goproxy.NewReverseProxy(":8080", "http://example.com")
    if err != nil {
        log.Fatalf("创建代理失败: %v", err)
    }
    // 启动HTTP服务器
    log.Println("反向代理启动在 :8080，转发到 http://example.com")
    if err := http.ListenAndServe(":8080", proxy); err != nil {
        log.Fatalf("服务器启动失败: %v", err)
    }
 }
 ```
 ### 创建带负载均衡的反向代理
 ```go
 package main
 import (
    "log"
    "net/http"
    "time"
    "github.com/darkit/goproxy"
    "github.com/darkit/goproxy/config"
    "github.com/darkit/goproxy/pkg/loadbalance"
 )
 func main() {
    // 创建负载均衡器
    lb := loadbalance.NewRoundRobinBalancer()
    lb.Add("http://backend1:8080", 1)
    lb.Add("http://backend2:8080", 1)
    lb.Add("http://backend3:8080", 1)
    // 创建统一配置
    cfg := config.DefaultUnifiedConfig()
    cfg.ListenAddr = ":8080"
    cfg.ProxyMode = config.ModeReverse
    cfg.EnableLoadBalancing = true
    // 创建代理
    proxy, err := goproxy.CreateUnifiedProxy(
        goproxy.WithUnifiedConfig(cfg),
        goproxy.WithUnifiedLoadBalancer(lb),
    )
    if err != nil {
        log.Fatalf("创建代理失败: %v", err)
    }
    // 启动HTTP服务器
    log.Println("负载均衡反向代理启动在 :8080")
    if err := http.ListenAndServe(":8080", proxy); err != nil {
        log.Fatalf("服务器启动失败: %v", err)
    }
 }
 ```
 ## 命令行工具
 GoProxy 提供了一个功能齐全的命令行工具，支持各种代理模式和配置选项。
 ```bash
 # 启动正向代理
 go run cmd/unified_proxy/main.go -mode forward -listen :8080
 # 启动反向代理
 go run cmd/unified_proxy/main.go -mode reverse -listen :8080 -target http://example.com
 # 启动带负载均衡的反向代理
 go run cmd/unified_proxy/main.go -mode reverse -listen :8080 -backends "http://backend1:8080,http://backend2:8080" -health-check -lb-strategy round-robin
 # 启动带HTTPS的反向代理
 go run cmd/unified_proxy/main.go -mode reverse -listen :443 -target http://example.com -https -cert server.crt -key server.key
 # 启动带缓存的代理
 go run cmd/unified_proxy/main.go -mode forward -listen :8080 -cache -cache-ttl 5m
 ```
 ## 配置选项
 ### 通用选项
 - `-mode`：代理模式 (forward, reverse, transparent)
 - `-listen`：监听地址
 - `-https`：启用HTTPS
 - `-cert`：TLS证书文件
 - `-key`：TLS密钥文件
 - `-cache`：启用响应缓存
 - `-cache-ttl`：缓存过期时间
 - `-insecure`：跳过SSL验证
 - `-verbose`：输出详细日志
 ### 反向代理选项
 - `-target`：目标服务地址
 - `-rules`：规则文件路径
 ### 负载均衡选项
 - `-backends`：后端服务器列表，用逗号分隔
 - `-lb-strategy`：负载均衡策略 (round-robin, random, weighted)
 - `-health-check`：启用健康检查
 - `-health-interval`：健康检查间隔时间
 ## 高级用法
 ### 自定义委托
 通过实现`Delegate`接口，可以在代理处理请求的各个阶段进行干预：
 ```go
 type CustomDelegate struct {
    goproxy.DefaultDelegate
 }
 func (d *CustomDelegate) BeforeRequest(ctx *goproxy.Context) {
    // 在请求发送前修改请求
    ctx.Req.Header.Set("X-Custom-Header", "value")
 }
 func (d *CustomDelegate) BeforeResponse(ctx *goproxy.Context, resp *http.Response, err error) {
    // 在返回响应前修改响应
    if resp != nil {
        resp.Header.Set("X-Response-Time", time.Now().String())
    }
 }
 // 使用自定义委托
 proxy, err := goproxy.CreateUnifiedProxy(
    goproxy.WithUnifiedDelegate(&CustomDelegate{}),
 )
 ```
 ### 带规则的反向代理
 可以使用JSON规则文件定义复杂的路由规则：
 ```json
 {
  "rules": [
    {
      "path": "/api/",
      "target": "http://api-server:8000",
      "strip_prefix": true
    },
    {
      "host": "admin.example.com",
      "target": "http://admin-server:9000"
    },
    {
      "default": true,
      "target": "http://default-server:8080"
    }
  ]
 }
 ```
 ## 性能优化
 - **连接池**：启用连接池可以减少连接建立的开销
 - **DNS缓存**：启用DNS缓存可以减少DNS解析的时间
 - **响应缓存**：对于频繁访问的静态资源，启用响应缓存可以大幅提高性能
 - **压缩**：启用压缩可以减少传输数据量，但会增加CPU开销
 ## 监控与指标
 GoProxy内置了指标收集功能，可以方便地监控代理的运行状态：
 - 请求计数
 - 错误计数
 - 响应时间
 - 缓存命中率
 - 连接数
 - 并发数
 ## 贡献
 欢迎贡献代码、报告问题或提出改进建议。请先阅读CONTRIBUTING.md了解贡献流程。
 ## 许可证
 本项目采用MIT许可证，详见LICENSE文件。 
--- a/cmd/cmd_reverse_proxy/cmd_reverse_proxy.go
+++ b/cmd/cmd_reverse_proxy/cmd_reverse_proxy.go
--- a/cmd/functional_options_proxy/functional_options_proxy.go
+++ b/cmd/functional_options_proxy/functional_options_proxy.go
@@ -14,8 +14,7 @@ import (
 	"github.com/darkit/goproxy/pkg/metrics"
 )
-// 这是functional_options_proxy的main函数，改名避免与其他文件冲突
+func main() {
 func main_functional_options() {
 	// 创建基本配置
 	cfg := config.DefaultConfig()
@@ -93,8 +92,3 @@ func main_functional_options() {
 		log.Fatalf("服务器启动失败: %v", err)
 	}
 }
 // 添加实际的main函数，调用上面的示例函数
 func main() {
 	main_functional_options()
 }
--- a/cmd/https_reverse_proxy/https_reverse_proxy.go
+++ b/cmd/https_reverse_proxy/https_reverse_proxy.go
--- a/cmd/middleware_reverse_proxy/middleware_reverse_proxy.go
+++ b/cmd/middleware_reverse_proxy/middleware_reverse_proxy.go
--- a/cmd/reverse_proxy_example/reverse_proxy_example.go
+++ b/cmd/reverse_proxy_example/reverse_proxy_example.go
--- a/cmd/rules_reverse_proxy/proxy_rules.json
+++ b/cmd/rules_reverse_proxy/proxy_rules.json
--- a/cmd/rules_reverse_proxy/rules_reverse_proxy.go
+++ b/cmd/rules_reverse_proxy/rules_reverse_proxy.go
@@ -42,7 +42,7 @@ func main() {
 	cfg.PreserveClientIP = true            // 保留客户端IP
 	cfg.AddXForwardedFor = true            // 添加X-Forwarded-For头
 	cfg.AddXRealIP = true                  // 添加X-Real-IP头
-	cfg.TargetAddr = "www.chipeak.com"
+	cfg.TargetAddr = "https://git.zishuo.net"
 	// 创建代理实例
 	proxy := goproxy.New(&goproxy.Options{
@@ -114,7 +114,7 @@ func createExampleRulesFile(filename string) {
  ]
 }`
-	err := os.WriteFile(filename, []byte(content), 0644)
+	err := os.WriteFile(filename, []byte(content), 0o644)
 	if err != nil {
 		log.Fatalf("创建规则文件失败: %v", err)
 	}
--- a/cmd/simple_reverse_proxy.go
+++ b/cmd/simple_reverse_proxy.go
@@ -1,35 +0,0 @@
 package main
 import (
 	"fmt"
 	"log"
 	"net/http"
 	"github.com/darkit/goproxy"
 	"github.com/darkit/goproxy/config"
 )
 func main() {
 	// 创建基本配置
 	cfg := config.DefaultConfig()
 	// 配置反向代理
 	cfg.ReverseProxy = true               // 启用反向代理模式
 	cfg.ListenAddr = ":8080"              // 监听本地8080端口
 	cfg.TargetAddr = "http://example.com" // 转发到example.com
 	// 启用一些基本功能
 	cfg.PreserveClientIP = true // 保留客户端IP
 	cfg.AddXForwardedFor = true // 添加X-Forwarded-For头
 	// 创建代理实例
 	proxy := goproxy.New(&goproxy.Options{
 		Config: cfg,
 	})
 	// 启动服务器
 	fmt.Println("反向代理启动在 :8080，转发到 http://example.com")
 	if err := http.ListenAndServe(":8080", proxy); err != nil {
 		log.Fatalf("服务器启动失败: %v", err)
 	}
 }
--- a/cmd/simple_reverse_proxy/simple_reverse_proxy.go
+++ b/cmd/simple_reverse_proxy/simple_reverse_proxy.go
--- a/cmd/unified_proxy/main.go
+++ b/cmd/unified_proxy/main.go
@@ -0,0 +1,258 @@
 package main
 import (
 	"context"
 	"errors"
 	"flag"
 	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
 	"strings"
 	"syscall"
 	"time"
 	"github.com/darkit/goproxy"
 	"github.com/darkit/goproxy/config"
 	"github.com/darkit/goproxy/pkg/cache"
 	"github.com/darkit/goproxy/pkg/dns"
 	"github.com/darkit/goproxy/pkg/healthcheck"
 	"github.com/darkit/goproxy/pkg/loadbalance"
 	"github.com/darkit/goproxy/pkg/metrics"
 )
 func main() {
 	// 通用选项
 	proxyMode := flag.String("mode", "forward", "代理模式 [forward, reverse, transparent]")
 	listenAddr := flag.String("listen", ":8080", "监听地址")
 	targetAddr := flag.String("target", "http://192.168.1.240", "目标地址 (只在反向代理模式下使用)")
 	enableHTTPS := flag.Bool("https", false, "是否启用HTTPS")
 	certFile := flag.String("cert", "", "证书文件路径")
 	keyFile := flag.String("key", "", "密钥文件路径")
 	enableCache := flag.Bool("cache", false, "是否启用响应缓存")
 	cacheTTL := flag.Duration("cache-ttl", 5*time.Minute, "缓存过期时间")
 	insecure := flag.Bool("insecure", false, "是否跳过证书验证")
 	// 反向代理选项
 	rulesFile := flag.String("rules", "", "规则文件路径 (只在反向代理模式下使用)")
 	// 负载均衡选项
 	backends := flag.String("backends", "", "后端服务器列表，用逗号分隔")
 	lbStrategy := flag.String("lb-strategy", "round-robin", "负载均衡策略 [round-robin, random, weighted]")
 	healthCheck := flag.Bool("health-check", false, "是否启用健康检查")
 	healthInterval := flag.Duration("health-interval", 10*time.Second, "健康检查间隔时间")
 	// 其他选项
 	verbose := flag.Bool("verbose", false, "是否输出详细日志")
 	// 解析命令行参数
 	flag.Parse()
 	// 设置日志级别
 	var logLevel slog.Level
 	if *verbose {
 		logLevel = slog.LevelDebug
 	} else {
 		logLevel = slog.LevelInfo
 	}
 	logLevelVar := &logLevel
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 		Level: logLevelVar,
 	}))
 	slog.SetDefault(logger)
 	// 创建统一配置
 	cfg := config.DefaultUnifiedConfig()
 	cfg.ListenAddr = *listenAddr
 	cfg.Logger = logger
 	// 设置代理模式
 	switch strings.ToLower(*proxyMode) {
 	case "forward", "proxy":
 		cfg.ProxyMode = config.ModeForward
 	case "reverse":
 		cfg.ProxyMode = config.ModeReverse
 		if *targetAddr != "" {
 			cfg.TargetAddr = *targetAddr
 		}
 		if *rulesFile != "" {
 			cfg.RulesFile = *rulesFile
 		}
 	case "transparent":
 		cfg.ProxyMode = config.ModeTransparent
 	default:
 		logger.Error("不支持的代理模式", "mode", *proxyMode)
 		os.Exit(1)
 	}
 	// HTTPS设置
 	cfg.EnableHTTPS = *enableHTTPS
 	if *enableHTTPS {
 		if *certFile == "" || *keyFile == "" {
 			logger.Error("启用HTTPS需要提供证书和密钥文件")
 			os.Exit(1)
 		}
 		cfg.TLSCert = *certFile
 		cfg.TLSKey = *keyFile
 	}
 	// 缓存设置
 	cfg.EnableCache = *enableCache
 	cfg.CacheTTL = *cacheTTL
 	// SSL验证设置
 	cfg.InsecureSkipVerify = *insecure
 	// 添加X-Forwarded-For头
 	cfg.AddXForwardedFor = true
 	// 添加X-Real-IP头
 	cfg.AddXRealIP = true
 	// 负载均衡设置
 	if *backends != "" {
 		backendList := strings.Split(*backends, ",")
 		cfg.EnableLoadBalancing = true
 		cfg.Backends = backendList
 		// 健康检查设置
 		if *healthCheck {
 			cfg.EnableHealthCheck = true
 			cfg.HealthCheckInterval = *healthInterval
 			cfg.HealthCheckTimeout = 5 * time.Second
 		}
 	}
 	// 创建统一代理选项
 	opts := &goproxy.UnifiedOptions{
 		Config: cfg,
 	}
 	// 根据需要添加额外组件
 	// 添加缓存
 	if *enableCache {
 		opts.HTTPCache = cache.NewMemoryCache(*cacheTTL, time.Minute, 10000)
 	}
 	// 添加负载均衡器
 	if cfg.EnableLoadBalancing {
 		var lb loadbalance.LoadBalancer
 		switch strings.ToLower(*lbStrategy) {
 		case "round-robin":
 			lb = loadbalance.NewRoundRobinBalancer()
 		case "random":
 			lb = loadbalance.NewRandomBalancer()
 		case "weighted":
 			lb = loadbalance.NewRoundRobinBalancer() // 实际上是加权轮询，但简化处理
 		default:
 			logger.Warn("不支持的负载均衡策略，使用默认的轮询策略", "strategy", *lbStrategy)
 			lb = loadbalance.NewRoundRobinBalancer()
 		}
 		// 添加后端服务器
 		for _, backend := range cfg.Backends {
 			lb.Add(backend, 1)
 		}
 		opts.LoadBalancer = lb
 		// 添加健康检查器
 		if cfg.EnableHealthCheck {
 			healthCfg := &healthcheck.Config{
 				Interval:   cfg.HealthCheckInterval,
 				Timeout:    cfg.HealthCheckTimeout,
 				MaxFails:   3,
 				MinSuccess: 1,
 			}
 			healthChecker := healthcheck.NewHealthChecker(healthCfg)
 			for _, backend := range cfg.Backends {
 				healthChecker.AddTarget(backend)
 			}
 			opts.HealthChecker = healthChecker
 			// 启动健康检查
 			healthChecker.Start()
 			defer healthChecker.Stop()
 		}
 	}
 	// 添加DNS解析器
 	if cfg.ProxyMode == config.ModeReverse {
 		resolver := dns.NewResolver(
 			dns.WithFallback(true),     // 如果找不到自定义规则，回退到系统DNS
 			dns.WithTTL(5*time.Minute), // 设置缓存TTL
 		)
 		// 将解析器添加到选项中
 		opts.DNSResolver = resolver
 		logger.Info("已创建自定义DNS解析器", "fallback", true, "ttl", "5m")
 	}
 	// 添加监控指标
 	opts.Metrics = metrics.NewSimpleMetrics()
 	// 创建统一代理
 	proxy, err := goproxy.NewUnifiedProxy(opts)
 	if err != nil {
 		logger.Error("创建代理失败", "error", err)
 		os.Exit(1)
 	}
 	// 打印启动信息
 	logger.Info("代理服务器启动", "mode", cfg.ProxyMode, "listen", cfg.ListenAddr, "https", cfg.EnableHTTPS)
 	if cfg.ProxyMode == config.ModeReverse {
 		logger.Info("反向代理设置", "target", cfg.TargetAddr, "rules", cfg.RulesFile)
 	}
 	if cfg.EnableLoadBalancing {
 		logger.Info("负载均衡设置", "strategy", *lbStrategy, "backends", cfg.Backends, "health_check", cfg.EnableHealthCheck)
 	}
 	// 创建HTTP服务器
 	server := &http.Server{
 		Addr:    cfg.ListenAddr,
 		Handler: proxy,
 	}
 	// 启动HTTP服务器
 	go func() {
 		var err error
 		if cfg.EnableHTTPS {
 			err = server.ListenAndServeTLS(cfg.TLSCert, cfg.TLSKey)
 		} else {
 			err = server.ListenAndServe()
 		}
 		if err != nil && !errors.Is(err, http.ErrServerClosed) {
 			logger.Error("服务器运行失败", "error", err)
 			os.Exit(1)
 		}
 	}()
 	// 等待中断信号
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 	<-quit
 	logger.Info("正在关闭服务器...")
 	// 优雅关闭
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	if err := server.Shutdown(ctx); err != nil {
 		logger.Error("服务器关闭失败", "error", err)
 	}
 	// 关闭代理
 	if err := proxy.Close(); err != nil {
 		logger.Error("代理关闭失败", "error", err)
 	}
 	logger.Info("服务器已关闭")
 }
--- a/config/unified_config.go
+++ b/config/unified_config.go
@@ -0,0 +1,254 @@
 package config
 import (
 	"log/slog"
 	"time"
 	"github.com/darkit/goproxy/pkg/reverse"
 )
 // ProxyMode 代理模式
 type ProxyMode string
 const (
 	// ModeForward 正向代理模式
 	ModeForward ProxyMode = "forward"
 	// ModeReverse 反向代理模式
 	ModeReverse ProxyMode = "reverse"
 	// ModeTransparent 透明代理模式
 	ModeTransparent ProxyMode = "transparent"
 )
 // UnifiedConfig 统一代理配置
 type UnifiedConfig struct {
 	// 基本配置
 	ListenAddr         string    `json:"listen_addr" yaml:"listen_addr" toml:"listen_addr"`                            // 监听地址
 	ProxyMode          ProxyMode `json:"proxy_mode" yaml:"proxy_mode" toml:"proxy_mode"`                               // 代理模式：forward, reverse, transparent
 	TargetAddr         string    `json:"target_addr" yaml:"target_addr" toml:"target_addr"`                            // 目标地址(反向代理使用)
 	EnableHTTPS        bool      `json:"enable_https" yaml:"enable_https" toml:"enable_https"`                         // 是否启用HTTPS
 	DecryptHTTPS       bool      `json:"decrypt_https" yaml:"decrypt_https" toml:"decrypt_https"`                      // 是否解密HTTPS(正向代理使用)
 	TLSCert            string    `json:"tls_cert" yaml:"tls_cert" toml:"tls_cert"`                                     // TLS证书文件路径
 	TLSKey             string    `json:"tls_key" yaml:"tls_key" toml:"tls_key"`                                        // TLS密钥文件路径
 	CACert             string    `json:"ca_cert" yaml:"ca_cert" toml:"ca_cert"`                                        // CA证书文件路径(用于生成动态证书)
 	CAKey              string    `json:"ca_key" yaml:"ca_key" toml:"ca_key"`                                           // CA密钥文件路径(用于生成动态证书)
 	UseECDSA           bool      `json:"use_ecdsa" yaml:"use_ecdsa" toml:"use_ecdsa"`                                  // 是否使用ECDSA生成证书（默认使用RSA）
 	InsecureSkipVerify bool      `json:"insecure_skip_verify" yaml:"insecure_skip_verify" toml:"insecure_skip_verify"` // 是否跳过TLS证书验证
 	// 连接配置
 	DisableKeepAlive        bool          `json:"disable_keep_alive" yaml:"disable_keep_alive" toml:"disable_keep_alive"`                      // 是否禁用连接复用
 	RequestTimeout          time.Duration `json:"request_timeout" yaml:"request_timeout" toml:"request_timeout"`                               // 请求超时时间
 	IdleTimeout             time.Duration `json:"idle_timeout" yaml:"idle_timeout" toml:"idle_timeout"`                                        // 连接空闲超时时间
 	MaxIdleConns            int           `json:"max_idle_conns" yaml:"max_idle_conns" toml:"max_idle_conns"`                                  // 最大空闲连接数
 	EnableConnectionPool    bool          `json:"enable_connection_pool" yaml:"enable_connection_pool" toml:"enable_connection_pool"`          // 是否启用连接池
 	ConnectionPoolSize      int           `json:"connection_pool_size" yaml:"connection_pool_size" toml:"connection_pool_size"`                // 连接池大小
 	MaxConnections          int           `json:"max_connections" yaml:"max_connections" toml:"max_connections"`                               // 最大连接数
 	EnableWebSocket         bool          `json:"enable_websocket" yaml:"enable_websocket" toml:"enable_websocket"`                            // 是否启用WebSocket
 	WebSocketIntercept      bool          `json:"websocket_intercept" yaml:"websocket_intercept" toml:"websocket_intercept"`                   // 是否拦截WebSocket
 	SupportWebSocketUpgrade bool          `json:"support_websocket_upgrade" yaml:"support_websocket_upgrade" toml:"support_websocket_upgrade"` // 是否支持Websocket升级
 	// 缓存配置
 	EnableCache bool          `json:"enable_cache" yaml:"enable_cache" toml:"enable_cache"`    // 是否启用响应缓存
 	CacheTTL    time.Duration `json:"cache_ttl" yaml:"cache_ttl" toml:"cache_ttl"`             // 缓存过期时间
 	DNSCacheTTL time.Duration `json:"dns_cache_ttl" yaml:"dns_cache_ttl" toml:"dns_cache_ttl"` // DNS缓存过期时间
 	// 重试配置
 	EnableRetry     bool          `json:"enable_retry" yaml:"enable_retry" toml:"enable_retry"`                // 是否启用重试机制
 	MaxRetries      int           `json:"max_retries" yaml:"max_retries" toml:"max_retries"`                   // 最大重试次数
 	RetryBackoff    time.Duration `json:"retry_backoff" yaml:"retry_backoff" toml:"retry_backoff"`             // 重试间隔基数
 	MaxRetryBackoff time.Duration `json:"max_retry_backoff" yaml:"max_retry_backoff" toml:"max_retry_backoff"` // 最大重试间隔
 	// HTTP头部操作
 	EnableCompression bool `json:"enable_compression" yaml:"enable_compression" toml:"enable_compression"`    // 是否启用压缩
 	EnableCORS        bool `json:"enable_cors" yaml:"enable_cors" toml:"enable_cors"`                         // 是否启用CORS
 	PreserveClientIP  bool `json:"preserve_client_ip" yaml:"preserve_client_ip" toml:"preserve_client_ip"`    // 是否保留客户端IP
 	RewriteHostHeader bool `json:"rewrite_host_header" yaml:"rewrite_host_header" toml:"rewrite_host_header"` // 重写Host头
 	AddXForwardedFor  bool `json:"add_x_forwarded_for" yaml:"add_x_forwarded_for" toml:"add_x_forwarded_for"` // 是否添加X-Forwarded-For头
 	AddXRealIP        bool `json:"add_x_real_ip" yaml:"add_x_real_ip" toml:"add_x_real_ip"`                   // 是否添加X-Real-IP头
 	// 负载均衡配置
 	EnableLoadBalancing bool          `json:"enable_load_balancing" yaml:"enable_load_balancing" toml:"enable_load_balancing"` // 是否启用负载均衡
 	Backends            []string      `json:"backends" yaml:"backends" toml:"backends"`                                        // 负载均衡后端列表
 	EnableHealthCheck   bool          `json:"enable_health_check" yaml:"enable_health_check" toml:"enable_health_check"`       // 是否启用健康检查
 	HealthCheckInterval time.Duration `json:"health_check_interval" yaml:"health_check_interval" toml:"health_check_interval"` // 健康检查间隔时间
 	HealthCheckTimeout  time.Duration `json:"health_check_timeout" yaml:"health_check_timeout" toml:"health_check_timeout"`    // 健康检查超时时间
 	// 限流配置
 	EnableRateLimit bool    `json:"enable_rate_limit" yaml:"enable_rate_limit" toml:"enable_rate_limit"` // 是否启用限流
 	RateLimit       float64 `json:"rate_limit" yaml:"rate_limit" toml:"rate_limit"`                      // 每秒请求速率限制
 	MaxBurst        int     `json:"max_burst" yaml:"max_burst" toml:"max_burst"`                         // 并发请求峰值限制
 	// 监控和跟踪
 	EnableMetrics bool `json:"enable_metrics" yaml:"enable_metrics" toml:"enable_metrics"` // 是否启用监控指标
 	EnableTracing bool `json:"enable_tracing" yaml:"enable_tracing" toml:"enable_tracing"` // 是否启用请求追踪
 	// 反向代理特有配置
 	RulesFile string `json:"rules_file" yaml:"rules_file" toml:"rules_file"` // 规则文件路径
 	// 日志
 	Logger *slog.Logger `json:"-" yaml:"-" toml:"-"` // 日志记录器
 }
 // DefaultUnifiedConfig 返回默认统一配置
 func DefaultUnifiedConfig() *UnifiedConfig {
 	return &UnifiedConfig{
 		ListenAddr:         ":8080",
 		ProxyMode:          ModeForward, // 默认为正向代理
 		DecryptHTTPS:       false,
 		EnableHTTPS:        false,
 		UseECDSA:           false,
 		InsecureSkipVerify: false,
 		RequestTimeout:          30 * time.Second,
 		IdleTimeout:             90 * time.Second,
 		MaxIdleConns:            100,
 		EnableConnectionPool:    true,
 		ConnectionPoolSize:      100,
 		MaxConnections:          1000,
 		EnableWebSocket:         true,
 		WebSocketIntercept:      false,
 		SupportWebSocketUpgrade: true,
 		EnableCache: false,
 		CacheTTL:    5 * time.Minute,
 		DNSCacheTTL: 5 * time.Minute,
 		EnableRetry:     true,
 		MaxRetries:      3,
 		RetryBackoff:    time.Second,
 		MaxRetryBackoff: 10 * time.Second,
 		EnableCompression: true,
 		EnableCORS:        true,
 		PreserveClientIP:  true,
 		RewriteHostHeader: false,
 		AddXForwardedFor:  true,
 		AddXRealIP:        true,
 		EnableLoadBalancing: false,
 		Backends:            []string{},
 		EnableHealthCheck:   false,
 		HealthCheckInterval: 30 * time.Second,
 		HealthCheckTimeout:  5 * time.Second,
 		EnableRateLimit: false,
 		RateLimit:       0, // 0 表示不限流
 		MaxBurst:        50,
 		EnableMetrics: false,
 		EnableTracing: false,
 		Logger: slog.Default(),
 	}
 }
 // CreateLegacyConfig 将统一配置转换为旧的配置格式（兼容性用）
 func (uc *UnifiedConfig) CreateLegacyConfig() *Config {
 	cfg := DefaultConfig()
 	// 基本配置
 	cfg.ListenAddr = uc.ListenAddr
 	cfg.TargetAddr = uc.TargetAddr
 	cfg.DecryptHTTPS = uc.DecryptHTTPS
 	cfg.CACert = uc.CACert
 	cfg.CAKey = uc.CAKey
 	cfg.UseECDSA = uc.UseECDSA
 	cfg.TLSCert = uc.TLSCert
 	cfg.TLSKey = uc.TLSKey
 	cfg.InsecureSkipVerify = uc.InsecureSkipVerify
 	// 连接配置
 	cfg.DisableKeepAlive = uc.DisableKeepAlive
 	cfg.RequestTimeout = uc.RequestTimeout
 	cfg.EnableCache = uc.EnableCache
 	cfg.IdleTimeout = uc.IdleTimeout
 	cfg.MaxIdleConns = uc.MaxIdleConns
 	// 缓存配置
 	cfg.DNSCacheTTL = uc.DNSCacheTTL
 	cfg.CacheTTL = uc.CacheTTL
 	// 重试配置
 	cfg.EnableRetry = uc.EnableRetry
 	cfg.MaxRetries = uc.MaxRetries
 	cfg.BaseBackoff = uc.RetryBackoff
 	cfg.MaxBackoff = uc.MaxRetryBackoff
 	// 限流配置
 	cfg.RateLimit = uc.RateLimit
 	// 其他配置
 	cfg.EnableCORS = uc.EnableCORS
 	// 负载均衡配置
 	cfg.EnableLoadBalancing = uc.EnableLoadBalancing
 	cfg.Backends = uc.Backends
 	cfg.EnableRateLimit = uc.EnableRateLimit
 	cfg.MaxBurst = uc.MaxBurst
 	cfg.MaxConnections = uc.MaxConnections
 	cfg.EnableConnectionPool = uc.EnableConnectionPool
 	cfg.ConnectionPoolSize = uc.ConnectionPoolSize
 	cfg.EnableHealthCheck = uc.EnableHealthCheck
 	cfg.HealthCheckInterval = uc.HealthCheckInterval
 	cfg.HealthCheckTimeout = uc.HealthCheckTimeout
 	cfg.EnableMetrics = uc.EnableMetrics
 	cfg.EnableTracing = uc.EnableTracing
 	cfg.WebSocketIntercept = uc.WebSocketIntercept
 	cfg.ReverseProxy = uc.ProxyMode == ModeReverse
 	cfg.ReverseProxyRulesFile = uc.RulesFile
 	cfg.PreserveClientIP = uc.PreserveClientIP
 	cfg.EnableCompression = uc.EnableCompression
 	cfg.RewriteHostHeader = uc.RewriteHostHeader
 	cfg.AddXForwardedFor = uc.AddXForwardedFor
 	cfg.AddXRealIP = uc.AddXRealIP
 	cfg.SupportWebSocketUpgrade = uc.SupportWebSocketUpgrade
 	cfg.Logger = uc.Logger
 	return cfg
 }
 // CreateReverseConfig 将统一配置转换为反向代理配置
 func (uc *UnifiedConfig) CreateReverseConfig() *reverse.Config {
 	cfg := reverse.DefaultConfig()
 	// 基础配置
 	cfg.BaseConfig.ListenAddr = uc.ListenAddr
 	cfg.BaseConfig.TargetAddr = uc.TargetAddr
 	cfg.BaseConfig.EnableHTTPS = uc.EnableHTTPS
 	if uc.TLSCert != "" && uc.TLSKey != "" {
 		cfg.BaseConfig.TLSConfig = &reverse.TLSConfig{
 			CertFile:           uc.TLSCert,
 			KeyFile:            uc.TLSKey,
 			InsecureSkipVerify: uc.InsecureSkipVerify,
 			UseECDSA:           uc.UseECDSA,
 		}
 	}
 	cfg.BaseConfig.EnableWebSocket = uc.EnableWebSocket
 	cfg.BaseConfig.EnableCompression = uc.EnableCompression
 	cfg.BaseConfig.EnableCORS = uc.EnableCORS
 	cfg.BaseConfig.PreserveClientIP = uc.PreserveClientIP
 	cfg.BaseConfig.AddXForwardedFor = uc.AddXForwardedFor
 	cfg.BaseConfig.AddXRealIP = uc.AddXRealIP
 	// 其他配置
 	cfg.RulesFile = uc.RulesFile
 	cfg.InsecureSkipVerify = uc.InsecureSkipVerify
 	cfg.EnableHealthCheck = uc.EnableHealthCheck
 	cfg.HealthCheckInterval = uc.HealthCheckInterval
 	cfg.HealthCheckTimeout = uc.HealthCheckTimeout
 	cfg.EnableRetry = uc.EnableRetry
 	cfg.MaxRetries = uc.MaxRetries
 	cfg.RetryBackoff = uc.RetryBackoff
 	cfg.MaxRetryBackoff = uc.MaxRetryBackoff
 	cfg.EnableMetrics = uc.EnableMetrics
 	cfg.EnableTracing = uc.EnableTracing
 	cfg.WebSocketIntercept = uc.WebSocketIntercept
 	cfg.DNSCacheTTL = uc.DNSCacheTTL
 	cfg.EnableCache = uc.EnableCache
 	cfg.CacheTTL = uc.CacheTTL
 	cfg.EnableConnectionPool = uc.EnableConnectionPool
 	cfg.ConnectionPoolSize = uc.ConnectionPoolSize
 	cfg.IdleTimeout = uc.IdleTimeout
 	cfg.RequestTimeout = uc.RequestTimeout
 	return cfg
 }
--- a/coverage.out
+++ b/coverage.out
@@ -1,225 +0,0 @@
 mode: set
 github.com/darkit/goproxy/pkg/dns/config.go:24.55,26.16 2 1
 github.com/darkit/goproxy/pkg/dns/config.go:26.16,28.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:29.2,33.42 4 1
 github.com/darkit/goproxy/pkg/dns/config.go:33.42,35.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:37.2,37.12 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:41.56,43.16 2 1
 github.com/darkit/goproxy/pkg/dns/config.go:43.16,45.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:46.2,55.47 4 1
 github.com/darkit/goproxy/pkg/dns/config.go:55.47,57.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:59.2,59.20 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:63.61,65.16 2 1
 github.com/darkit/goproxy/pkg/dns/config.go:65.16,67.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:68.2,78.21 5 1
 github.com/darkit/goproxy/pkg/dns/config.go:78.21,83.49 3 1
 github.com/darkit/goproxy/pkg/dns/config.go:83.49,84.12 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:87.3,88.22 2 1
 github.com/darkit/goproxy/pkg/dns/config.go:88.22,89.12 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:92.3,97.21 4 1
 github.com/darkit/goproxy/pkg/dns/config.go:97.21,98.12 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:101.3,106.20 4 1
 github.com/darkit/goproxy/pkg/dns/config.go:106.20,108.4 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:110.3,110.34 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:110.34,112.38 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:112.38,113.10 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:117.4,117.34 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:121.2,121.38 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:121.38,123.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:125.2,125.20 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:129.63,131.20 2 1
 github.com/darkit/goproxy/pkg/dns/config.go:131.20,133.3 1 1
 github.com/darkit/goproxy/pkg/dns/config.go:133.8,135.3 1 0
 github.com/darkit/goproxy/pkg/dns/config.go:137.2,145.17 3 1
 github.com/darkit/goproxy/pkg/dns/config.go:149.43,151.2 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:19.43,26.2 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:29.61,32.2 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:35.65,38.2 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:41.55,44.2 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:47.94,50.16 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:50.16,54.3 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:57.2,58.16 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:58.16,60.3 1 0
 github.com/darkit/goproxy/pkg/dns/dialer.go:63.2,63.17 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:63.17,65.17 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:65.17,67.4 1 0
 github.com/darkit/goproxy/pkg/dns/dialer.go:70.3,70.24 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:70.24,72.4 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:74.3,74.21 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:78.2,84.71 2 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:88.66,90.2 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:93.26,95.2 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:98.98,100.2 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:103.52,105.2 1 1
 github.com/darkit/goproxy/pkg/dns/dialer.go:108.111,110.2 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:16.39,21.2 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:24.57,29.2 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:32.49,34.30 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:34.30,36.22 2 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:36.22,38.4 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:41.3,45.17 3 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:45.17,47.4 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:49.3,49.44 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:53.2,53.28 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:57.36,58.16 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:58.16,60.3 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:61.2,61.13 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:65.70,66.16 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:66.16,68.3 1 1
 github.com/darkit/goproxy/pkg/dns/endpoint.go:69.2,69.48 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:73.53,84.33 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:84.33,86.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:88.2,88.10 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:92.63,94.16 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:94.16,96.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:97.2,97.25 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:101.91,106.64 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:106.64,109.3 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:112.2,112.60 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:112.60,115.3 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:118.2,118.36 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:118.36,119.41 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:119.41,122.4 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:124.2,127.16 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:127.16,129.17 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:129.17,131.4 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:134.3,135.28 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:135.28,136.39 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:136.39,138.10 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:142.3,142.15 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:142.15,144.4 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:147.3,148.22 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:148.22,150.4 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:153.3,160.23 4 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:163.2,163.76 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:167.91,168.25 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:168.25,170.3 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:173.2,173.25 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:173.25,175.22 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:175.22,177.4 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:178.3,178.18 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:182.2,183.22 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:184.18,186.68 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:187.14,189.68 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:190.22,192.26 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:195.2,195.40 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:195.40,197.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:198.2,198.17 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:202.65,206.39 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:206.39,207.48 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:207.48,209.4 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:212.2,212.12 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:216.64,218.41 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:218.41,220.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:223.2,223.38 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:223.38,225.29 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:225.29,226.12 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:230.3,230.38 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:230.38,232.4 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:235.2,235.13 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:239.53,241.2 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:244.71,245.28 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:245.28,247.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:249.2,253.50 4 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:253.50,255.31 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:255.31,256.54 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:256.54,258.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:260.3,260.54 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:261.8,263.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:264.2,264.12 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:268.71,270.2 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:273.89,274.28 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:274.28,276.3 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:279.2,279.44 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:279.44,281.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:284.2,290.39 4 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:290.39,291.37 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:291.37,294.37 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:294.37,295.55 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:295.55,297.6 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:300.4,301.14 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:306.2,315.12 3 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:319.52,324.34 3 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:324.34,327.3 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:330.2,330.39 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:330.39,331.27 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:331.27,335.4 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:338.2,338.44 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:342.74,347.42 3 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:347.42,349.31 2 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:349.31,350.36 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:350.36,352.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:354.3,354.29 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:354.29,356.4 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:356.9,358.4 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:359.3,359.13 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:363.2,363.39 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:363.39,364.27 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:364.27,366.37 2 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:366.37,367.37 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:367.37,369.6 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:371.4,371.30 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:371.30,373.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:373.10,375.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:376.4,376.14 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:380.2,380.44 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:384.34,391.2 5 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:397.41,398.33 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:398.33,400.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:404.40,405.33 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:405.33,407.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:411.67,412.33 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:412.33,414.3 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:418.71,422.35 3 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:422.35,424.34 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:424.34,426.18 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:426.18,428.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:430.4,430.39 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:430.39,432.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:435.4,436.41 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:436.41,437.29 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:437.29,439.39 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:439.39,440.57 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:440.57,442.13 2 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:445.6,445.16 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:445.16,447.7 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:448.6,448.11 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:452.4,452.14 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:452.14,460.5 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:462.9,465.18 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:465.18,467.5 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:469.4,469.39 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:469.39,471.5 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:474.4,474.52 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:474.52,476.33 2 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:476.33,477.56 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:477.56,479.12 2 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:482.5,482.15 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:482.15,484.6 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:485.10,487.5 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:492.2,494.12 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:498.46,500.46 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:500.46,509.39 5 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:509.39,511.4 1 0
 github.com/darkit/goproxy/pkg/dns/resolver.go:514.3,514.45 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:519.41,521.29 2 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:521.29,522.18 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:522.18,524.4 1 1
 github.com/darkit/goproxy/pkg/dns/resolver.go:526.2,526.14 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:10.47,11.37 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:11.37,13.3 1 0
 github.com/darkit/goproxy/pkg/dns/wildcard.go:15.2,16.21 2 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:16.21,18.3 1 0
 github.com/darkit/goproxy/pkg/dns/wildcard.go:20.2,23.54 3 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:23.54,25.3 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:27.2,27.54 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:27.54,29.3 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:31.2,31.13 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:41.72,45.2 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:48.65,52.42 3 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:52.42,53.35 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:53.35,55.4 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:58.2,58.70 1 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:62.62,67.2 4 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:70.57,75.2 4 1
 github.com/darkit/goproxy/pkg/dns/wildcard.go:78.42,83.2 4 1
--- a/examples/custom_dns_resolver/main.go
+++ b/examples/custom_dns_resolver/main.go
@@ -0,0 +1,132 @@
 package main
 import (
 	"context"
 	"flag"
 	"log/slog"
 	"net/http"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
 	"github.com/darkit/goproxy"
 	"github.com/darkit/goproxy/pkg/dns"
 )
 func main() {
 	// 解析命令行参数
 	var (
 		listenAddr  = flag.String("listen", ":8080", "代理服务器监听地址")
 		targetAddr  = flag.String("target", "http://example.com", "目标服务器地址（反向代理模式下使用）")
 		proxyMode   = flag.String("mode", "reverse", "代理模式: forward, reverse, transparent")
 		enableHTTPS = flag.Bool("https", false, "是否启用HTTPS拦截")
 		verbosity   = flag.Int("v", 0, "日志详细级别 (0-3)")
 		host        = flag.String("dns-host", "example.com", "要解析的主机名")
 		ip          = flag.String("dns-ip", "127.0.0.1", "解析的IP地址")
 	)
 	flag.Parse()
 	// 配置日志
 	logLevel := slog.LevelInfo
 	switch *verbosity {
 	case 1:
 		logLevel = slog.LevelDebug
 	case 2:
 		logLevel = slog.LevelInfo
 	case 3:
 		logLevel = slog.LevelDebug - 3 // 更详细的调试级别
 	}
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 		Level: logLevel,
 	}))
 	slog.SetDefault(logger)
 	// 创建自定义DNS解析器
 	resolver := dns.NewResolver(
 		dns.WithFallback(true),     // 如果找不到自定义规则，回退到系统DNS
 		dns.WithTTL(5*time.Minute), // 设置缓存TTL
 	)
 	// 添加自定义DNS解析规则
 	if err := resolver.Add(*host, *ip); err != nil {
 		slog.Error("添加DNS解析规则失败", "error", err)
 		return
 	}
 	// 添加通配符DNS解析规则示例
 	if err := resolver.AddWildcard("*.example.org", "192.168.1.2"); err != nil {
 		slog.Error("添加通配符DNS解析规则失败", "error", err)
 		return
 	}
 	slog.Info("已添加DNS解析规则", "host", *host, "ip", *ip)
 	// 创建代理选项
 	var (
 		proxy goproxy.UnifiedProxy
 		err   error
 	)
 	// 根据代理模式创建不同类型的代理
 	switch *proxyMode {
 	case "forward":
 		proxy, err = goproxy.NewForwardProxy(*listenAddr, goproxy.WithUnifiedDNSResolver(resolver))
 	case "reverse":
 		proxy, err = goproxy.NewReverseProxy(*listenAddr, *targetAddr, goproxy.WithUnifiedDNSResolver(resolver))
 	case "transparent":
 		proxy, err = goproxy.NewTransparentProxy(*listenAddr, goproxy.WithUnifiedDNSResolver(resolver))
 	default:
 		slog.Error("不支持的代理模式", "mode", *proxyMode)
 		return
 	}
 	if err != nil {
 		slog.Error("创建代理失败", "error", err)
 		return
 	}
 	// 设置信号处理
 	sigCh := make(chan os.Signal, 1)
 	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
 	// 打印启动信息
 	slog.Info("代理服务器已启动",
 		"mode", *proxyMode,
 		"listen", *listenAddr,
 		"target", *targetAddr,
 		"https", *enableHTTPS)
 	// 启动HTTP服务器
 	server := &http.Server{
 		Addr:    *listenAddr,
 		Handler: proxy,
 	}
 	// 监听和服务连接
 	go func() {
 		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			slog.Error("服务器运行失败", "error", err)
 			os.Exit(1)
 		}
 	}()
 	// 等待中断信号
 	<-sigCh
 	slog.Info("接收到信号，正在关闭...")
 	// 创建关闭上下文
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 	// 优雅关闭HTTP服务器
 	if err := server.Shutdown(ctx); err != nil {
 		slog.Error("服务器关闭失败", "error", err)
 	}
 	// 关闭代理
 	if err := proxy.Close(); err != nil {
 		slog.Error("关闭代理时出错", "error", err)
 	}
 }
--- a/examples/dns_resolver_comparison/main.go
+++ b/examples/dns_resolver_comparison/main.go
@@ -0,0 +1,112 @@
 package main
 import (
 	"flag"
 	"log/slog"
 	"net"
 	"net/http"
 	"net/url"
 	"os"
 	"time"
 	"github.com/darkit/goproxy"
 	"github.com/darkit/goproxy/pkg/dns"
 )
 func main() {
 	// 解析命令行参数
 	var (
 		listenAddr     = flag.String("listen", ":8080", "代理服务器监听地址")
 		targetAddr     = flag.String("target", "http://example.com", "目标服务器地址")
 		useDNSResolver = flag.Bool("custom-dns", false, "是否使用自定义DNS解析")
 		dnsHost        = flag.String("dns-host", "example.com", "要解析的主机名")
 		dnsIP          = flag.String("dns-ip", "127.0.0.1", "解析的IP地址")
 		verbosity      = flag.Int("v", 0, "日志详细级别 (0-3)")
 	)
 	flag.Parse()
 	// 配置日志
 	logLevel := slog.LevelInfo
 	switch *verbosity {
 	case 1:
 		logLevel = slog.LevelDebug
 	case 2:
 		logLevel = slog.LevelInfo
 	case 3:
 		logLevel = slog.LevelDebug - 3 // 更详细的调试级别
 	}
 	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
 		Level: logLevel,
 	}))
 	slog.SetDefault(logger)
 	// 创建反向代理实例
 	var proxy goproxy.UnifiedProxy
 	var err error
 	if *useDNSResolver {
 		// 使用自定义DNS解析器
 		slog.Info("使用自定义DNS解析器")
 		// 创建自定义DNS解析器
 		resolver := dns.NewResolver(
 			dns.WithFallback(true),     // 如果找不到自定义规则，回退到系统DNS
 			dns.WithTTL(5*time.Minute), // 设置缓存TTL
 		)
 		// 添加自定义DNS解析规则
 		if err := resolver.Add(*dnsHost, *dnsIP); err != nil {
 			slog.Error("添加DNS解析规则失败", "error", err)
 			return
 		}
 		slog.Info("添加DNS解析规则", "host", *dnsHost, "ip", *dnsIP)
 		// 创建带自定义DNS解析器的反向代理
 		proxy, err = goproxy.NewReverseProxy(*listenAddr, *targetAddr, goproxy.WithUnifiedDNSResolver(resolver))
 	} else {
 		// 使用系统DNS解析
 		slog.Info("使用系统DNS解析")
 		proxy, err = goproxy.NewReverseProxy(*listenAddr, *targetAddr)
 	}
 	if err != nil {
 		slog.Error("创建代理服务器失败", "error", err)
 		return
 	}
 	// 使用系统DNS解析一次目标地址，打印结果供比较
 	targetHost := *targetAddr
 	// 尝试解析URL
 	if u, err := url.Parse(targetHost); err == nil && u.Host != "" {
 		targetHost = u.Host
 	}
 	// 如果还包含端口，移除端口
 	if host, _, err := net.SplitHostPort(targetHost); err == nil {
 		targetHost = host
 	}
 	ips, err := net.LookupIP(targetHost)
 	if err != nil {
 		slog.Error("系统DNS解析失败", "host", targetHost, "error", err)
 	} else {
 		slog.Info("系统DNS解析结果", "host", targetHost, "ips", ips)
 	}
 	// 创建HTTP服务器
 	server := &http.Server{
 		Addr:    *listenAddr,
 		Handler: proxy,
 	}
 	// 启动服务器
 	slog.Info("代理服务器已启动",
 		"listen", *listenAddr,
 		"target", *targetAddr,
 		"custom_dns", *useDNSResolver)
 	// 监听和服务连接
 	if err := server.ListenAndServe(); err != nil {
 		slog.Error("服务器运行失败", "error", err)
 	}
 }
--- a/examples/rewriter/http_server.go
+++ b/examples/rewriter/http_server.go
@@ -90,7 +90,7 @@ func RewriteMiddleware(rw *rewriter.Rewriter, next http.Handler) http.Handler {
 	})
 }
-func main() {
+func main1() {
 	// 创建重写器
 	rw := rewriter.NewRewriter()
--- a/examples/rewriter/main.go
+++ b/examples/rewriter/main.go
@@ -10,7 +10,7 @@ import (
 	"github.com/darkit/goproxy/pkg/rewriter"
 )
-func main() {
+func main2() {
 	// 创建URL重写器
 	rw := rewriter.NewRewriter()
--- a/factory.go
+++ b/factory.go
@@ -0,0 +1,301 @@
 package goproxy
 import (
 	"crypto/tls"
 	"errors"
 	"net/http"
 	"net/http/httptrace"
 	"strconv"
 	"strings"
 	"time"
 	"github.com/darkit/goproxy/config"
 	"github.com/darkit/goproxy/pkg/auth"
 	"github.com/darkit/goproxy/pkg/cache"
 	"github.com/darkit/goproxy/pkg/dns"
 	"github.com/darkit/goproxy/pkg/healthcheck"
 	"github.com/darkit/goproxy/pkg/loadbalance"
 	"github.com/darkit/goproxy/pkg/metrics"
 )
 // ErrNotSupportHijacking 不支持劫持错误
 var ErrNotSupportHijacking = errors.New("connection does not support hijacking")
 // CreateUnifiedProxy 创建统一代理
 // 为了避免与现有的NewProxy冲突
 func CreateUnifiedProxy(options ...UnifiedOption) (UnifiedProxy, error) {
 	opts := &UnifiedOptions{}
 	for _, option := range options {
 		option(opts)
 	}
 	return NewUnifiedProxy(opts)
 }
 // NewForwardProxy 创建正向代理
 func NewForwardProxy(listenAddr string, options ...UnifiedOption) (UnifiedProxy, error) {
 	cfg := config.DefaultUnifiedConfig()
 	cfg.ListenAddr = listenAddr
 	cfg.ProxyMode = config.ModeForward
 	opts := &UnifiedOptions{
 		Config: cfg,
 	}
 	for _, option := range options {
 		option(opts)
 	}
 	return NewUnifiedProxy(opts)
 }
 // NewReverseProxy 创建反向代理
 func NewReverseProxy(listenAddr, targetAddr string, options ...UnifiedOption) (UnifiedProxy, error) {
 	cfg := config.DefaultUnifiedConfig()
 	cfg.ListenAddr = listenAddr
 	cfg.TargetAddr = targetAddr
 	cfg.ProxyMode = config.ModeReverse
 	opts := &UnifiedOptions{
 		Config: cfg,
 	}
 	for _, option := range options {
 		option(opts)
 	}
 	return NewUnifiedProxy(opts)
 }
 // NewTransparentProxy 创建透明代理
 func NewTransparentProxy(listenAddr string, options ...UnifiedOption) (UnifiedProxy, error) {
 	cfg := config.DefaultUnifiedConfig()
 	cfg.ListenAddr = listenAddr
 	cfg.ProxyMode = config.ModeTransparent
 	opts := &UnifiedOptions{
 		Config: cfg,
 	}
 	for _, option := range options {
 		option(opts)
 	}
 	return NewUnifiedProxy(opts)
 }
 // UnifiedOption 用于配置统一代理选项的函数类型
 type UnifiedOption func(*UnifiedOptions)
 // WithUnifiedConfig 设置代理配置
 func WithUnifiedConfig(cfg *config.UnifiedConfig) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.Config = cfg
 	}
 }
 // WithUnifiedDelegate 设置委托类
 func WithUnifiedDelegate(delegate Delegate) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.Delegate = delegate
 	}
 }
 // WithUnifiedCertCache 设置证书缓存
 func WithUnifiedCertCache(cache CertificateCache) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.CertCache = cache
 	}
 }
 // WithUnifiedHTTPCache 设置HTTP缓存
 func WithUnifiedHTTPCache(c cache.Cache) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.HTTPCache = c
 	}
 }
 // WithUnifiedLoadBalancer 设置负载均衡器
 func WithUnifiedLoadBalancer(lb loadbalance.LoadBalancer) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.LoadBalancer = lb
 	}
 }
 // WithUnifiedHealthChecker 设置健康检查器
 func WithUnifiedHealthChecker(hc *healthcheck.HealthChecker) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.HealthChecker = hc
 	}
 }
 // WithUnifiedMetrics 设置监控指标
 func WithUnifiedMetrics(m metrics.MetricsCollector) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.Metrics = m
 	}
 }
 // WithUnifiedClientTrace 设置HTTP客户端跟踪
 func WithUnifiedClientTrace(t *httptrace.ClientTrace) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.ClientTrace = t
 	}
 }
 // WithUnifiedCertManager 设置证书管理器
 func WithUnifiedCertManager(cm *CertManager) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.CertManager = cm
 	}
 }
 // WithUnifiedAuth 设置认证系统
 func WithUnifiedAuth(a *auth.Auth) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.Auth = a
 	}
 }
 // WithUnifiedDNSResolver 设置DNS解析器
 func WithUnifiedDNSResolver(resolver *dns.CustomResolver) UnifiedOption {
 	return func(opt *UnifiedOptions) {
 		opt.DNSResolver = resolver
 	}
 }
 // 处理劫持连接
 func hijackerImpl(rw http.ResponseWriter) (*ConnBuffer, error) {
 	hijacker, ok := rw.(http.Hijacker)
 	if !ok {
 		return nil, ErrNotSupportHijacking
 	}
 	conn, bufrw, err := hijacker.Hijack()
 	if err != nil {
 		return nil, err
 	}
 	return NewConnBuffer(conn, bufrw.Reader), nil
 }
 // 检查是否是WebSocket请求
 func isWebSocketRequestImpl(req *http.Request) bool {
 	if req.Method != http.MethodGet {
 		return false
 	}
 	connection := req.Header.Get("Connection")
 	if connection == "" {
 		return false
 	}
 	upgrade := req.Header.Get("Upgrade")
 	return upgrade != ""
 }
 // 发送隧道已连接响应
 func tunnelConnectedImpl(_ *Context, err error, rw http.ResponseWriter) error {
 	// 此函数应根据原始代码实现
 	if err != nil {
 		if rw != nil {
 			http.Error(rw, err.Error(), http.StatusServiceUnavailable)
 		}
 		return err
 	}
 	// 发送连接成功响应
 	// 这里简化处理，实际应该根据原代码完整实现
 	if rw != nil {
 		rw.WriteHeader(http.StatusOK)
 	}
 	return nil
 }
 // 可以缓存的HTTP方法
 func canCacheMethodImpl(method string) bool {
 	return method == http.MethodGet
 }
 // 可以缓存的状态码
 func canCacheStatusImpl(statusCode int) bool {
 	return statusCode >= 200 && statusCode < 300
 }
 // 生成缓存键
 func generateCacheKeyImpl(req *http.Request) string {
 	return req.Method + ":" + req.URL.String()
 }
 // 获取缓存TTL
 func getCacheTTLImpl(resp *http.Response) time.Duration {
 	// 检查响应头中的Cache-Control
 	cacheControl := resp.Header.Get("Cache-Control")
 	if cacheControl != "" {
 		// 解析Cache-Control头
 		if strings.Contains(cacheControl, "no-store") || strings.Contains(cacheControl, "no-cache") {
 			return 0 // 不缓存
 		}
 		// 查找max-age指令
 		if strings.Contains(cacheControl, "max-age=") {
 			parts := strings.Split(cacheControl, "max-age=")
 			if len(parts) > 1 {
 				seconds := strings.Split(parts[1], ",")[0]
 				if maxAge, err := strconv.ParseInt(seconds, 10, 64); err == nil {
 					return time.Duration(maxAge) * time.Second
 				}
 			}
 		}
 	}
 	// 检查Expires头
 	if expires := resp.Header.Get("Expires"); expires != "" {
 		if expiresTime, err := time.Parse(time.RFC1123, expires); err == nil {
 			return time.Until(expiresTime)
 		}
 	}
 	// 返回默认缓存时间
 	return 5 * time.Minute
 }
 // 检查是否支持缓存命中指标
 func isCacheHitMetricsSupportedImpl(m metrics.MetricsCollector) bool {
 	// 首先检查是否为nil
 	if m == nil {
 		return false
 	}
 	// 检查是否实现了具体的缓存命中计数方法
 	_, hasIncrementCacheHit := m.(interface {
 		IncrementCacheHit()
 	})
 	// 或者检查是否实现了通用的计数器增加方法
 	_, hasIncrement := m.(interface {
 		Increment(key string, value float64)
 	})
 	// 如果实现了其中任何一个方法，就认为支持缓存命中计数
 	return hasIncrementCacheHit || hasIncrement
 }
 // 增加缓存命中计数
 func incrementCacheHitImpl(m metrics.MetricsCollector) {
 	// 如果指标收集器实现了特定接口，则增加缓存命中计数
 	if counterInterface, ok := m.(interface {
 		IncrementCacheHit()
 	}); ok {
 		counterInterface.IncrementCacheHit()
 	} else if counterInterface, ok := m.(interface {
 		Increment(key string, value float64)
 	}); ok {
 		counterInterface.Increment("cache_hit", 1)
 	}
 }
 // NewTLSConfig 创建新的TLS配置
 func NewTLSConfig(serverName string, insecureSkipVerify bool) *tls.Config {
 	return &tls.Config{
 		ServerName:         serverName,
 		InsecureSkipVerify: insecureSkipVerify,
 	}
 }
--- a/go.mod
+++ b/go.mod
@@ -3,10 +3,10 @@ module github.com/darkit/goproxy
 go 1.24.0
 require (
-	github.com/fsnotify/fsnotify v1.7.0
+	github.com/fsnotify/fsnotify v1.8.0
 	github.com/golang-jwt/jwt/v5 v5.2.1
-	github.com/ouqiang/websocket v1.6.2
+	github.com/ouqiang/websocket v1.6.0
-	github.com/prometheus/client_golang v1.20.4
+	github.com/prometheus/client_golang v1.21.1
 	github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8
 	golang.org/x/time v0.11.0
 )
--- a/go.sum
+++ b/go.sum
@@ -4,22 +4,22 @@ github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UF
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.8.0 h1:dAwr6QBTBZIkG8roQaJjGof0pp0EeF+tNV7YBP3F/8M=
-github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/fsnotify/fsnotify v1.8.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
 github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
 github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/ouqiang/websocket v1.6.2 h1:LGQIySbQO3ahZCl34v9xBVb0yncDk8yIcuEIbWBab/U=
+github.com/ouqiang/websocket v1.6.0 h1:dbo7W207d6P3UaBGeyey8SP80WpFxTDdd80eKUiduEg=
-github.com/ouqiang/websocket v1.6.2/go.mod h1:fIROJIHRlQwgCyUFTMzaaIcs4HIwUj2xlOW43u9Sf+M=
+github.com/ouqiang/websocket v1.6.0/go.mod h1:fIROJIHRlQwgCyUFTMzaaIcs4HIwUj2xlOW43u9Sf+M=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.20.4 h1:Tgh3Yr67PaOv/uTqloMsCEdeuFTatm5zIq5+qNN23vI=
+github.com/prometheus/client_golang v1.21.1 h1:DOvXXTqVzvkIewV/CDPFdejpMCGeMcbGCQ8YOmu+Ibk=
-github.com/prometheus/client_golang v1.20.4/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_golang v1.21.1/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
 github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
 github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
 github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
--- a/pkg/reverse/proxy.go
+++ b/pkg/reverse/proxy.go
@@ -1,3 +1,7 @@
 // Package reverse 提供反向代理功能。
 // Deprecated: 此包已被弃用，请使用统一代理接口 (github.com/darkit/goproxy) 代替。
 // 在未来版本中，此包可能会被移除。
 package reverse
 import (
--- a/unified_proxy.go
+++ b/unified_proxy.go
--- a/统一代理实现说明.md
+++ b/统一代理实现说明.md
@@ -0,0 +1,184 @@
 # GoProxy 统一代理实现说明
 ## 项目背景
 本项目对原有的正向代理和反向代理功能进行了统一实现，提供了一致的配置结构和API接口，使用户可以通过同一套API创建和管理不同类型的代理。
 ## 实现方案
 ### 1. 统一配置结构
 在 `config/unified_config.go` 文件中，我们创建了 `UnifiedConfig` 结构体，包含了所有类型代理的配置项：
 ```go
 type UnifiedConfig struct {
    // 基本配置
    ListenAddr string    // 监听地址
    ProxyMode  ProxyMode // 代理模式：forward, reverse, transparent
    TargetAddr string    // 目标地址(反向代理使用)
    // ... 其他配置项
 }
 ```
 该结构体提供了以下方法：
 - `DefaultUnifiedConfig()`: 返回默认配置
 - `CreateLegacyConfig()`: 创建兼容旧版本的配置（向后兼容）
 - `CreateReverseConfig()`: 创建反向代理配置
 ### 2. 统一代理接口
 在 `unified_proxy.go` 文件中，我们定义了 `UnifiedProxy` 接口：
 ```go
 type UnifiedProxy interface {
    // ServeHTTP 处理HTTP请求
    ServeHTTP(w http.ResponseWriter, r *http.Request)
    // Close 关闭代理
    Close() error
 }
 ```
 ### 3. 代理实现
 `UnifiedProxyImpl` 结构体实现了 `UnifiedProxy` 接口，根据配置的 `ProxyMode` 提供不同的代理行为：
 ```go
 type UnifiedProxyImpl struct {
    // 配置
    config *config.UnifiedConfig
    // ... 其他字段
 }
 ```
 主要的初始化方法:
 - `NewUnifiedProxy()`: 创建统一代理实例
 - `initializeForwardProxy()`: 初始化正向代理
 - `initializeReverseProxy()`: 初始化反向代理
 - `initializeTransparentProxy()`: 初始化透明代理
 处理请求的方法:
 - `serveForwardProxy()`: 处理正向代理请求
 - `serveReverseProxy()`: 处理反向代理请求
 - `serveTransparentProxy()`: 处理透明代理请求
 ### 4. 工厂函数
 在 `factory.go` 文件中，我们提供了多种创建代理的工厂函数：
 ```go
 // 创建统一代理
 func CreateUnifiedProxy(options ...UnifiedOption) (UnifiedProxy, error)
 // 创建正向代理
 func NewForwardProxy(listenAddr string, options ...UnifiedOption) (UnifiedProxy, error)
 // 创建反向代理
 func NewReverseProxy(listenAddr, targetAddr string, options ...UnifiedOption) (UnifiedProxy, error)
 // 创建透明代理
 func NewTransparentProxy(listenAddr string, options ...UnifiedOption) (UnifiedProxy, error)
 ```
 ### 5. 选项模式
 采用功能选项模式配置代理：
 ```go
 // UnifiedOption 用于配置统一代理选项的函数类型
 type UnifiedOption func(*UnifiedOptions)
 // 选项示例
 WithUnifiedConfig(cfg *config.UnifiedConfig)
 WithUnifiedDelegate(delegate Delegate)
 WithUnifiedLoadBalancer(lb loadbalance.LoadBalancer)
 // ... 其他选项
 ```
 ### 6. 命令行工具
 在 `cmd/unified_proxy/main.go` 中实现了一个完整的命令行工具，支持各种代理模式和配置选项：
 ```bash
 # 启动正向代理
 go run cmd/unified_proxy/main.go -mode forward -listen :8080
 # 启动反向代理
 go run cmd/unified_proxy/main.go -mode reverse -listen :8080 -target http://example.com
 ```
 ## 使用示例
 ### 创建正向代理
 ```go
 proxy, err := goproxy.NewForwardProxy(":8080")
 if err != nil {
    log.Fatal(err)
 }
 http.ListenAndServe(":8080", proxy)
 ```
 ### 创建反向代理
 ```go
 proxy, err := goproxy.NewReverseProxy(":8080", "http://example.com")
 if err != nil {
    log.Fatal(err)
 }
 http.ListenAndServe(":8080", proxy)
 ```
 ### 使用功能选项创建代理
 ```go
 cfg := config.DefaultUnifiedConfig()
 cfg.ListenAddr = ":8080"
 cfg.ProxyMode = config.ModeReverse
 cfg.EnableLoadBalancing = true
 lb := loadbalance.NewRoundRobinBalancer()
 lb.Add("http://backend1:8080", 1)
 lb.Add("http://backend2:8080", 1)
 proxy, err := goproxy.CreateUnifiedProxy(
    goproxy.WithUnifiedConfig(cfg),
    goproxy.WithUnifiedLoadBalancer(lb),
 )
 ```
 ## 架构设计
 ```
 +------------------+
 |  UnifiedConfig   |
 +------------------+
          ^
          |
 +------------------+     +------------------+
 |   UnifiedProxy   |<----|  Factory 工厂函数  |
 +------------------+     +------------------+
          ^
          |
 +------------------+     +------------------+
 | UnifiedProxyImpl |---->|   功能组件/插件   |
 +------------------+     +------------------+
       /    \
      /      \
     /        \
 +--------+  +--------+  +-------------+
 | 正向代理 |  | 反向代理 |  | 透明代理实现 |
 +--------+  +--------+  +-------------+
 ```
 ## 兼容性考虑
 1. 保留了原有的API接口，确保向后兼容
 2. 提供配置转换方法，使新旧配置可以互相转换
 3. 所有新增功能通过扩展而非修改实现
 ## 后续工作
 1. 完善单元测试和集成测试
 2. 添加更多代理功能，如请求限流、熔断等
 3. 优化性能，减少内存占用
 4. 完善文档和示例