Golang创建HTTP服务教程 net/http入门实践

Golang通过net/http标准库可快速构建HTTP服务，使用http.HandleFunc注册路由并监听端口即可启动服务器。通过r.Method可区分GET、POST等请求方法，在Handler中实现不同逻辑。中间件通过函数包装实现，如日志和认证，形成洋葱圈式处理链。优雅关闭利用signal.Notify监听系统信号，结合context.WithTimeout和server.Shutdown确保服务在终止前完成正在进行的请求，保障服务稳定性。

用Golang创建HTTP服务，最基础也最直接的方式就是利用其标准库net/http。它提供了一套非常成熟且简洁的API，让开发者能够快速搭建起一个功能完备的Web服务器，处理HTTP请求和响应。

解决方案

其实，要用Go搭建一个最简单的HTTP服务，代码量少得让人难以置信。核心就是定义一个处理函数（Handler）来响应特定的请求路径，然后让服务器监听一个端口。

package main

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

// homeHandler 处理根路径 "/" 的请求
func homeHandler(w http.ResponseWriter, r *http.Request) {
    // r.URL.Path 检查请求路径，确保只处理根路径
    if r.URL.Path != "/" {
        http.NotFound(w, r) // 如果不是根路径，返回404
        return
    }
    fmt.Fprintf(w, "Hello, Go Web! 你好世界！")
}

// aboutHandler 处理 "/about" 路径的请求
func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "这是一个关于页面。")
}

func main() {
    // 注册路由和对应的处理函数
    // http.HandleFunc 将一个路径与一个处理函数关联起来
    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/about", aboutHandler)

    // 启动HTTP服务器，监听8080端口
    // log.Fatal 会在ListenAndServe返回错误时打印错误并退出程序
    fmt.Println("服务器正在监听 http://localhost:8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

这段代码，你保存成一个.go文件，比如main.go，然后命令行里跑go run main.go，一个HTTP服务就起来了。浏览器访问http://localhost:8080和http://localhost:8080/about，就能看到效果。http.ListenAndServe的第二个参数是nil，这意味着它会使用http.DefaultServeMux作为路由器，而我们前面注册的HandleFunc就是往这个默认路由器里加规则。

Golang HTTP服务如何处理不同请求方法和路径？

在实际的Web开发中，一个URL路径往往需要根据不同的HTTP方法（GET、POST、PUT、DELETE等）来执行不同的逻辑。net/http包的http.HandlerFunc类型，其签名是func(w http.ResponseWriter, r *http.Request)，r *http.Request这个参数就包含了所有关于请求的信息，包括请求方法。

我们可以在一个Handler内部，通过检查r.Method来区分处理逻辑。比如，对于一个articles资源，GET请求可能用于获取文章列表，而POST请求则用于创建新文章。

package main

import (
    "fmt"
    "log"
    "net/http"
    "io/ioutil" // 用于读取请求体
)

func articlesHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        // 处理获取文章列表或单篇文章的逻辑
        fmt.Fprintf(w, "你发起了GET请求，正在获取文章列表或单篇文章。")
    case "POST":
        // 处理创建新文章的逻辑
        body, err := ioutil.ReadAll(r.Body)
        if err != nil {
            http.Error(w, "无法读取请求体", http.StatusInternalServerError)
            return
        }
        fmt.Printf("收到了POST请求，内容是: %s\n", string(body))
        fmt.Fprintf(w, "你发起了POST请求，正在创建新文章。")
    case "PUT":
        // 处理更新文章的逻辑
        fmt.Fprintf(w, "你发起了PUT请求，正在更新文章。")
    case "DELETE":
        // 处理删除文章的逻辑
        fmt.Fprintf(w, "你发起了DELETE请求，正在删除文章。")
    default:
        // 对于不支持的方法，返回405 Method Not Allowed
        http.Error(w, "不支持的请求方法", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/articles", articlesHandler)
    fmt.Println("服务器正在监听 http://localhost:8080/articles")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

这段代码展示了如何在一个处理函数中根据r.Method进行分支判断。这是一种非常直接且常见的做法。对于更复杂的路由需求，比如RESTful API中带有参数的路径（/articles/{id}），net/http本身需要一些额外的逻辑来解析路径参数，或者通常会引入第三方路由库（如gorilla/mux、chi等）来简化这个过程。不过，对于基础实践，这种switch r.Method的方式足以应对很多场景。

Go Web服务如何实现中间件（Middleware）模式？

在构建Web服务时，我们经常需要在请求到达最终的处理函数之前或之后执行一些通用的操作，比如日志记录、身份验证、请求头解析、错误处理等。这种模式就是中间件。net/http虽然没有内置像Express.js那样的中间件链机制，但我们可以通过函数包装（或称作高阶函数）的方式来实现。

核心思想是，一个中间件函数接收一个http.Handler（或http.HandlerFunc），然后返回一个新的http.Handler。这个新的Handler在执行自己的逻辑后，会调用传入的原始Handler。

package main

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

// loggingMiddleware 是一个简单的日志中间件
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        // 在这里执行前置逻辑，比如记录请求信息
        log.Printf("收到请求: %s %s", r.Method, r.URL.Path)

        // 调用链中的下一个Handler
        next.ServeHTTP(w, r)

        // 在这里执行后置逻辑，比如记录响应时间
        log.Printf("请求处理完成: %s %s，耗时 %v", r.Method, r.URL.Path, time.Since(start))
    })
}

