Golang搭建HTTP服务，net/http基础教程

Go语言通过net/http包可快速构建HTTP服务，核心步骤为：定义处理器函数处理请求、使用http.HandleFunc注册路由、调用http.ListenAndServe启动服务。处理器通过检查r.Method区分GET、POST等请求方法，利用r.URL.Query()获取查询参数，读取r.Body获取请求体。可通过实现http.Handler接口的ServeHTTP方法创建带状态的自定义处理器，便于复用和模块化。错误处理需返回恰当状态码，如http.Error(w, msg, code)或手动设置WriteHeader，确保API健壮性。

在Go语言里构建一个HTTP服务，说实话，比我想象中要直接得多。你不需要引入什么复杂的框架，标准库的net/http包就提供了所有你起步所需的基础能力。它的设计理念很Go：简洁、高效，而且非常实用，让你能快速搭建起一个能响应请求的Web服务。

解决方案

要用net/http包跑一个HTTP服务，核心就那么几步：

1. 定义处理器函数（Handler Function）：这是你的服务收到请求后会执行的逻辑。它接收两个参数：http.ResponseWriter用来写响应，*http.Request用来读请求。
2. 注册路径与处理器：通过http.HandleFunc把你的处理器函数和特定的URL路径关联起来。
3. 启动HTTP服务器：调用http.ListenAndServe，指定监听的地址和端口。

来看个最简单的例子：

package main

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

// homeHandler 是一个简单的HTTP处理器函数
func homeHandler(w http.ResponseWriter, r *http.Request) {
    // 检查请求路径，确保只响应根路径
    if r.URL.Path != "/" {
        http.NotFound(w, r) // 返回404
        return
    }
    fmt.Fprintf(w, "Hello, Go HTTP!") // 向客户端写入响应
}

