Golang Web 编程：net/http 快速上手

package main

import (
	"encoding/json"
	"log"
	"net/http"
)

func main() {
	mux := http.NewServeMux()

	mux.HandleFunc("GET /healthz", func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
		fmt.Fprintln(w, "ok")
	})

	// JSON API
	mux.HandleFunc("GET /api/users/{id}", func(w http.ResponseWriter, r *http.Request) {
		id := r.PathValue("id")               // go1.22+ 原生路径参数!
		json.NewEncoder(w).Encode(map[string]string{
			"id": id, "name": "zy",
		})
	})

	log.Println("listening :8080")
	log.Fatal(http.ListenAndServe(":8080", mux))
}

curl http://localhost:8080/healthz
curl http://localhost:8080/api/users/42

type CreateUserReq struct {
	Name string `json:"name"`
	Age  int    `json:"age"`
}

mux.HandleFunc("POST /api/users", func(w http.ResponseWriter, r *http.Request) {
	// 1. 解析 JSON body（限制大小防滥用）
	r.Body = http.MaxBytesReader(w, r.Body, 1<<20)   // 1MB
	var req CreateUserReq
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, `{"error":"bad json"}`, http.StatusBadRequest)
		return
	}

	// 2. 校验
	if req.Name == "" {
		http.Error(w, `{"error":"name required"}`, http.StatusUnprocessableEntity)
		return
	}

	// 3. 响应 JSON（统一头）
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(map[string]any{
		"id": 1, "name": req.Name,
	})
})

r.URL.Query().Get("page")          // ?page=2
r.Header.Get("Authorization")      // 请求头
r.PathValue("id")                  // 路径参数
r.RemoteAddr                       // 客户端地址（注意代理场景读 X-Forwarded-For）
r.ParseForm(); r.FormValue("k")    // 表单

type Middleware func(http.Handler) http.Handler

func Chain(h http.Handler, mws ...Middleware) http.Handler {
	for i := len(mws) - 1; i >= 0; i-- {      // 倒序包裹
		h = mws[i](h)
	}
	return h
}

// 日志中间件
func withLogging(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		start := time.Now()
		next.ServeHTTP(w, r)                  // 调用下一层
		log.Printf("%s %s %v", r.Method, r.URL.Path, time.Since(start))
	})
}

// 恢复 panic（保命）
func withRecover(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: %v", err)
				http.Error(w, `{"error":"internal"}`, http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

// 用法
handler := Chain(mux, withLogging, withRecover)
http.ListenAndServe(":8080", handler)

func main() {
	srv := &http.Server{
		Addr:         ":8080",
		Handler:      Chain(mux, withLogging, withRecover),
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 30 * time.Second,
		IdleTimeout:  60 * time.Second,
	}

	go func() {
		if err := srv.ListenAndServe(); err != http.ErrServerClosed {
			log.Fatalf("listen: %v", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGTERM, syscall.SIGINT)
	<-quit                                    // 阻塞等到信号
	log.Println("shutting down...")

	ctx, cancel := context.WithTimeout(context.Background(), 25*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil { // 最多等25s
		log.Printf("forced exit: %v", err)
	}
}

client := &http.Client{Timeout: 5 * time.Second}      // 必设超时!

req, _ := http.NewRequest("GET", "https://api.example.com/v1/x", nil)
req.Header.Set("Authorization", "Bearer "+token)

resp, err := client.Do(req)
if err != nil {
	return fmt.Errorf("call api: %w", err)
}
defer resp.Body.Close()

if resp.StatusCode != http.StatusOK {
	body, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
	return fmt.Errorf("api status %d: %s", resp.StatusCode, body)
}

var result Result
json.NewDecoder(resp.Body).Decode(&result)

import "log/slog"

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
slog.SetDefault(logger)

slog.Info("user created",
	"user_id", 42,
	"ip", r.RemoteAddr,
)
// {"time":"...","level":"INFO","msg":"user created","user_id":42,"ip":"10.0.0.5:3342"}

// chi 风格示例（和标准库无缝）
r := chi.NewRouter()
r.Use(middleware.Logger, middleware.Recoverer)
r.Get("/users/{id}", getUser)
r.Group(func(r chi.Router) {
	r.Use(requireAuth)                    // 一组路由统一加鉴权
	r.Post("/api/users", createUser)
})

go build -o app . && ./app &
wrk -t4 -c200 -d15s http://localhost:8080/healthz
# 单机几十万 QPS 的底子, 超过多数业务需求