// authMiddleware 是一个简单的身份验证中间件
func authMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 检查请求头中是否有"X-Auth-Token"
        token := r.Header.Get("X-Auth-Token")
        if token != "my-secret-token" {
            http.Error(w, "未授权访问", http.StatusUnauthorized)
            log.Printf("未授权访问尝试: %s %s", r.Method, r.URL.Path)
            return // 阻止请求继续向下传递
        }
        log.Println("身份验证通过。")
        // 如果验证通过，调用链中的下一个Handler
        next.ServeHTTP(w, r)
    })
}

// finalHandler 是最终的业务逻辑处理函数
func finalHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "这是受保护的资源！")
}

func main() {
    // 将最终的Handler包装进中间件
    // 顺序很重要：最外层的中间件会最先执行，最内层的中间件会最后执行
    // 这里是：loggingMiddleware -> authMiddleware -> finalHandler
    // 也就是请求先经过logging，再经过auth，最后才到finalHandler
    protectedHandler := loggingMiddleware(authMiddleware(http.HandlerFunc(finalHandler)))

    http.Handle("/protected", protectedHandler)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "这是一个公开页面。")
    })

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

运行这段代码，访问http://localhost:8080/会显示公开页面。访问http://localhost:8080/protected则会返回401 Unauthorized，因为缺少X-Auth-Token。如果你用curl添加请求头curl -H "X-Auth-Token: my-secret-token" http://localhost:8080/protected，就能成功访问并看到日志输出。

这种“洋葱圈”式的中间件模式非常灵活，它允许我们将横切关注点（cross-cutting concerns）从核心业务逻辑中分离出来，使得代码更清晰、更易于维护和复用。这是Go在net/http层面实现高级功能的一个非常重要的模式。

Golang HTTP服务如何实现优雅关闭（Graceful Shutdown）？

一个健壮的Web服务，在接收到终止信号（如Ctrl+C）时，不应该立即中断所有正在处理的请求。它应该等待当前正在处理的请求完成，然后才关闭服务器，这就是所谓的“优雅关闭”。net/http包结合Go的context包和os包，可以相对容易地实现这个功能。

当服务器收到中断信号时，我们通常会捕获这个信号，然后给服务器一个“停止”的信号，并设置一个超时时间，让它在规定时间内完成当前任务。

package main

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

func main() {
    // 定义一个简单的HTTP处理函数
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Println("收到请求：", r.URL.Path)
        // 模拟一个耗时操作，比如数据库查询或外部API调用
        time.Sleep(5 * time.Second)
        fmt.Fprintf(w, "Hello, 世界！请求处理完成。")
        log.Println("请求处理完毕：", r.URL.Path)
    })

    // 创建一个HTTP服务器实例
    server := &http.Server{
        Addr:    ":8080",
        Handler: nil, // 使用http.DefaultServeMux
        // 可以设置读写超时，避免恶意连接或网络问题导致资源耗尽
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    // 创建一个通道来接收操作系统的信号
    quit := make(chan os.Signal, 1)
    // 监听SIGINT (Ctrl+C) 和 SIGTERM (终止信号)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)

    // 在一个goroutine中启动HTTP服务器
    go func() {
        fmt.Println("服务器正在监听 http://localhost:8080")
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            // 如果不是正常关闭（ErrServerClosed），则打印错误
            log.Fatalf("服务器启动失败: %s\n", err)
        }
    }()

    // 阻塞主goroutine，直到接收到终止信号
    <-quit
    log.Println("收到终止信号，服务器开始优雅关闭...")

    // 创建一个带有超时限制的上下文
    // 15秒内，服务器必须完成所有未完成的请求并关闭
    ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
    defer cancel() // 确保上下文资源被释放

    // 调用Shutdown方法，它会阻止新的连接，并等待现有连接完成
    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("服务器强制关闭: %s\n", err) // 如果超时，会返回context.DeadlineExceeded
    }

    log.Println("服务器已优雅关闭。")
}

当你运行这段代码，在浏览器中访问http://localhost:8080后，立即在终端按下Ctrl+C。你会发现服务器不会立即退出，而是会等待浏览器中的请求响应完成后（这里模拟了5秒延迟），才会完全关闭。如果等待时间超过了context.WithTimeout设置的15秒，Shutdown方法就会返回错误，服务器会强制关闭。

优雅关闭对于生产环境的服务来说至关重要，它能避免数据丢失、连接中断等问题，确保服务的平滑过渡和高可用性。这是Go标准库在处理并发和系统信号方面的一个出色应用。