引言
Go语言的标准库net/http提供了完善的HTTP服务端和客户端实现，其设计简洁优雅，性能优异，是构建Web服务的主流选择。本文将深入剖析HTTP服务端的核心组件请求处理流程、中间件模式以及客户端使用，并通过实际案例展示如何构建完整的HTTP服务。
一、HTTP服务端核心概念
1.1 最简单的HTTP服务器
package main
import (
"fmt"
"net/http"
)
func main() {
// HandleFunc注册路由处理器
http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, World!")
})
// 监听端口并启动服务
fmt.Println("Server starting on :8080")
if err := http.ListenAndServe(":8080", nil); err != nil {
fmt.Printf("Server error: %v\n", err)
}
}1.2 Handler接口解析
http.Handler是HTTP服务的核心接口：
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}任何实现此接口的类型都可以作为处理器：
package main
import (
"fmt"
"net/http"
)
// 自定义处理器类型
type greetingHandler struct {
prefix string
}
// 实现Handler接口
func (g *greetingHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "%s from custom handler!", g.prefix)
}
type statusHandler struct {
statusCode int
}
func (s *statusHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(s.statusCode)
fmt.Fprintf(w, "Status code: %d", s.statusCode)
}
func main() {
mux := http.NewServeMux()
// 使用自定义处理器
mux.Handle("/hello", &greetingHandler{prefix: "Hello"})
mux.Handle("/status", &statusHandler{statusCode: http.StatusOK})
fmt.Println("Server starting on :8080")
http.ListenAndServe(":8080", mux)
}1.3 ServeMux路由多路复用器
ServeMux是Go内置的路由多路复用器，支持基于模式匹配的分发：
package main
import (
"fmt"
"net/http"
)
func main() {
mux := http.NewServeMux()
// 精确匹配
mux.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "List all users")
})
mux.HandleFunc("/users/", func(w http.ResponseWriter, r *http.Request) {
// 通过Request.URL.Path获取路径
fmt.Fprintf(w, "User ID: %s", r.URL.Path[len("/users/"):])
})
// 使用路径参数模式
mux.HandleFunc("/products/", func(w http.ResponseWriter, r *http.Request) {
parts := r.URL.Path[len("/products/"):]
fmt.Fprintf(w, "Product path: %s", parts)
})
fmt.Println("Server starting on :8080")
http.ListenAndServe(":8080", mux)
}二、请求处理流程与响应构建
2.1 请求对象详解
http.Request包含客户端请求的所有信息：
package main
import (
"encoding/json"
"fmt"
"net/http"
)
func inspectRequest(w http.ResponseWriter, r *http.Request) {
info := map[string]interface{}{
"Method": r.Method,
"URL": r.URL.String(),
"Path": r.URL.Path,
"RawQuery": r.URL.RawQuery,
"Host": r.Host,
"RemoteAddr": r.RemoteAddr,
"Protocol": r.Proto,
"Header": r.Header,
"ContentLength": r.ContentLength,
"TransferEncoding": r.TransferEncoding,
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(info)
}
func main() {
http.HandleFunc("/inspect", inspectRequest)
http.ListenAndServe(":8080", nil)
}2.2 请求体读取
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
)
type User struct {
Name string `json:"name"`
Email string `json:"email"`
}
func readJSONBody(w http.ResponseWriter, r *http.Request) {
// 确保内容类型是JSON
if r.Header.Get("Content-Type") != "application/json" {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, "Expected Content-Type: application/json")
return
}
// 限制请求体大小，防止过大请求
r.Body = http.MaxBytesReader(w, r.Body, 1024*1024) // 1MB限制
defer r.Body.Close()
var user User
decoder := json.NewDecoder(r.Body)
// 支持解析未知字段
decoder.DisallowUnknownFields()
if err := decoder.Decode(&user); err != nil {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, "Invalid JSON: %v", err)
return
}
fmt.Printf("Received user: %+v\n", user)
fmt.Fprintf(w, "User %s (%s) received", user.Name, user.Email)
}
func main() {
http.HandleFunc("/user", readJSONBody)
http.ListenAndServe(":8080", nil)
}2.3 响应构建
package main
import (
"encoding/json"
"fmt"
"net/http"
"time"
)
type Response struct {
Success bool `json:"success"`
Message string `json:"message,omitempty"`
Data interface{} `json:"data,omitempty"`
Error string `json:"error,omitempty"`
}
func writeJSON(w http.ResponseWriter, statusCode int, data interface{}) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(statusCode)
json.NewEncoder(w).Encode(data)
}
func successResponse(w http.ResponseWriter, data interface{}) {
writeJSON(w, http.StatusOK, Response{
Success: true,
Data: data,
})
}
func errorResponse(w http.ResponseWriter, statusCode int, message string) {
writeJSON(w, statusCode, Response{
Success: false,
Error: message,
})
}
func jsonAPI(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case http.MethodGet:
successResponse(w, map[string]interface{}{
"time": time.Now().Unix(),
"message": "GET request successful",
})
case http.MethodPost:
var data map[string]interface{}
if err := json.NewDecoder(r.Body).Decode(&data); err != nil {
errorResponse(w, http.StatusBadRequest, "Invalid JSON")
return
}
successResponse(w, map[string]interface{}{
"received": data,
})
default:
errorResponse(w, http.StatusMethodNotAllowed, "Method not allowed")
}
}
func main() {
http.HandleFunc("/api", jsonAPI)
http.ListenAndServe(":8080", nil)
}2.4 ResponseWriter原理
http.ResponseWriter是一个接口：
type ResponseWriter interface {
Header() Header
Write([]byte) (int, error)
WriteHeader(statusCode int)
}写入顺序很重要：
package main
import (
"fmt"
"net/http"
)
func badExample(w http.ResponseWriter, r *http.Request) {
// 错误：先Write后WriteHeader
w.Write([]byte("Content")) // 隐式调用WriteHeader(200)
w.WriteHeader(http.StatusInternalServerError) // 已经发送了200，这里无效
}
func goodExample(w http.ResponseWriter, r *http.Request) {
// 正确：先WriteHeader后Write
w.WriteHeader(http.StatusOK)
w.Write([]byte("Content"))
}
func main() {
http.HandleFunc("/bad", badExample)
http.HandleFunc("/good", goodExample)
http.ListenAndServe(":8080", nil)
}三、中间件模式实现
3.1 中间件基础
中间件是一个返回http.Handler的函数：
package main
import (
"fmt"
"log"
"net/http"
"time"
)
// 中间件函数签名
type Middleware func(http.Handler) http.Handler
// 日志中间件
func LoggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
// 使用responsewriter的包装器来记录状态码
wrapped := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
next.ServeHTTP(wrapped, r)
log.Printf("%s %s %d %v",
r.Method,
r.URL.Path,
wrapped.statusCode,
time.Since(start))
})
}
type responseWriter struct {
http.ResponseWriter
statusCode int
}
func (rw *responseWriter) WriteHeader(code int) {
rw.statusCode = code
rw.ResponseWriter.WriteHeader(code)
}
func (rw *responseWriter) Write(b []byte) (int, error) {
if rw.statusCode == 0 {
rw.statusCode = http.StatusOK
}
return rw.ResponseWriter.Write(b)
}
// 认证中间件
func AuthMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
token := r.Header.Get("Authorization")
if token == "" {
w.WriteHeader(http.StatusUnauthorized)
fmt.Fprintf(w, "Missing authorization token")
return
}
// 验证token（简化示例）
if !validateToken(token) {
w.WriteHeader(http.StatusUnauthorized)
fmt.Fprintf(w, "Invalid token")
return
}
next.ServeHTTP(wrapped, r)
})
}
func validateToken(token string) bool {
// 实际应该验证JWT或其他token机制
return token == "valid-token-123"
}
func main() {
finalHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Protected resource!")
})
// 组合中间件
handler := LoggingMiddleware(finalHandler)
// handler = AuthMiddleware(handler)
http.Handle("/protected", handler)
http.HandleFunc("/public", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Public resource!")
})
http.ListenAndServe(":8080", nil)
}3.2 中间件链式组合
package main
import (
"fmt"
"log"
"net/http"
"time"
)
type Middleware func(http.Handler) http.Handler
// 链式组合多个中间件
func Chain(h http.Handler, middlewares ...Middleware) http.Handler {
for i := len(middlewares) - 1; i >= 0; i-- {
h = middlewares[i](h)
}
return h
}
// 各个中间件实现
func WithTimeout(timeout time.Duration) Middleware {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
done := make(chan struct{})
go func() {
next.ServeHTTP(w, r)
close(done)
}()
select {
case <-done:
return
case <-time.After(timeout):
log.Printf("Request timeout: %s %s", r.Method, r.URL.Path)
w.WriteHeader(http.StatusGatewayTimeout)
fmt.Fprintf(w, "Request timeout")
}
})
}
}
func WithCORS(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
if r.Method == "OPTIONS" {
w.WriteHeader(http.StatusOK)
return
}
next.ServeHTTP(w, r)
})
}
func WithRecovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
log.Printf("Panic recovered: %v", err)
w.WriteHeader(http.StatusInternalServerError)
fmt.Fprintf(w, "Internal server error")
}
}()
next.ServeHTTP(w, r)
})
}
func mainHandler(w http.ResponseWriter, r *http.Request) {
// 模拟业务逻辑
time.Sleep(100 * time.Millisecond)
fmt.Fprintf(w, "Hello, World!")
}
func main() {
handler := Chain(
http.HandlerFunc(mainHandler),
WithRecovery,
WithCORS,
WithTimeout(5*time.Second),
)
http.Handle("/", handler)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}3.3 第三方中间件框架
实际项目中可以使用negroni等成熟框架：
package main
import (
"fmt"
"log"
"net/http"
"github.com/urfave/negroni"
)
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello from main handler!")
})
n := negroni.New()
// 使用中间件
n.Use(negroni.NewLogger())
n.Use(negroni.NewRecovery())
n.Use(negroni.NewCORS())
// 添加自定义中间件
n.UseFunc(func(rw http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
log.Printf("Before request: %s", r.URL.Path)
next(rw, r)
log.Printf("After request: %s", r.URL.Path)
})
n.UseHandler(mux)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", n))
}四、HTTP客户端使用
4.1 基本客户端请求
package main
import (
"fmt"
"io"
"net/http"
"time"
)
func main() {
// 创建客户端并设置超时
client := &http.Client{
Timeout: 10 * time.Second,
}
// GET请求
resp, err := client.Get("https://api.example.com/data")
if err != nil {
fmt.Printf("GET request failed: %v\n", err)
return
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
fmt.Printf("Read body failed: %v\n", err)
return
}
fmt.Printf("Status: %d\n", resp.StatusCode)
fmt.Printf("Body: %s\n", string(body))
}4.2 设置请求头和自定义请求
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)
func main() {
client := &http.Client{}
// 创建自定义请求
reqBody := map[string]interface{}{
"username": "testuser",
"password": "securepass",
}
jsonBody, _ := json.Marshal(reqBody)
req, err := http.NewRequest("POST", "https://api.example.com/login",
bytes.NewBuffer(jsonBody))
if err != nil {
fmt.Printf("Create request failed: %v\n", err)
return
}
// 设置请求头
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", "MyGoClient/1.0")
req.Header.Set("Accept", "application/json")
// 发送请求
resp, err := client.Do(req)
if err != nil {
fmt.Printf("Request failed: %v\n", err)
return
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Printf("Response: %s\n", string(body))
}4.3 处理Cookies
package main
import (
"fmt"
"net/http"
)
func main() {
client := &http.Client{}
// 第一次请求，获取Cookie
req1, _ := http.NewRequest("GET", "https://example.com/login", nil)
resp1, err := client.Do(req1)
if err != nil {
fmt.Printf("Request 1 failed: %v\n", err)
return
}
cookies := resp1.Cookies()
fmt.Printf("Got %d cookies\n", len(cookies))
resp1.Body.Close()
// 第二次请求，带上Cookie
req2, _ := http.NewRequest("GET", "https://example.com/profile", nil)
for _, cookie := range cookies {
req2.AddCookie(cookie)
fmt.Printf("Cookie: %s=%s\n", cookie.Name, cookie.Value)
}
resp2, err := client.Do(req2)
if err != nil {
fmt.Printf("Request 2 failed: %v\n", err)
return
}
defer resp2.Body.Close()
fmt.Printf("Profile response status: %d\n", resp2.StatusCode)
}五、TCP保活与超时控制
5.1 连接池与复用
package main
import (
"fmt"
"io"
"net/http"
"sync"
"time"
)
// 使用共享的HTTP客户端（包含连接池）
var httpClient = &http.Client{
Transport: &http.Transport{
MaxIdleConns: 100, // 最大空闲连接数
MaxIdleConnsPerHost: 10, // 每个主机最大空闲连接
IdleConnTimeout: 90 * time.Second, // 空闲连接超时
},
Timeout: 30 * time.Second,
}
func fetchURLs(urls []string) []string {
var wg sync.WaitGroup
results := make([]string, len(urls))
var mu sync.Mutex
for i, url := range urls {
wg.Add(1)
go func(idx int, u string) {
defer wg.Done()
resp, err := httpClient.Get(u)
if err != nil {
results[idx] = fmt.Sprintf("Error: %v", err)
return
}
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
mu.Lock()
results[idx] = fmt.Sprintf("%s: %d bytes", u, len(body))
mu.Unlock()
}(i, url)
}
wg.Wait()
return results
}
func main() {
urls := []string{
"https://example.com",
"https://example.org",
"https://example.net",
}
results := fetchURLs(urls)
for _, r := range results {
fmt.Println(r)
}
}5.2 超时控制详解
package main
import (
"context"
"fmt"
"net/http"
"time"
)
func main() {
// 1. 整体客户端超时
client := &http.Client{
Timeout: 5 * time.Second,
}
// 2. 使用Context控制超时
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
req, _ := http.NewRequestWithContext(ctx, "GET", "https://httpbin.org/delay/10", nil)
resp, err := client.Do(req)
if err != nil {
if ctx.Err() == context.DeadlineExceeded {
fmt.Println("Request timed out!")
} else {
fmt.Printf("Request failed: %v\n", err)
}
return
}
defer resp.Body.Close()
fmt.Printf("Response status: %d\n", resp.StatusCode)
}
// 分层超时示例
func layeredTimeoutExample() {
// 创建带有超时的Context
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
// 创建请求
req, _ := http.NewRequestWithContext(ctx, "GET", "https://api.example.com/data", nil)
// 使用http.Transport设置各层超时
transport := &http.Transport{
DialContext: (&net.Dialer{
Timeout: 1 * time.Second, // 连接建立超时
KeepAlive: 30 * time.Second,
}).DialContext,
ResponseHeaderTimeout: 1 * time.Second, // 读取响应头超时
ExpectContinueTimeout: 1 * time.Second,
}
client := &http.Client{
Transport: transport,
}
resp, err := client.Do(req)
if err != nil {
fmt.Printf("Request failed: %v\n", err)
return
}
defer resp.Body.Close()
fmt.Printf("Response status: %d\n", resp.StatusCode)
}六、RESTful API设计原则
6.1 RESTful路由设计
package main
import (
"encoding/json"
"fmt"
"net/http"
"strconv"
"strings"
)
// RESTful资源处理器
type UserHandler struct{}
func (h *UserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
parts := strings.Split(strings.Trim(path, "/"), "/")
// /users - 资源集合
// /users/:id - 单个资源
if len(parts) == 1 && parts[0] == "users" {
switch r.Method {
case http.MethodGet:
h.ListUsers(w, r)
case http.MethodPost:
h.CreateUser(w, r)
}
return
}
if len(parts) == 2 && parts[0] == "users" {
id, err := strconv.Atoi(parts[1])
if err != nil {
http.Error(w, "Invalid user ID", http.StatusBadRequest)
return
}
switch r.Method {
case http.MethodGet:
h.GetUser(w, r, id)
case http.MethodPut:
h.UpdateUser(w, r, id)
case http.MethodDelete:
h.DeleteUser(w, r, id)
}
return
}
http.NotFound(w, r)
}
func (h *UserHandler) ListUsers(w http.ResponseWriter, r *http.Request) {
users := []map[string]interface{}{
{"id": 1, "name": "张三"},
{"id": 2, "name": "李四"},
}
writeJSON(w, http.StatusOK, users)
}
func (h *UserHandler) CreateUser(w http.ResponseWriter, r *http.Request) {
var user map[string]interface{}
if err := json.NewDecoder(r.Body).Decode(&user); err != nil {
http.Error(w, "Invalid JSON", http.StatusBadRequest)
return
}
user["id"] = 3 // 模拟创建
writeJSON(w, http.StatusCreated, user)
}
func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request, id int) {
user := map[string]interface{}{
"id": id,
"name": fmt.Sprintf("User %d", id),
}
writeJSON(w, http.StatusOK, user)
}
func (h *UserHandler) UpdateUser(w http.ResponseWriter, r *http.Request, id int) {
var updates map[string]interface{}
if err := json.NewDecoder(r.Body).Decode(&updates); err != nil {
http.Error(w, "Invalid JSON", http.StatusBadRequest)
return
}
updates["id"] = id
writeJSON(w, http.StatusOK, updates)
}
func (h *UserHandler) DeleteUser(w http.ResponseWriter, r *http.Request, id int) {
writeJSON(w, http.StatusOK, map[string]interface{}{
"message": fmt.Sprintf("User %d deleted", id),
})
}
func writeJSON(w http.ResponseWriter, status int, data interface{}) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(data)
}
func main() {
handler := &UserHandler{}
http.Handle("/users/", handler)
fmt.Println("RESTful API server starting on :8080")
http.ListenAndServe(":8080", nil)
}6.2 错误处理规范
package main
import (
"encoding/json"
"fmt"
"net/http"
)
// RFC 7807 Problem Details for HTTP APIs
type ProblemDetail struct {
Type string `json:"type"`
Title string `json:"title"`
Status int `json:"status"`
Detail string `json:"detail"`
Instance string `json:"instance"`
}
func writeProblem(w http.ResponseWriter, status int, title, detail string) {
problem := ProblemDetail{
Type: fmt.Sprintf("https://example.com/probs/%d", status),
Title: title,
Status: status,
Detail: detail,
Instance: "/users", // 简化
}
w.Header().Set("Content-Type", "application/problem+json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(problem)
}
func userHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet {
writeProblem(w, http.StatusMethodNotAllowed,
"Method Not Allowed",
"Only GET method is supported for this endpoint")
return
}
userID := r.URL.Query().Get("id")
if userID == "" {
writeProblem(w, http.StatusBadRequest,
"Missing Required Parameter",
"The 'id' query parameter is required")
return
}
fmt.Fprintf(w, "User: %s", userID)
}
func main() {
http.HandleFunc("/users", userHandler)
http.ListenAndServe(":8080", nil)
}七、实际案例：构建完整的HTTP服务
7.1 项目结构
myapp/
├── main.go
├── handlers/
│ ├── user.go
│ └── product.go
├── middleware/
│ ├── logging.go
│ └── auth.go
├── models/
│ └── models.go
└── go.mod7.2 完整实现
package main
import (
"context"
"encoding/json"
"fmt"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
)
// ============ 模型定义 ============
type User struct {
ID int `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
}
type Product struct {
ID int `json:"id"`
Name string `json:"name"`
Price float64 `json:"price"`
Quantity int `json:"quantity"`
}
type Order struct {
ID int `json:"id"`
UserID int `json:"user_id"`
Products []Product `json:"products"`
Total float64 `json:"total"`
CreatedAt time.Time `json:"created_at"`
}
type APIResponse struct {
Success bool `json:"success"`
Data interface{} `json:"data,omitempty"`
Error string `json:"error,omitempty"`
Meta *Meta `json:"meta,omitempty"`
}
type Meta struct {
Page int `json:"page,omitempty"`
PageSize int `json:"page_size,omitempty"`
TotalCount int `json:"total_count,omitempty"`
}
// ============ 中间件 ============
type loggingResponseWriter struct {
http.ResponseWriter
statusCode int
size int
}
func (w *loggingResponseWriter) WriteHeader(code int) {
w.statusCode = code
w.ResponseWriter.WriteHeader(code)
}
func (w *loggingResponseWriter) Write(b []byte) (int, error) {
size, err := w.ResponseWriter.Write(b)
w.size += size
return size, err
}
func loggingMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
lrw := &loggingResponseWriter{w, http.StatusOK, 0}
next.ServeHTTP(lrw, r)
log.Printf("[%s] %s %s %d %d bytes %v",
r.Method,
r.URL.Path,
r.RemoteAddr,
lrw.statusCode,
lrw.size,
time.Since(start))
})
}
func recoveryMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
log.Printf("Panic recovered: %v", err)
writeJSON(w, http.StatusInternalServerError, APIResponse{
Success: false,
Error: "Internal server error",
})
}
}()
next.ServeHTTP(w, r)
})
}
func corsMiddleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")
if r.Method == "OPTIONS" {
w.WriteHeader(http.StatusOK)
return
}
next.ServeHTTP(w, r)
})
}
// ============ 处理器 ============
type UserHandler struct {
users []User
}
func NewUserHandler() *UserHandler {
return &UserHandler{
users: []User{
{ID: 1, Name: "张三", Email: "zhangsan@example.com"},
{ID: 2, Name: "李四", Email: "lisi@example.com"},
},
}
}
func (h *UserHandler) ListUsers(w http.ResponseWriter, r *http.Request) {
page, _ := strconv.Atoi(r.URL.Query().Get("page"))
pageSize, _ := strconv.Atoi(r.URL.Query().Get("page_size"))
if page <= 0 {
page = 1
}
if pageSize <= 0 || pageSize > 100 {
pageSize = 10
}
start := (page - 1) * pageSize
end := start + pageSize
if start >= len(h.users) {
writeJSON(w, http.StatusOK, APIResponse{
Success: true,
Data: []User{},
Meta: &Meta{Page: page, PageSize: pageSize, TotalCount: len(h.users)},
})
return
}
if end > len(h.users) {
end = len(h.users)
}
writeJSON(w, http.StatusOK, APIResponse{
Success: true,
Data: h.users[start:end],
Meta: &Meta{Page: page, PageSize: pageSize, TotalCount: len(h.users)},
})
}
func (h *UserHandler) GetUser(w http.ResponseWriter, r *http.Request, id int) {
for _, user := range h.users {
if user.ID == id {
writeJSON(w, http.StatusOK, APIResponse{Success: true, Data: user})
return
}
}
writeJSON(w, http.StatusNotFound, APIResponse{
Success: false,
Error: "User not found",
})
}
type ProductHandler struct {
products []Product
}
func NewProductHandler() *ProductHandler {
return &ProductHandler{
products: []Product{
{ID: 1, Name: "iPhone 15", Price: 7999.00, Quantity: 100},
{ID: 2, Name: "MacBook Pro", Price: 19999.00, Quantity: 50},
},
}
}
func (h *ProductHandler) ListProducts(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, APIResponse{Success: true, Data: h.products})
}
func (h *ProductHandler) GetProduct(w http.ResponseWriter, r *http.Request, id int) {
for _, p := range h.products {
if p.ID == id {
writeJSON(w, http.StatusOK, APIResponse{Success: true, Data: p})
return
}
}
writeJSON(w, http.StatusNotFound, APIResponse{Success: false, Error: "Product not found"})
}
// ============ 辅助函数 ============
func writeJSON(w http.ResponseWriter, status int, resp APIResponse) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(resp)
}
func requireJSON(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("Content-Type") != "application/json" {
writeJSON(w, http.StatusUnsupportedMediaType, APIResponse{
Success: false,
Error: "Content-Type must be application/json",
})
return
}
next(w, r)
}
}
// ============ 路由设置 ============
func setupRoutes(userHandler *UserHandler, productHandler *ProductHandler) *http.ServeMux {
mux := http.NewServeMux()
// 用户路由
mux.HandleFunc("GET /api/users", userHandler.ListUsers)
mux.HandleFunc("GET /api/users/", func(w http.ResponseWriter, r *http.Request) {
idStr := r.URL.Path[len("/api/users/"):]
id, err := strconv.Atoi(idStr)
if err != nil {
writeJSON(w, http.StatusBadRequest, APIResponse{Success: false, Error: "Invalid user ID"})
return
}
userHandler.GetUser(w, r, id)
})
// 产品路由
mux.HandleFunc("GET /api/products", productHandler.ListProducts)
mux.HandleFunc("GET /api/products/", func(w http.ResponseWriter, r *http.Request) {
idStr := r.URL.Path[len("/api/products/"):]
id, err := strconv.Atoi(idStr)
if err != nil {
writeJSON(w, http.StatusBadRequest, APIResponse{Success: false, Error: "Invalid product ID"})
return
}
productHandler.GetProduct(w, r, id)
})
// 健康检查
mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
writeJSON(w, http.StatusOK, APIResponse{Success: true, Data: map[string]string{"status": "healthy"}})
})
return mux
}
// ============ 主函数 ============
import (
"strconv"
)
func main() {
userHandler := NewUserHandler()
productHandler := NewProductHandler()
mux := setupRoutes(userHandler, productHandler)
// 创建服务器
server := &http.Server{
Addr: ":8080",
Handler: chainHandlers(mux, recoveryMiddleware, loggingMiddleware, corsMiddleware),
ReadTimeout: 10 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 60 * time.Second,
}
// 启动服务器到Goroutine
go func() {
log.Println("Server starting on :8080")
if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
log.Fatalf("Server failed: %v", err)
}
}()
// 优雅关闭
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
log.Println("Shutting down server...")
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
log.Fatalf("Server forced to shutdown: %v", err)
}
log.Println("Server exited properly")
}
func chainHandlers(h http.Handler, middlewares ...func(http.Handler) http.Handler) http.Handler {
for i := len(middlewares) - 1; i >= 0; i-- {
h = middlewares[i](h)
}
return h
}总结
本文全面介绍了Go语言net/http包的Web开发能力：
-
Handler与ServeMux ：理解
http.Handler接口和ServeMux路由多路复用器是构建HTTP服务的基础。 -
请求处理流程 ：深入理解
http.Request和http.ResponseWriter的工作原理，正确处理请求和构建响应。 -
中间件模式：掌握中间件函数签名和链式组合方式，实现日志、认证、限流等功能。
-
HTTP客户端 ：使用
http.Client进行HTTP请求，注意连接池和超时控制。 -
性能优化：合理设置TCP保活、超时控制、连接池参数以提升服务性能。
-
RESTful设计：遵循REST原则设计清晰的API接口。
-
工程实践：完整的HTTP服务需要考虑中间件链、优雅关闭、健康检查等生产级特性。
Go的net/http包设计简洁但功能完善，足以应对大多数Web开发场景。深入理解其底层原理，才能构建高性能、稳定的Web服务。