3. Go 基础回顾：结构体与方法、接口与实现、错误处理、并发基础

在进入契约压测与校验实战之前，必须夯实 Go 语言的核心基础。本章聚焦于四个关键领域：结构体与方法、接口与实现、错误处理以及并发基础（goroutine 与 channel）。这些概念是构建高性能、高可靠压测工具的基石。

3.1 结构体与方法：数据建模的基石

结构体（struct）是 Go 中组织和封装数据的核心方式。方法（method）则为结构体赋予行为。在契约压测中，我们使用结构体来定义请求参数、响应结构、测试配置等。

核心要点：结构体是值类型；方法通过接收者（receiver）绑定到类型上。指针接收者可以修改结构体字段，值接收者则操作副本。

3.1.1 结构体定义与嵌套

// 定义 HTTP 请求配置结构体
type RequestConfig struct {
    Method   string            // GET, POST, PUT, DELETE
    URL      string            // 目标 URL
    Headers  map[string]string // 请求头
    Body     []byte            // 请求体
    Timeout  time.Duration     // 超时时间
}

// 嵌套结构体：压测场景配置
type LoadTestConfig struct {
    Name          string         // 场景名称
    Request       RequestConfig  // 请求配置（嵌套）
    Concurrency   int            // 并发数
    Duration      time.Duration  // 持续时间
    RampUpPeriod  time.Duration  // 预热时间
}

3.1.2 方法与接收者

// 值接收者方法：返回配置的副本，不修改原对象
func (c RequestConfig) Clone() RequestConfig {
    newHeaders := make(map[string]string, len(c.Headers))
    for k, v := range c.Headers {
        newHeaders[k] = v
    }
    return RequestConfig{
        Method:  c.Method,
        URL:     c.URL,
        Headers: newHeaders,
        Body:    append([]byte{}, c.Body...),
        Timeout: c.Timeout,
    }
}

// 指针接收者方法：修改原对象
func (c *RequestConfig) SetTimeout(d time.Duration) {
    c.Timeout = d
}
接收者类型 行为特征 适用场景
值接收者 (T) 操作的是调用者的副本 只读操作、返回新实例、小结构体
指针接收者 (*T) 操作的是调用者本身 修改字段、避免大结构体拷贝、实现接口
实战建议：在压测工具中，RequestConfig 通常较大（包含 Headers map 和 Body 切片），建议使用指针接收者方法以避免不必要的内存拷贝，提升性能。

3.2 接口与实现：契约抽象的核心

接口（interface）定义了行为契约。在 Go 中，接口的实现是隐式的：只要一个类型实现了接口的所有方法，它就实现了该接口。这种设计让代码更加灵活、可测试。

核心要点：接口是方法的集合；隐式实现让代码解耦；空接口 interface{} 可以表示任何类型。

3.2.1 定义压测执行器接口

// 定义压测执行器接口
type LoadTester interface {
    // 执行单个请求，返回响应和耗时
    Execute(ctx context.Context, req *RequestConfig) (*Response, time.Duration, error)
    // 获取执行器名称
    Name() string
    // 关闭执行器，释放资源
    Close() error
}

// HTTP 执行器实现
type HTTPLoadTester struct {
    client *http.Client
}

