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来处理这种致命错误，因为它会打印错误信息并退出程序。在生产环境中，这可能还需要结合一些进程守护工具来自动重启服务。这些细节，虽然在“基础用法”里可能不会被提及太多，但当你真的要把服务跑起来的时候，它们就会变得非常重要了。
