Go语言HTTP服务开发
一、HTTP基础
Go语言的net/http包提供了构建HTTP服务的核心功能。
基础HTTP服务
package main import ( "fmt" "net/http" ) func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Hello, World!") } func main() { http.HandleFunc("/", handler) fmt.Println("Server starting on :8080...") err := http.ListenAndServe(":8080", nil) if err != nil { fmt.Printf("Server failed to start: %v\n", err) } }路由处理
package main import ( "fmt" "net/http" ) func homeHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "Home Page") } func aboutHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "About Us") } func userHandler(w http.ResponseWriter, r *http.Request) { // 获取URL路径参数 userID := r.URL.Path[len("/user/"):] fmt.Fprintf(w, "User: %s", userID) } func main() { http.HandleFunc("/", homeHandler) http.HandleFunc("/about", aboutHandler) http.HandleFunc("/user/", userHandler) http.ListenAndServe(":8080", nil) }二、HTTP路由器
使用gorilla/mux
go get github.com/gorilla/muxpackage main import ( "fmt" "net/http" "github.com/gorilla/mux" ) func main() { r := mux.NewRouter() // 基本路由 r.HandleFunc("/", homeHandler) // 参数路由 r.HandleFunc("/users/{id}", userHandler) // 查询参数 r.HandleFunc("/search", searchHandler) // 方法限制 r.HandleFunc("/api/users", createUserHandler).Methods("POST") // 子路由 api := r.PathPrefix("/api").Subrouter() api.HandleFunc("/v1/users", listUsersHandler) http.Handle("/", r) http.ListenAndServe(":8080", nil) } func userHandler(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) userID := vars["id"] fmt.Fprintf(w, "User ID: %s", userID) } func searchHandler(w http.ResponseWriter, r *http.Request) { query := r.URL.Query().Get("q") fmt.Fprintf(w, "Search query: %s", query) }使用chi路由器
go get github.com/go-chi/chi/v5package main import ( "fmt" "net/http" "github.com/go-chi/chi/v5" ) func main() { r := chi.NewRouter() r.Get("/", homeHandler) r.Get("/users/{id}", userHandler) r.Post("/users", createUserHandler) // 中间件 r.Use(loggerMiddleware) r.Use(recoverMiddleware) http.ListenAndServe(":8080", r) } func loggerMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Printf("%s %s\n", r.Method, r.URL.Path) next.ServeHTTP(w, r) }) }三、HTTP请求处理
获取请求参数
func handleRequest(w http.ResponseWriter, r *http.Request) { // 获取URL路径参数 id := r.URL.Path[len("/items/"):] // 获取查询参数 page := r.URL.Query().Get("page") limit := r.URL.Query().Get("limit") // 获取表单数据 err := r.ParseForm() if err != nil { http.Error(w, "Bad request", http.StatusBadRequest) return } username := r.FormValue("username") // 获取JSON请求体 var data struct { Name string `json:"name"` Age int `json:"age"` } err = json.NewDecoder(r.Body).Decode(&data) if err != nil { http.Error(w, "Invalid JSON", http.StatusBadRequest) return } fmt.Fprintf(w, "ID: %s, Page: %s, Limit: %s, Username: %s, Name: %s", id, page, limit, username, data.Name) }响应处理
func jsonResponse(w http.ResponseWriter, data interface{}, status int) { w.Header().Set("Content-Type", "application/json") w.WriteHeader(status) err := json.NewEncoder(w).Encode(data) if err != nil { http.Error(w, "Failed to encode response", http.StatusInternalServerError) } } func getUserHandler(w http.ResponseWriter, r *http.Request) { user := struct { ID int `json:"id"` Name string `json:"name"` Age int `json:"age"` }{ ID: 1, Name: "John", Age: 30, } jsonResponse(w, user, http.StatusOK) } func errorResponse(w http.ResponseWriter, message string, status int) { response := struct { Error string `json:"error"` }{ Error: message, } jsonResponse(w, response, status) }四、中间件
自定义中间件
package main import ( "log" "net/http" "time" ) type responseRecorder struct { http.ResponseWriter statusCode int } func newResponseRecorder(w http.ResponseWriter) *responseRecorder { return &responseRecorder{w, http.StatusOK} } func (r *responseRecorder) WriteHeader(code int) { r.statusCode = code r.ResponseWriter.WriteHeader(code) } func loggingMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { start := time.Now() rr := newResponseRecorder(w) next.ServeHTTP(rr, r) log.Printf( "%s %s %d %s", r.Method, r.URL.Path, rr.statusCode, time.Since(start), ) }) } func authMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { token := r.Header.Get("Authorization") if token == "" { http.Error(w, "Unauthorized", http.StatusUnauthorized) return } // 验证token... if !validateToken(token) { http.Error(w, "Invalid token", http.StatusForbidden) return } next.ServeHTTP(w, r) }) }中间件链
func main() { r := chi.NewRouter() // 全局中间件 r.Use(loggingMiddleware) r.Use(recoverMiddleware) // 特定路由中间件 r.Route("/api", func(r chi.Router) { r.Use(authMiddleware) r.Get("/users", listUsersHandler) r.Post("/users", createUserHandler) }) http.ListenAndServe(":8080", r) }五、静态文件服务
package main import ( "net/http" ) func main() { // 提供静态文件服务 fs := http.FileServer(http.Dir("./static")) http.Handle("/static/", http.StripPrefix("/static/", fs)) // API路由 http.HandleFunc("/api/hello", helloHandler) http.ListenAndServe(":8080", nil) }嵌入静态文件
package main import ( "embed" "net/http" ) //go:embed static/* var staticFS embed.FS func main() { http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.FS(staticFS)))) http.ListenAndServe(":8080", nil) }六、HTTPS配置
package main import ( "fmt" "net/http" ) func handler(w http.ResponseWriter, r *http.Request) { fmt.Fprintf(w, "HTTPS Server") } func main() { // 使用自签名证书 err := http.ListenAndServeTLS(":8443", "cert.pem", "key.pem", nil) if err != nil { fmt.Printf("HTTPS server failed: %v\n", err) } }生成自签名证书
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes七、HTTP客户端
基础请求
package main import ( "fmt" "io/ioutil" "net/http" ) func main() { // GET请求 resp, err := http.Get("https://api.example.com/users") if err != nil { fmt.Printf("Request failed: %v\n", err) return } defer resp.Body.Close() // 读取响应 body, err := ioutil.ReadAll(resp.Body) if err != nil { fmt.Printf("Failed to read response: %v\n", err) return } fmt.Println(string(body)) }自定义客户端
package main import ( "net/http" "time" ) func main() { client := &http.Client{ Timeout: 30 * time.Second, Transport: &http.Transport{ MaxIdleConns: 10, IdleConnTimeout: 30 * time.Second, TLSHandshakeTimeout: 10 * time.Second, }, } resp, err := client.Get("https://api.example.com/users") if err != nil { // 处理错误 } defer resp.Body.Close() }POST请求
package main import ( "bytes" "encoding/json" "net/http" ) func main() { data := map[string]interface{}{ "name": "John", "age": 30, } jsonData, err := json.Marshal(data) if err != nil { // 处理错误 } resp, err := http.Post( "https://api.example.com/users", "application/json", bytes.NewBuffer(jsonData), ) if err != nil { // 处理错误 } defer resp.Body.Close() }八、性能优化
连接池
package main import ( "net/http" "time" ) var client = &http.Client{ Transport: &http.Transport{ MaxIdleConns: 100, MaxIdleConnsPerHost: 10, IdleConnTimeout: 60 * time.Second, }, Timeout: 30 * time.Second, }限流
package main import ( "net/http" "sync/atomic" "time" ) type rateLimiter struct { tokens int64 maxTokens int64 refillRate int64 lastRefill time.Time } func (rl *rateLimiter) allow() bool { now := time.Now() elapsed := now.Sub(rl.lastRefill).Seconds() // 计算应该添加的token数量 tokensToAdd := int64(elapsed * float64(rl.refillRate)) if tokensToAdd > 0 { atomic.AddInt64(&rl.tokens, tokensToAdd) rl.lastRefill = now } // 限制最大token数量 current := atomic.LoadInt64(&rl.tokens) if current > rl.maxTokens { atomic.StoreInt64(&rl.tokens, rl.maxTokens) } // 尝试获取token return atomic.AddInt64(&rl.tokens, -1) >= 0 } func rateLimitMiddleware(next http.Handler) http.Handler { rl := &rateLimiter{ maxTokens: 100, refillRate: 10, // 每秒10个token } return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if !rl.allow() { http.Error(w, "Too many requests", http.StatusTooManyRequests) return } next.ServeHTTP(w, r) }) }九、总结
Go语言的HTTP服务开发具有简洁高效的特点。通过掌握以下要点可以构建可靠的HTTP服务：
- 基础路由：使用net/http包或第三方路由器（gorilla/mux、chi）
- 请求处理：获取路径参数、查询参数、表单数据、JSON请求体
- 响应处理：返回JSON响应、错误处理
- 中间件：日志、认证、限流等中间件
- 静态文件：提供静态资源服务
- HTTPS：配置TLS证书
- HTTP客户端：发起请求、连接池配置
良好的HTTP服务设计应该考虑安全性、性能和可维护性，结合中间件模式可以实现高度可扩展的架构。