func (h *HTTPLoadTester) Execute(ctx context.Context, req *RequestConfig) (*Response, time.Duration, error) {
    start := time.Now()
    httpReq, _ := http.NewRequestWithContext(ctx, req.Method, req.URL, bytes.NewReader(req.Body))
    for k, v := range req.Headers {
        httpReq.Header.Set(k, v)
    }
    resp, err := h.client.Do(httpReq)
    elapsed := time.Since(start)
    if err != nil {
        return nil, elapsed, err
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    return &Response{StatusCode: resp.StatusCode, Body: body, Headers: resp.Header}, elapsed, nil
}

func (h *HTTPLoadTester) Name() string { return "HTTP" }
func (h *HTTPLoadTester) Close() error { return nil }

3.2.2 接口组合与类型断言

// 接口组合：更精细的契约
type Reporter interface {
    Report(result *TestResult)
}

type MetricsCollector interface {
    Record(latency time.Duration, status int)
    Summary() map[string]float64
}

// 组合接口
type AdvancedLoadTester interface {
    LoadTester
    Reporter
    MetricsCollector
}

// 类型断言：检查接口实现
func RunTest(tester LoadTester, config *LoadTestConfig) {
    // 检查是否实现了 MetricsCollector 接口
    if collector, ok := tester.(MetricsCollector); ok {
        collector.Record(100*time.Millisecond, 200)
    }
}
接口与实现关系图 LoadTester 接口 Reporter 接口 MetricsCollector 接口 AdvancedLoadTester（组合接口） HTTPLoadTester 结构体 GRPCLoadTester 结构体 隐式实现：HTTPLoadTester 和 GRPCLoadTester 无需显式声明 implements， 只要实现了接口中的所有方法，就自动满足契约。

3.3 错误处理：契约校验的保障

Go 的错误处理哲学是显式而非异常。函数返回 error 类型，调用者必须处理。在压测和契约校验中，错误处理直接关系到测试结果的可靠性。

核心要点：error 是接口；使用 errors.Is 和 errors.As 进行错误链检查；自定义错误类型携带上下文信息。

3.3.1 自定义错误类型

// 自定义错误类型：携带状态码和响应体
type HTTPError struct {
    StatusCode int
    Body       string
    Err        error
}

func (e *HTTPError) Error() string {
    return fmt.Sprintf("HTTP %d: %s (body: %s)", e.StatusCode, e.Err.Error(), e.Body)
}

func (e *HTTPError) Unwrap() error {
    return e.Err
}

// 使用示例
func ValidateResponse(resp *Response, expectedStatus int) error {
    if resp.StatusCode != expectedStatus {
        return &HTTPError{
            StatusCode: resp.StatusCode,
            Body:       string(resp.Body),
            Err:        fmt.Errorf("expected status %d, got %d", expectedStatus, resp.StatusCode),
        }
    }
    return nil
}

3.3.2 错误处理最佳实践

实践 说明 示例
尽早检查错误 函数返回后立即检查 error if err != nil { return err }
包装错误上下文 使用 fmt.Errorf("...: %w", err) fmt.Errorf("execute request: %w", err)
使用 errors.Is/As 检查错误链中的特定错误 errors.Is(err, io.EOF)
避免重复处理 每个错误只处理一次 日志记录或返回，二选一 
// 错误链检查示例
func ProcessResult(result *TestResult) error {
    err := result.Err
    if err == nil {
        return nil
    }
    
    // 检查是否是 HTTP 错误
    var httpErr *HTTPError
    if errors.As(err, &httpErr) {
        if httpErr.StatusCode == 429 {
            // 限流错误，特殊处理
            return fmt.Errorf("rate limited: %w", err)
        }
    }
    
    // 检查是否是超时错误
    if errors.Is(err, context.DeadlineExceeded) {
        return fmt.Errorf("request timeout: %w", err)
    }
    
    return err
}

3.4 并发基础：goroutine 与 channel

Go 的并发模型是压测工具的核心驱动力。goroutine 提供轻量级并发执行单元，channel 用于 goroutine 之间的通信和同步。

核心要点：goroutine 是轻量级线程；channel 是类型化的管道；使用 select 处理多路通信；sync.WaitGroup 用于等待 goroutine 完成。

3.4.1 goroutine 与 WaitGroup

// 并发执行压测请求
func RunConcurrentTest(config *LoadTestConfig) []*TestResult {
    var wg sync.WaitGroup
    results := make([]*TestResult, 0, config.Concurrency)
    resultChan := make(chan *TestResult, config.Concurrency)
    
    // 启动并发 goroutine
    for i := 0; i < config.Concurrency; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            result := executeSingleRequest(config.Request)
            resultChan <- result
        }(i)
    }
    
    // 等待所有 goroutine 完成
    go func() {
        wg.Wait()
        close(resultChan)
    }()
    
    // 收集结果
    for result := range resultChan {
        results = append(results, result)
    }
    
    return results
}

3.4.2 channel 模式：生产者-消费者

// 生产者：生成压测请求
func RequestProducer(ctx context.Context, config *RequestConfig, count int) <-chan *RequestConfig {
    out := make(chan *RequestConfig)
    go func() {
        defer close(out)
        for i := 0; i < count; i++ {
            select {
            case out <- config.Clone():
            case <-ctx.Done():
                return
            }
        }
    }()
    return out
}