func main() {
    // 注册处理器函数，将根路径"/"的请求交给homeHandler处理
    http.HandleFunc("/", homeHandler)

    // 启动HTTP服务器，监听8080端口
    // ListenAndServe会阻塞，直到服务器停止或出错
    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", nil) // nil表示使用默认的多路复用器DefaultServeMux
    if err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

这段代码跑起来，访问http://localhost:8080，你就能看到"Hello, Go HTTP!"了。http.ListenAndServe的第二个参数是http.Handler接口，传nil就意味着它会使用http.DefaultServeMux，而http.HandleFunc正是往这个默认的多路复用器里注册路由的。这个设计，初看可能有点绕，但用起来确实方便。

如何在Go的HTTP服务中处理不同类型的请求？

当你构建一个API或者一个复杂的Web应用时，仅仅响应一个固定路径是不够的。HTTP请求有不同的方法（GET、POST、PUT、DELETE等），还有各种参数（查询参数、请求体、Header）。在Go的net/http处理器里，这些信息都在*http.Request这个结构体里。

要区分请求方法，最直接的方式就是检查r.Method字段：

package main

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

// userHandler 处理 /user 路径的请求
func userHandler(w http.ResponseWriter, r *http.Request) {
    switch r.Method {
    case "GET":
        // 处理GET请求，通常用于获取资源
        userID := r.URL.Query().Get("id") // 获取查询参数，例如 /user?id=123
        if userID == "" {
            http.Error(w, "User ID is required", http.StatusBadRequest)
            return
        }
        fmt.Fprintf(w, "Fetching user with ID: %s", userID)

    case "POST":
        // 处理POST请求，通常用于创建资源
        // 读取请求体，例如JSON数据
        body, err := ioutil.ReadAll(r.Body) // 注意：生产环境应限制body大小
        if err != nil {
            http.Error(w, "Failed to read request body", http.StatusInternalServerError)
            return
        }
        defer r.Body.Close() // 养成关闭Body的习惯

        // 假设请求体是简单的文本
        fmt.Fprintf(w, "Creating user with data: %s", string(body))

    default:
        // 不支持的方法
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

func main() {
    http.HandleFunc("/user", userHandler)
    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

这里我稍微展开了一下，r.URL.Query().Get("id")可以方便地获取URL中的查询参数。而对于POST请求，你需要从r.Body中读取数据。记住，r.Body是一个io.Reader，读完后最好关闭它。这种基于switch r.Method的模式非常常见，虽然有时候会把一个handler搞得有点大，但对于简单到中等复杂度的逻辑来说，它足够清晰了。

Go的HTTP处理器（Handler）接口：自定义与复用

http.HandleFunc虽然好用，但它背后其实是Go的http.Handler接口在起作用。这个接口只有一个方法：ServeHTTP(w http.ResponseWriter, r *http.Request)。任何实现了这个接口的类型，都可以作为一个HTTP处理器。

这意味着什么呢？你可以定义自己的结构体，让它拥有一些状态（比如数据库连接、配置信息），然后让这个结构体实现ServeHTTP方法。这样，你的处理器就不再是无状态的函数，而是可以携带上下文信息的“对象”了。这对于构建更模块化、可复用的组件非常有用。

举个例子：

package main

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

// MyCustomHandler 结构体，可以携带一些配置信息
type MyCustomHandler struct {
    Greeting string
}

// ServeHTTP 实现http.Handler接口
func (h *MyCustomHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "%s, from a custom handler!", h.Greeting)
}

func main() {
    // 创建一个自定义处理器的实例，并传入问候语
    customHandler := &MyCustomHandler{Greeting: "Hello Go"}

    // 使用http.Handle注册，而不是http.HandleFunc
    // http.Handle接收一个http.Handler接口的实例
    http.Handle("/custom", customHandler)

    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

通过http.Handle而不是http.HandleFunc来注册，你就可以传入一个实现了http.Handler接口的实例。这种方式的好处在于，你可以把一些通用的逻辑或者共享的资源封装到这个结构体里，避免全局变量或者闭包带来的潜在问题。它让你的代码更“面向对象”一些，虽然Go不是严格意义上的OOP语言，但这种模式确实提供了类似的封装能力。我个人觉得，当你需要处理一些共享资源或者想把某些逻辑抽象出来的时候，这种方式就显得特别有用了。

构建健壮的HTTP服务：错误处理与状态码

在实际项目中，没有哪个服务能保证永远不犯错。所以，如何优雅地处理错误，并返回给客户端明确的状态码，是构建健壮HTTP服务不可或缺的一环。Go的net/http包在这方面提供了很好的支持。

当你的处理器逻辑出错时，你不应该仅仅打印一个日志就完事，更重要的是要告诉客户端发生了什么。http.ResponseWriter提供了WriteHeader(statusCode int)方法来设置HTTP状态码，以及Error(w http.ResponseWriter, error string, code int)这个便捷函数来发送错误响应。

比如，当用户请求的资源不存在时：

package main

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

// resourceHandler 处理资源请求
func resourceHandler(w http.ResponseWriter, r *http.Request) {
    resourceID := r.URL.Query().Get("id")
    if resourceID == "" {
        // 参数缺失，返回400 Bad Request
        http.Error(w, "Resource ID is required", http.StatusBadRequest)
        return
    }

    // 模拟资源查找
    if resourceID == "nonexistent" {
        // 资源不存在，返回404 Not Found
        http.Error(w, "Resource not found", http.StatusNotFound)
        return
    }

    // 模拟内部服务器错误
    if resourceID == "error" {
        // 内部错误，返回500 Internal Server Error
        log.Printf("Internal error processing resource ID %s", resourceID) // 记录日志
        http.Error(w, "Internal server error", http.StatusInternalServerError)
        return
    }

    fmt.Fprintf(w, "Successfully retrieved resource: %s", resourceID)
}

func main() {
    http.HandleFunc("/resource", resourceHandler)
    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatalf("Server failed to start: %v", err)
    }
}

我发现很多新手，包括我自己刚开始的时候，都容易忽略错误处理和状态码的设置。但这是衡量一个API是否专业的关键点。http.Error是个很方便的快捷函数，它会自动设置Content-Type为text/plain并写入错误信息。当然，你也可以手动w.WriteHeader()然后fmt.Fprint()写入更复杂的错误响应体（比如JSON格式的错误信息），这取决于你的API设计。

另一个需要考虑的是，如果服务器启动失败怎么办？http.ListenAndServe会返回一个error。通常我们会用log.Fatalf来处理这种致命错误，因为它会打印错误信息并退出程序。在生产环境中，这可能还需要结合一些进程守护工具来自动重启服务。这些细节，虽然在“基础用法”里可能不会被提及太多，但当你真的要把服务跑起来的时候，它们就会变得非常重要了。