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服务，核心就那么几步：
- 定义处理器函数（Handler function）：这是你的服务收到请求后会执行的逻辑。它接收两个参数：
http.ResponseWriter
用来写响应，
*http.Request
用来读请求。
- 注册路径与处理器：通过
http.HandleFunc
把你的处理器函数和特定的URL路径关联起来。
- 启动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语言免费学习笔记（深入）”；
如何在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
来处理这种致命错误，因为它会打印错误信息并退出程序。在生产环境中，这可能还需要结合一些进程守护工具来自动重启服务。这些细节，虽然在“基础用法”里可能不会被提及太多，但当你真的要把服务跑起来的时候，它们就会变得非常重要了。
评论（已关闭）
评论已关闭