Golang中HTTP重定向到HTTPS的问题：1.10版本是否存在回归？

在 Go 1.10 中，你遇到的问题并非回归，而是代码执行逻辑导致的常见问题。当你在 go 语句中启动 HTTPS 服务器时，它会在后台运行，但主线程会立即继续执行并启动 HTTP 服务器。如果 HTTP 服务器的 ListenAndServe() 阻塞（这是正常行为），程序会一直等待，直到 HTTP 服务器出错或停止。如果 HTTPS 服务器在启动时遇到错误（例如权限问题或端口被占用），错误会被记录，但主线程不会捕获它，导致 HTTP 服务器看起来“隐藏”了 HTTPS 服务器。

关键点在于：ListenAndServeTLS 和 ListenAndServe 都是阻塞调用，除非在 goroutine 中运行，否则会顺序执行。在你的代码中，HTTPS 服务器在 goroutine 中启动，但 HTTP 服务器在主线程中启动并阻塞，因此如果 HTTP 服务器先启动并成功监听，它会一直运行，而 HTTPS 服务器的任何错误可能被忽略。反之，如果 HTTPS 服务器在 goroutine 中启动失败，错误可能被记录，但 HTTP 服务器仍会启动。

以下是修改后的代码示例，使用 goroutine 启动两个服务器，并添加错误处理以确保两者都能独立运行：

package main

import (
    "crypto/tls"
    "fmt"
    "net/http"
    "log"
    "time"
)

func main() {
    // 创建 HTTPS 服务器
    smux := &http.ServeMux{}
    smux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
        fmt.Fprintf(w, "Hello, world")
    })

    tlsConfig := &tls.Config{
        PreferServerCipherSuites: true,
        CurvePreferences: []tls.CurveID{
            tls.CurveP256,
            tls.X25519,
        },
        MinVersion: tls.VersionTLS12,
        CipherSuites: []uint16{
            tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
            tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
            tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
            tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
            tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
            tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
        },
        NextProtos: []string{"http/1.1"},
    }

    cert, err := tls.LoadX509KeyPair(".\\tiers\\staging\\server.crt", ".\\tiers\\staging\\server.key")
    if err != nil {
        log.Fatal("Failed to load TLS certificate:", err)
    }
    tlsConfig.Certificates = append(tlsConfig.Certificates, cert)
    tlsConfig.BuildNameToCertificate()

    httpsServer := newServer()
    httpsServer.Addr = ":443"
    httpsServer.TLSConfig = tlsConfig
    httpsServer.TLSNextProto = make(map[string]func(*http.Server, *tls.Conn, http.Handler))
    httpsServer.Handler = smux

    // 在 goroutine 中启动 HTTPS 服务器
    go func() {
        log.Println("Starting HTTPS server on :443")
        if err := httpsServer.ListenAndServeTLS("", ""); err != nil && err != http.ErrServerClosed {
            log.Fatal("HTTPS server error:", err)
        }
    }()

    // 创建 HTTP 重定向服务器
    httpServer := newServer()
    httpServer.Addr = ":80"
    hmux := &http.ServeMux{}
    hmux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
        w.Header().Set("Connection", "close")
        url := "https://" + req.Host + req.URL.String()
        http.Redirect(w, req, url, http.StatusMovedPermanently)
    })
    httpServer.Handler = hmux

    // 在 goroutine 中启动 HTTP 服务器
    go func() {
        log.Println("Starting HTTP server on :80")
        if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatal("HTTP server error:", err)
        }
    }()

    // 保持主程序运行以允许服务器持续监听
    select {}
}

func newServer() *http.Server {
    return &http.Server{
        ReadTimeout:       5 * time.Second,
        ReadHeaderTimeout: 4 * time.Second,
        WriteTimeout:      10 * time.Second,
        IdleTimeout:       120 * time.Second,
    }
}

在这个修改中，两个服务器都在独立的 goroutine 中启动，并使用 select {} 保持主程序运行。这样，两个服务器可以并行监听，不会互相阻塞。错误处理确保任何服务器启动失败都会记录并终止程序。这解决了你描述的“阻塞或隐藏”问题，与 Go 1.10 版本无关。