想用Golang构建一个负载均衡器？这里有你需要的指南

在Go中构建负载均衡器并处理异步API调用是可行的。以下是针对你需求的解决方案：

负载均衡和请求重定向

使用标准库的 net/http 和 net/http/httputil 包：

package main

import (
    "net/http"
    "net/http/httputil"
    "net/url"
    "strings"
)

// 根据头部信息路由到不同后端
func main() {
    // 定义后端服务
    nodejsBackend, _ := url.Parse("http://localhost:3000")
    defaultBackend, _ := url.Parse("http://localhost:8080")
    
    // 创建反向代理
    nodejsProxy := httputil.NewSingleHostReverseProxy(nodejsBackend)
    defaultProxy := httputil.NewSingleHostReverseProxy(defaultBackend)
    
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 根据头部信息决定路由
        if shouldRouteToNodeJS(r.Header) {
            nodejsProxy.ServeHTTP(w, r)
        } else {
            defaultProxy.ServeHTTP(w, r)
        }
    })
    
    http.ListenAndServe(":8080", nil)
}

func shouldRouteToNodeJS(headers http.Header) bool {
    // 根据特定头部值决定是否路由到Node.js
    return headers.Get("X-Service-Type") == "nodejs" ||
           strings.Contains(headers.Get("User-Agent"), "NodeJS-Client")
}

异步调用多个API

使用goroutine和channel实现异步调用：

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "sync"
    "time"
)

type APIResponse struct {
    URL      string
    Response string
    Error    error
}

func callAPI(ctx context.Context, url string, ch chan<- APIResponse) {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        ch <- APIResponse{URL: url, Error: err}
        return
    }
    
    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        ch <- APIResponse{URL: url, Error: err}
        return
    }
    defer resp.Body.Close()
    
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        ch <- APIResponse{URL: url, Error: err}
        return
    }
    
    ch <- APIResponse{
        URL:      url,
        Response: string(body),
    }
}

func callMultipleAPIs(urls []string) []APIResponse {
    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel()
    
    ch := make(chan APIResponse, len(urls))
    var wg sync.WaitGroup
    
    // 启动多个goroutine并发调用API
    for _, url := range urls {
        wg.Add(1)
        go func(u string) {
            defer wg.Done()
            callAPI(ctx, u, ch)
        }(url)
    }
    
    // 等待所有goroutine完成
    go func() {
        wg.Wait()
        close(ch)
    }()
    
    // 收集结果
    var results []APIResponse
    for result := range ch {
        results = append(results, result)
    }
    
    return results
}

// 在HTTP处理器中使用
func apiHandler(w http.ResponseWriter, r *http.Request) {
    urls := []string{
        "https://api1.example.com/data",
        "https://api2.example.com/info",
    }
    
    results := callMultipleAPIs(urls)
    
    // 处理所有API调用的结果
    for _, result := range results {
        if result.Error != nil {
            fmt.Printf("API %s failed: %v\n", result.URL, result.Error)
        } else {
            fmt.Printf("API %s response: %s\n", result.URL, result.Response)
        }
    }
    
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("APIs processed"))
}

完整的负载均衡器示例

package main

import (
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "sync/atomic"
)

type LoadBalancer struct {
    backends []*url.URL
    current  uint64
}

func NewLoadBalancer(backendURLs []string) *LoadBalancer {
    lb := &LoadBalancer{}
    for _, u := range backendURLs {
        url, _ := url.Parse(u)
        lb.backends = append(lb.backends, url)
    }
    return lb
}

func (lb *LoadBalancer) nextBackend() *url.URL {
    if len(lb.backends) == 0 {
        return nil
    }
    index := atomic.AddUint64(&lb.current, 1) % uint64(len(lb.backends))
    return lb.backends[index]
}

func (lb *LoadBalancer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    backend := lb.nextBackend()
    if backend == nil {
        http.Error(w, "No backends available", http.StatusServiceUnavailable)
        return
    }
    
    proxy := httputil.NewSingleHostReverseProxy(backend)
    proxy.ServeHTTP(w, r)
}

func main() {
    backends := []string{
        "http://localhost:3001",
        "http://localhost:3002", 
        "http://localhost:3003",
    }
    
    lb := NewLoadBalancer(backends)
    
    log.Println("Load balancer starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", lb))
}

这些示例展示了如何使用Go构建负载均衡器、根据头部信息路由请求，以及并发调用多个API。goroutine和channel提供了强大的异步处理能力，而标准库的HTTP包则简化了反向代理的实现。