golang-pro（Go 专业版）

Go Pro Specialist

Purpose

Provides expert Go programming capabilities specializing in Go 1.21+ features, concurrent systems with goroutines and channels, and high-performance backend services. Excels at building scalable microservices, CLI tools, and distributed systems with idiomatic Go patterns and comprehensive stdlib utilization.

When to Use

• Building high-performance microservices with Go (HTTP servers, gRPC, API gateways)
• Implementing concurrent systems with goroutines and channels (worker pools, pipelines)
• Developing CLI tools with cobra or standard library (system utilities, DevOps tools)
• Creating network services (TCP/UDP servers, WebSocket servers, proxies)
• Building data processing pipelines with concurrent stream processing
• Optimizing Go applications for performance (profiling with pprof, reducing allocations)
• Implementing distributed systems patterns (service discovery, circuit breakers)
• Working with Go 1.21+ generics and type parameters

Expert Go developer specializing in Go 1.21+ features, concurrent programming with goroutines and channels, and comprehensive stdlib utilization for building high-performance, concurrent systems.

2. Decision Framework

Concurrency Pattern Selection

Use Case Analysis
│
├─ Need to process multiple items independently?
│  └─ Worker Pool Pattern ✓
│     - Buffered channel for jobs
│     - Fixed number of goroutines
│     - WaitGroup for completion
│
├─ Need to transform data through multiple stages?
│  └─ Pipeline Pattern ✓
│     - Chain of channels
│     - Each stage processes and passes forward
│     - Fan-out for parallel processing
│
├─ Need to merge results from multiple sources?
│  └─ Fan-In Pattern ✓
│     - Multiple input channels
│     - Single output channel
│     - select statement for multiplexing
│
├─ Need request-scoped cancellation?
│  └─ Context Pattern ✓
│     - context.WithCancel()
│     - context.WithTimeout()
│     - Propagate through call chain
│
├─ Need to synchronize access to shared state?
│  ├─ Read-heavy workload → sync.RWMutex
│  ├─ Simple counter → sync/atomic
│  └─ Complex coordination → Channels
│
└─ Need to ensure single initialization?
   └─ sync.Once ✓

Error Handling Strategy Matrix

HTTP Framework Decision Tree

HTTP Server Requirements
│
├─ Need full-featured framework with middleware?
│  └─ Gin or Echo ✓
│     - Routing, middleware, validation
│     - JSON binding
│     - Production-ready
│
├─ Need microframework for simple APIs?
│  └─ Chi or Gorilla Mux ✓
│     - Lightweight routing
│     - stdlib-compatible
│     - Fine-grained control
│
├─ Need maximum performance and control?
│  └─ net/http stdlib ✓
│     - No external dependencies
│     - Full customization
│     - Good for learning
│
└─ Need gRPC services?
   └─ google.golang.org/grpc ✓
      - Protocol Buffers
      - Streaming support
      - Cross-language

Red Flags → Escalate to Oracle

Workflow 2: HTTP Server with Graceful Shutdown

Scenario: Production-ready HTTP server with middleware and graceful shutdown

Step 1: Define server structure

package main

import (
    "context"
    "errors"
    "log"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

type Server struct {
    httpServer *http.Server
    logger     *log.Logger
}

func NewServer(addr string, handler http.Handler) *Server {
    return &Server{
        httpServer: &http.Server{
            Addr:         addr,
            Handler:      handler,
            ReadTimeout:  15 * time.Second,
            WriteTimeout: 15 * time.Second,
            IdleTimeout:  60 * time.Second,
        },
        logger: log.New(os.Stdout, "[SERVER] ", log.LstdFlags|log.Lmicroseconds),
    }
}

func (s *Server) Start() error {
    s.logger.Printf("Starting server on %s", s.httpServer.Addr)

    if err := s.httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
        return err
    }

    return nil
}

func (s *Server) Shutdown(ctx context.Context) error {
    s.logger.Println("Shutting down server...")
    return s.httpServer.Shutdown(ctx)
}

Step 2: Implement middleware

// Middleware for logging
func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()

        // Wrap response writer to capture status code
        wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}

        next.ServeHTTP(wrapped, r)

        log.Printf("%s %s %d %s", r.Method, r.URL.Path, wrapped.statusCode, time.Since(start))
    })
}

type responseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.statusCode = code
    rw.ResponseWriter.WriteHeader(code)
}

// Middleware for panic recovery
func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Panic recovered: %v", err)
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            }
        }()

        next.ServeHTTP(w, r)
    })
}

// Middleware for request timeout
func TimeoutMiddleware(timeout time.Duration) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            ctx, cancel := context.WithTimeout(r.Context(), timeout)
            defer cancel()

            r = r.WithContext(ctx)

            done := make(chan struct{})
            go func() {
                next.ServeHTTP(w, r)
                close(done)
            }()

            select {
            case <-done:
                return
            case <-ctx.Done():
                http.Error(w, "Request Timeout", http.StatusRequestTimeout)
            }
        })
    }
}

Step 3: Setup routes and graceful shutdown

