Go语言中实现绝对路径HTTP重定向的策略与实践

func Redirect(w ResponseWriter, r *Request, urlStr string, code int)

// Redirect replies to the request with a redirect to url,
// which may be a path relative to the request path.
func Redirect(w ResponseWriter, r *Request, urlStr string, code int) {
    if u, err := url.Parse(urlStr); err == nil {
        // If url was relative, make absolute by
        // combining with request path.
        // The browser would probably do this for us,
        // but doing it ourselves is more reliable.

        // NOTE(rsc): RFC 2616 says that the Location
        // line must be an absolute URI, like
        // "http://www.google.com/redirect/",
        // not a path like "/redirect/".
        // Unfortunately, we don't know what to
        // put in the host name section to get the
        // client to connect to us again, so we can't
        // know the right absolute URI to send back.
        // Because of this problem, no one pays attention
        // to the RFC; they all send back just a new path.
        // So do we.
        oldpath := r.URL.Path
        if oldpath == "" { // should not happen, but avoid a crash if it does
            oldpath = "/"
        }
        if u.Scheme == "" { // 关键判断：如果URL没有协议（scheme）
            // no leading http://server
            if urlStr == "" || urlStr[0] != '/' {
                // make relative path absolute
                olddir, _ := path.Split(oldpath)
                urlStr = olddir + urlStr
            }

            var query string
            if i := strings.Index(urlStr, "?"); i != -1 {
                urlStr, query = urlStr[:i], urlStr[i:]
            }

            // clean up but preserve trailing slash
            trailing := strings.HasSuffix(urlStr, "/")
            urlStr = path.Clean(urlStr)
            if trailing && !strings.HasSuffix(urlStr, "/") {
                urlStr += "/"
            }
            urlStr += query
        }
    }

    w.Header().Set("Location", urlStr)
    w.WriteHeader(code)

    // ... (省略了处理响应体的部分)
}

package main

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

func main() {
    // 根路径处理函数
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "欢迎访问根路径！当前路径: %s\n", r.URL.Path)
        fmt.Fprintf(w, "尝试访问 /relative-redirect 或 /absolute-redirect 或 /external-redirect\n")
    })

    // 相对路径重定向示例
    http.HandleFunc("/relative-redirect", func(w http.ResponseWriter, r *http.Request) {
        // 这里的 "/target" 会被浏览器解释为相对于当前域的根路径
        // 例如，如果当前请求是 http://localhost:8080/relative-redirect
        // 重定向后会是 http://localhost:8080/target
        log.Printf("执行相对路径重定向到 /target")
        http.Redirect(w, r, "/target", http.StatusFound) // 302 Found
    })

    // 绝对路径重定向到同一域内的示例
    http.HandleFunc("/absolute-redirect", func(w http.ResponseWriter, r *http.Request) {
        // 动态构建包含协议和主机的完整URL
        // r.URL.Scheme 在某些情况下可能为空（例如，在代理后），
        // 可以使用 r.TLS != nil 来判断是否是HTTPS，或者依赖代理设置X-Forwarded-Proto
        scheme := "http"
        if r.TLS != nil || r.Header.Get("X-Forwarded-Proto") == "https" {
            scheme = "https"
        }

        targetPath := "/target"
        absoluteURL := fmt.Sprintf("%s://%s%s", scheme, r.Host, targetPath)

        log.Printf("执行绝对路径重定向到 %s", absoluteURL)
        http.Redirect(w, r, absoluteURL, http.StatusFound) // 302 Found
    })

    // 绝对路径重定向到外部URL的示例
    http.HandleFunc("/external-redirect", func(w http.ResponseWriter, r *http.Request) {
        externalURL := "https://www.google.com"
        log.Printf("执行外部绝对路径重定向到 %s", externalURL)
        http.Redirect(w, r, externalURL, http.StatusFound) // 302 Found
    })

    // 目标路径处理函数
    http.HandleFunc("/target", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "您已成功重定向到目标路径！当前路径: %s\n", r.URL.Path)
    })

    fmt.Println("服务器正在监听 :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}