// 消费者：执行请求并收集结果
func ResultConsumer(ctx context.Context, tester LoadTester, requests <-chan *RequestConfig) <-chan *TestResult {
    out := make(chan *TestResult)
    go func() {
        defer close(out)
        for req := range requests {
            select {
            case out <- executeWithMetrics(tester, req):
            case <-ctx.Done():
                return
            }
        }
    }()
    return out
}

// 管道组合
func RunPipeline(ctx context.Context, tester LoadTester, config *LoadTestConfig) []*TestResult {
    requests := RequestProducer(ctx, &config.Request, 1000)
    results := ResultConsumer(ctx, tester, requests)
    
    var finalResults []*TestResult
    for result := range results {
        finalResults = append(finalResults, result)
    }
    return finalResults
}
goroutine 与 channel 并发模型 生产者 goroutine 生成请求配置 chan *RequestConfig 消费者 goroutine 执行请求并记录 消费者 goroutine 2 执行请求并记录 消费者 goroutine N 执行请求并记录 生产者-消费者模式：一个生产者 goroutine 生成请求，多个消费者 goroutine 并发执行。 channel 作为线程安全的队列，实现 goroutine 之间的解耦通信。

3.4.3 select 多路复用与超时控制

// 带超时的并发请求
func ExecuteWithTimeout(ctx context.Context, tester LoadTester, req *RequestConfig, timeout time.Duration) (*TestResult, error) {
    // 创建带超时的 context
    ctx, cancel := context.WithTimeout(ctx, timeout)
    defer cancel()
    
    resultChan := make(chan *TestResult, 1)
    errChan := make(chan error, 1)
    
    go func() {
        result, _, err := tester.Execute(ctx, req)
        if err != nil {
            errChan <- err
            return
        }
        resultChan <- result
    }()
    
    // select 多路复用
    select {
    case result := <-resultChan:
        return result, nil
    case err := <-errChan:
        return nil, err
    case <-ctx.Done():
        return nil, fmt.Errorf("request timeout after %v: %w", timeout, ctx.Err())
    }
}
并发陷阱提醒：
  • goroutine 泄漏：确保所有 goroutine 都能退出，使用 context 控制生命周期。
  • channel 死锁：确保发送和接收配对，使用缓冲 channel 或 select 避免阻塞。
  • 数据竞争：多个 goroutine 访问共享变量时使用互斥锁（sync.Mutex）或 channel 同步。
  • 资源耗尽：控制 goroutine 数量，使用工作池（worker pool）模式。

3.5 综合示例：并发压测执行器

将上述概念整合，构建一个基础的并发压测执行器：

// 工作池模式压测执行器
type WorkerPool struct {
    tester    LoadTester
    workers   int
    jobs      chan *RequestConfig
    results   chan *TestResult
    wg        sync.WaitGroup
}

func NewWorkerPool(tester LoadTester, workers int) *WorkerPool {
    return &WorkerPool{
        tester:  tester,
        workers: workers,
        jobs:    make(chan *RequestConfig, 100),
        results: make(chan *TestResult, 100),
    }
}

func (wp *WorkerPool) Start(ctx context.Context) {
    for i := 0; i < wp.workers; i++ {
        wp.wg.Add(1)
        go wp.worker(ctx, i)
    }
}

func (wp *WorkerPool) worker(ctx context.Context, id int) {
    defer wp.wg.Done()
    for {
        select {
        case job, ok := <-wp.jobs:
            if !ok {
                return // channel 关闭，退出
            }
            result, _, err := wp.tester.Execute(ctx, job)
            if err != nil {
                result = &TestResult{Err: err}
            }
            wp.results <- result
        case <-ctx.Done():
            return // context 取消，退出
        }
    }
}

func (wp *WorkerPool) Submit(req *RequestConfig) {
    wp.jobs <- req
}

func (wp *WorkerPool) Results() <-chan *TestResult {
    return wp.results
}

func (wp *WorkerPool) Stop() {
    close(wp.jobs)
    wp.wg.Wait()
    close(wp.results)
}
性能优化提示：工作池模式可以有效控制并发 goroutine 数量，避免资源耗尽。在压测场景中，建议将 worker 数量设置为 CPU 核心数的 2-4 倍，并根据实际压测结果进行调整。
← 上一章 📖 返回目录 下一章 →