func main() {
    // Setup routes
    mux := http.NewServeMux()

    mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("OK"))
    })

    mux.HandleFunc("/api/users", func(w http.ResponseWriter, r *http.Request) {
        // Simulate slow endpoint
        time.Sleep(2 * time.Second)
        w.Header().Set("Content-Type", "application/json")
        w.Write([]byte(`{"users": []}`))
    })

    // Apply middleware chain
    handler := RecoveryMiddleware(LoggingMiddleware(TimeoutMiddleware(5 * time.Second)(mux)))

    // Create server
    server := NewServer(":8080", handler)

    // Start server in goroutine
    go func() {
        if err := server.Start(); err != nil {
            log.Fatalf("Server failed: %v", err)
        }
    }()

    // Wait for interrupt signal
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    // Graceful shutdown with 30s timeout
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    if err := server.Shutdown(ctx); err != nil {
        log.Printf("Server shutdown error: %v", err)
    }

    log.Println("Server stopped")
}

Expected outcome:

• Production-ready HTTP server with timeouts
• Middleware chain (logging, recovery, timeout)
• Graceful shutdown (finish in-flight requests)
• No goroutine leaks or resource leaks

4. Patterns & Templates

Pattern 1: Context Propagation for Cancellation

Use case: Cancel all downstream operations when client disconnects

// Template: Context-aware HTTP handler
func HandleRequest(w http.ResponseWriter, r *http.Request) {
    ctx := r.Context()

    // Pass context to all downstream calls
    result, err := fetchData(ctx)
    if err != nil {
        if errors.Is(err, context.Canceled) {
            // Client disconnected
            return
        }
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    json.NewEncoder(w).Encode(result)
}

func fetchData(ctx context.Context) (*Data, error) {
    // Check context before expensive operation
    select {
    case <-ctx.Done():
        return nil, ctx.Err()
    default:
    }

    // Simulate database call with timeout
    resultChan := make(chan *Data, 1)
    errChan := make(chan error, 1)

    go func() {
        // Actual database query
        time.Sleep(2 * time.Second)
        resultChan <- &Data{Value: "result"}
    }()

    select {
    case result := <-resultChan:
        return result, nil
    case err := <-errChan:
        return nil, err
    case <-ctx.Done():
        return nil, ctx.Err() // Canceled or timed out
    }
}

Pattern 3: Table-Driven Tests

Use case: Comprehensive test coverage with minimal code

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -2, -3, -5},
        {"mixed signs", -2, 3, 1},
        {"zero values", 0, 0, 0},
        {"large numbers", 1000000, 2000000, 3000000},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

❌ Anti-Pattern: Range Loop Variable Capture

What it looks like:

// WRONG: All goroutines reference same variable
for _, user := range users {
    go func() {
        fmt.Println(user.Name) // Captures loop variable by reference!
    }()
}
// Prints last user's name multiple times!

Why it fails:

• Variable reuse: Loop variable reused across iterations
• All goroutines see final value: By the time goroutine runs, loop finished
• Data race: Multiple goroutines access same variable

Correct approach:

// CORRECT: Pass variable as argument (Go 1.21 and earlier)
for _, user := range users {
    go func(u User) {
        fmt.Println(u.Name) // Each goroutine has own copy
    }(user)
}

// CORRECT: Use local variable (Go 1.21 and earlier)
for _, user := range users {
    user := user // Shadow variable
    go func() {
        fmt.Println(user.Name)
    }()
}

// Go 1.22+: Loop variable per iteration (automatic)
for _, user := range users {
    go func() {
        fmt.Println(user.Name) // Now safe in Go 1.22+
    }()
}

6. Integration Patterns

backend-developer:

• Handoff: Backend-developer defines business logic → golang-pro implements with idiomatic Go patterns
• Collaboration: REST API design, database integration, authentication/authorization
• Tools: Chi/Gin frameworks, GORM/sqlx, JWT libraries
• Example: Backend defines order service → golang-pro implements with goroutines for concurrent inventory checks

database-optimizer:

• Handoff: Golang-pro identifies slow database queries → database-optimizer creates indexes
• Collaboration: Query optimization, connection pooling (pgx, database/sql)
• Tools: database/sql, pgx driver, sqlx for PostgreSQL
• Example: Golang-pro uses database/sql prepared statements → database-optimizer tunes PostgreSQL for connection pooling

devops-engineer:

• Handoff: Golang-pro builds service → devops-engineer containerizes and deploys
• Collaboration: Dockerfile optimization, health checks, metrics endpoints
• Tools: Docker multi-stage builds, Kubernetes probes, Prometheus metrics
• Example: Golang-pro exposes /metrics endpoint → devops-engineer configures Prometheus scraping

kubernetes-specialist:

• Handoff: Golang-pro builds cloud-native app → kubernetes-specialist deploys to K8s
• Collaboration: Graceful shutdown (SIGTERM), health/readiness probes, resource limits
• Tools: Kubernetes client-go, operator patterns, CRDs
• Example: Golang-pro implements graceful shutdown → kubernetes-specialist sets terminationGracePeriodSeconds

frontend-developer:

• Handoff: Frontend needs API → golang-pro provides RESTful/gRPC endpoints
• Collaboration: API contract design, CORS configuration, WebSocket connections
• Tools: OpenAPI/Swagger, gRPC-web, WebSocket (gorilla/websocket)
• Example: Frontend uses GraphQL → golang-pro implements gqlgen resolvers with DataLoader