使用Go语言实现基于域名的透明反向代理

package main

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

// backendMapping 存储域名到后端服务URL的映射
var backendMapping = map[string]*url.URL{
    "mydomainA.com": {Scheme: "http", Host: "localhost:1234"}, // 域名A映射到本地1234端口
    "mydomainB.com": {Scheme: "http", Host: "localhost:4567"}, // 域名B映射到本地4567端口
    // 可以根据需要添加更多域名和后端服务的映射
}

func main() {
    // 创建一个HTTP多路复用器
    mux := http.NewServeMux()

    // 注册一个处理所有请求的处理器函数
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // 提取请求的Host头，去除端口部分以便匹配映射
        hostWithoutPort, _, err := net.SplitHostPort(r.Host)
        if err != nil {
            // 如果Host头不包含端口，则直接使用Host头作为域名
            hostWithoutPort = r.Host
        }

        // 根据域名查找对应的后端服务URL
        targetURL, ok := backendMapping[hostWithoutPort]
        if !ok {
            log.Printf("收到未知域名的请求: %s", hostWithoutPort)
            http.Error(w, fmt.Sprintf("无法处理的域名: %s", hostWithoutPort), http.StatusBadGateway)
            return
        }

        // 创建并配置一个ReverseProxy实例
        proxy := &httputil.ReverseProxy{
            Director: func(req *http.Request) {
                // 修改请求的URL，使其指向后端服务
                req.URL.Scheme = targetURL.Scheme
                req.URL.Host = targetURL.Host
                req.URL.Path = r.URL.Path     // 保留原始请求路径
                req.URL.RawQuery = r.URL.RawQuery // 保留原始查询参数

                // 关键一步：将原始请求的Host头传递给后端服务。
                // 这样后端服务就能知道最初是哪个域名发起的请求。
                req.Host = r.Host

                // 添加X-Forwarded-*头，用于记录客户端真实IP和原始协议等信息
                if clientIP, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
                    if prior := req.Header.Get("X-Forwarded-For"); prior != "" {
                        req.Header.Set("X-Forwarded-For", prior+", "+clientIP)
                    } else {
                        req.Header.Set("X-Forwarded-For", clientIP)
                    }
                }
                req.Header.Set("X-Forwarded-Host", r.Host)
                // 根据原始请求的协议设置X-Forwarded-Proto
                if r.TLS != nil {
                    req.Header.Set("X-Forwarded-Proto", "https")
                } else {
                    req.Header.Set("X-Forwarded-Proto", "http")
                }
            },
            // 自定义错误处理器，当代理转发失败时返回友好的错误信息
            ErrorHandler: func(rw http.ResponseWriter, req *http.Request, err error) {
                log.Printf("代理转发错误: 请求 %s 到后端 %s 失败: %v", req.URL.String(), targetURL.String(), err)
                http.Error(rw, "内部服务器错误或后端服务不可用", http.StatusBadGateway)
            },
        }

        // 执行代理转发
        proxy.ServeHTTP(w, r)
    })

    log.Println("反向代理服务启动，监听端口: 8080")
    // 监听8080端口，接收所有进来的HTTP请求
    // 在生产环境中，通常会监听80或443端口
    log.Fatal(http.ListenAndServe(":8080", mux))
}

// 为了测试，你可以运行以下简单的后端服务：
/*
func main() {
    // 后端服务A
    go func() {
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintf(w, "Hello from Backend A on port 1234! Original Host: %s, Path: %s\n", r.Host, r.URL.Path)
        })
        log.Fatal(http.ListenAndServe(":1234", nil))
    }()

    // 后端服务B
    go func() {
        http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintf(w, "Hello from Backend B on port 4567! Original Host: %s, Path: %s\n", r.Host, r.URL.Path)
        })
        log.Fatal(http.ListenAndServe(":4567", nil))
    }()

    // 启动反向代理（如上述代码所示）
    // ...
}
*/