下面给出一次完整的重构，将原始 net/http 裸处理与共享可变全局状态的代码，升级为使用 Gin、服务层与依赖注入、严格 JSON 反序列化、slog 结构化日志、显式上下文与超时、统一响应格式的可扩展 Web 服务。同时在末尾标注所有更改点与带来的好处。
重构后示例工程结构（可直接粘贴为多文件；如需单文件演示，也可合并）：
- cmd/server/main.go
- internal/http/middleware/requestid.go
- internal/http/handlers.go
- internal/user/model.go
- internal/user/repo.go
- internal/user/memory_repo.go
- internal/user/service.go
- internal/http/response.go
- internal/http/decoder.go
- internal/http/router.go
- internal/user/service_test.go
- internal/user/bench_test.go
代码如下：
// cmd/server/main.go
package main
import (
"context"
"log/slog"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"github.com/gin-gonic/gin"
"example/internal/http/middleware"
httpx "example/internal/http"
"example/internal/user"
)
func main() {
// 1) 结构化日志（JSON），区分等级
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
Level: slog.LevelInfo,
}))
// 2) 构建依赖（服务层），替换全局状态
repo := user.NewInMemoryRepo() // 可替换为持久化后端实现
svc := user.NewService(repo, logger) // 依赖注入
router := buildRouter(svc, logger) // 组合路由与中间件
// 3) 启动带超时的 HTTP 服务器
srv := &http.Server{
Addr: ":8080",
Handler: router,
ReadTimeout: 5 * time.Second,
ReadHeaderTimeout: 3 * time.Second,
WriteTimeout: 10 * time.Second,
IdleTimeout: 60 * time.Second,
}
logger.Info("server starting", slog.String("addr", srv.Addr))
// 4) 优雅关闭：监听信号并用 context 超时
go func() {
if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
logger.Error("server listen failed", slog.String("err", err.Error()))
}
}()
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
logger.Error("server shutdown failed", slog.String("err", err.Error()))
}
logger.Info("server stopped")
}
func buildRouter(svc *user.Service, logger *slog.Logger) *gin.Engine {
// 5) Gin 路由与中间件
r := gin.New()
r.Use(gin.Recovery())
r.Use(middleware.RequestID()) // 请求ID注入
r.Use(middleware.Slog(logger)) // 请求级别结构化日志
// 健康检查
r.GET("/healthz", func(c *gin.Context) {
httpx.JSON(c, http.StatusOK, "ok", gin.H{"uptime": "unknown"})
})
// 用户路由
h := httpx.NewUserHandlers(svc)
r.GET("/users", h.ListUsers)
r.POST("/users", h.CreateUser)
return r
}
// internal/http/middleware/requestid.go
package middleware
import (
"crypto/rand"
"encoding/hex"
"net/http"
"github.com/gin-gonic/gin"
)
const HeaderRequestID = "X-Request-ID"
const CtxRequestIDKey = "request_id"
func RequestID() gin.HandlerFunc {
return func(c *gin.Context) {
id := c.GetHeader(HeaderRequestID)
if id == "" {
buf := make([]byte, 16)
_, _ = rand.Read(buf)
id = hex.EncodeToString(buf)
}
// 设置头与上下文
c.Writer.Header().Set(HeaderRequestID, id)
c.Set(CtxRequestIDKey, id)
c.Next()
}
}
// internal/http/middleware/slog.go
package middleware
import (
"log/slog"
"github.com/gin-gonic/gin"
)
func Slog(base *slog.Logger) gin.HandlerFunc {
return func(c *gin.Context) {
reqID, _ := c.Get(CtxRequestIDKey)
// 将请求ID附着到日志
logger := base.With(slog.String("request_id", reqID.(string)))
c.Set("logger", logger)
logger.Info("request started",
slog.String("method", c.Request.Method),
slog.String("path", c.Request.URL.Path),
)
c.Next()
logger.Info("request finished",
slog.Int("status", c.Writer.Status()),
slog.Int("bytes", c.Writer.Size()),
)
}
}
// internal/user/model.go
package user
import "time"
type User struct {
ID string json:"id"
Data string json:"data"
CreatedAt time.Time json:"created_at"
}
// CreateUserPayload 用于严格反序列化
type CreateUserPayload struct {
Data string json:"data"
}
// internal/user/repo.go
package user
import "context"
//go:generate mockgen -destination=mock_user_repo_test.go -package=user . UserRepository
type UserRepository interface {
Create(ctx context.Context, u User) (User, error)
List(ctx context.Context) ([]User, error)
}
// internal/user/memory_repo.go
package user
import (
"context"
"strconv"
"sync"
"time"
)
type InMemoryRepo struct {
mu sync.RWMutex
store map[string]User
}
func NewInMemoryRepo() *InMemoryRepo {
return &InMemoryRepo{
store: make(map[string]User),
}
}
func (r *InMemoryRepo) Create(ctx context.Context, u User) (User, error) {
// 生成ID（如需更强保证可改用 UUID/ULID）
u.ID = strconv.FormatInt(time.Now().UnixNano(), 10)
u.CreatedAt = time.Now().UTC()
// 支持取消
select {
case <-ctx.Done():
return User{}, ctx.Err()
default:
}
r.mu.Lock()
r.store[u.ID] = u
r.mu.Unlock()
return u, nil
}
func (r *InMemoryRepo) List(ctx context.Context) ([]User, error) {
select {
case <-ctx.Done():
return nil, ctx.Err()
default:
}
r.mu.RLock()
defer r.mu.RUnlock()
out := make([]User, 0, len(r.store))
for _, u := range r.store {
out = append(out, u)
}
return out, nil
}
// internal/user/service.go
package user
import (
"context"
"errors"
"log/slog"
"strings"
)
type Service struct {
repo UserRepository
logger *slog.Logger
}
func NewService(repo UserRepository, logger *slog.Logger) *Service {
return &Service{repo: repo, logger: logger}
}
func (s *Service) CreateUser(ctx context.Context, data string) (User, error) {
data = strings.TrimSpace(data)
if data == "" {
return User{}, errors.New("data must not be empty")
}
u := User{Data: data}
created, err := s.repo.Create(ctx, u)
if err != nil {
s.logger.Error("create user failed", slog.String("err", err.Error()))
return User{}, err
}
s.logger.Info("user created", slog.String("id", created.ID))
return created, nil
}
func (s *Service) ListUsers(ctx context.Context) ([]User, error) {
users, err := s.repo.List(ctx)
if err != nil {
s.logger.Error("list users failed", slog.String("err", err.Error()))
return nil, err
}
return users, nil
}
// internal/http/response.go
package httpx
import (
"net/http"
"github.com/gin-gonic/gin"
)
type APIResponse struct {
RequestID string json:"request_id"
Code int json:"code"
Message string json:"message"
Data interface{} json:"data,omitempty"
}
func JSON(c *gin.Context, status int, message string, data interface{}) {
reqID, _ := c.Get("request_id")
c.JSON(status, APIResponse{
RequestID: reqID.(string),
Code: status,
Message: message,
Data: data,
})
}
func Error(c *gin.Context, status int, message string, err error) {
if err != nil && message == "" {
message = err.Error()
}
JSON(c, status, message, nil)
}
// internal/http/decoder.go
package httpx
import (
"encoding/json"
"errors"
"net/http"
"github.com/gin-gonic/gin"
)
const MaxBodyBytes = 1 << 20 // 1MB
// DecodeStrict 使用 DisallowUnknownFields 并限制体积
func DecodeStrict[T any](c *gin.Context, dst *T) error {
r := http.MaxBytesReader(c.Writer, c.Request.Body, MaxBodyBytes)
defer r.Close()
dec := json.NewDecoder(r)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
return err
}
// 禁止多余内容（如多对象拼接）
if dec.More() {
return errors.New("unexpected extra JSON content")
}
return nil
}
// internal/http/handlers.go
package httpx
import (
"net/http"
"github.com/gin-gonic/gin"
"example/internal/user"
)
type UserHandlers struct {
svc *user.Service
}
func NewUserHandlers(svc *user.Service) *UserHandlers {
return &UserHandlers{svc: svc}
}
// GET /users
func (h *UserHandlers) ListUsers(c *gin.Context) {
users, err := h.svc.ListUsers(c.Request.Context())
if err != nil {
Error(c, http.StatusInternalServerError, "failed to list users", err)
return
}
JSON(c, http.StatusOK, "ok", users)
}
// POST /users
func (h *UserHandlers) CreateUser(c *gin.Context) {
// 严格解码
var p user.CreateUserPayload
if err := DecodeStrict(c, &p); err != nil {
Error(c, http.StatusBadRequest, "invalid JSON payload", err)
return
}
u, err := h.svc.CreateUser(c.Request.Context(), p.Data)
if err != nil {
Error(c, http.StatusBadRequest, "failed to create user", err)
return
}
JSON(c, http.StatusCreated, "created", u)
}
// internal/http/router.go
// （可选：已在 main 中内联了，此文件可省略）
// internal/user/service_test.go
package user
import (
"context"
"log/slog"
"os"
"testing"
"time"
)
func TestService_CreateAndList(t *testing.T) {
svc := NewService(NewInMemoryRepo(), slog.New(slog.NewTextHandler(os.Stdout, nil)))
// 正常创建
u, err := svc.CreateUser(context.Background(), "hello")
if err != nil {
t.Fatalf("CreateUser error: %v", err)
}
if u.ID == "" || u.Data != "hello" {
t.Fatalf("unexpected user: %+v", u)
}
// 并发创建
n := 100
errCh := make(chan error, n)
for i := 0; i < n; i++ {
go func(i int) {
_, e := svc.CreateUser(context.Background(), "d"+string(rune('A'+(i%26))))
errCh <- e
}(i)
}
for i := 0; i < n; i++ {
if e := <-errCh; e != nil {
t.Fatalf("concurrent create error: %v", e)
}
}
// 列表
users, err := svc.ListUsers(context.Background())
if err != nil {
t.Fatalf("ListUsers error: %v", err)
}
if len(users) < n+1 {
t.Fatalf("expected at least %d users, got %d", n+1, len(users))
}
// 超时/取消
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Nanosecond)
defer cancel()
_, err = svc.CreateUser(ctx, "delayed")
if err == nil {
t.Fatalf("expected context error, got nil")
}
}
// internal/user/bench_test.go
package user
import (
"context"
"log/slog"
"os"
"testing"
)
func BenchmarkService_CreateUser(b *testing.B) {
svc := NewService(NewInMemoryRepo(), slog.New(slog.NewTextHandler(os.Stdout, nil)))
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
_, _ = svc.CreateUser(context.Background(), "payload")
}
})
}
更改与好处说明（映射到你的10点要求）：
-
使用 Gin 路由与中间件，替换 net/http 裸处理
- 更改：main 中使用 gin.New、路由定义 GET/POST /users、Recovery 中间件。
- 好处：更易扩展的路由、中间件生态、统一错误恢复。
-
用户数据抽象为结构体与接口，移除字符串 map 及裸锁，采用服务层与依赖注入的构造函数
- 更改：User struct、UserRepository 接口、InMemoryRepo 实现、Service 封装业务逻辑与验证。
- 好处：清晰的分层与可替换的存储后端，便于测试与演进。
-
使用 context 传递请求范围与超时，避免阻塞与资源泄露
- 更改：Service 与 Repo 方法均接收 context；HTTP 服务器设置读写超时；优雅关闭使用 context 超时。
- 好处：支持取消、避免长时间阻塞、提升可靠性。
-
采用 json.Decoder 并 DisallowUnknownFields，严格反序列化与错误返回
- 更改：DecodeStrict 使用 json.NewDecoder + DisallowUnknownFields，并限制 MaxBodyBytes。
- 好处：防止悄然忽略未知字段与超大请求，提升安全性与可维护性。
-
使用 slog 进行结构化日志，区分 info/error 并带请求ID
- 更改：slog JSON handler；RequestID 中间件；Slog 中间件将 request_id 注入日志。
- 好处：可观测性提升，便于排查问题与关联请求。
-
替换 ioutil 为 io 与 net/http 标准库新接口
- 更改：不再使用 ioutil.ReadAll；使用 http.MaxBytesReader + json.Decoder。
- 好处：符合现代 Go 标准库实践，避免弃用 API。
-
返回明确 HTTP 状态码与错误信息，统一响应格式
- 更改：APIResponse 统一格式；Error/JSON 帮助函数输出标准化响应。
- 好处：前后端约定清晰、易于消费与监控。
-
如果需要并发写入，考虑 channel 或 sync.Map，或持久化后端
- 更改：InMemoryRepo 使用 map+RWMutex；可替换为 sync.Map 或数据库实现（接口已抽象）。
- 好处：线程安全；通过接口可平滑迁移到持久化后端。
-
编写单元测试与基准测试，覆盖并发与错误场景
- 更改：service_test 覆盖并发创建、取消与错误；bench_test 基准测试并发创建。
- 好处：保证正确性与性能，为重构与优化提供回归保障。
-
模块化包结构，并使用 go:generate 生成 Mock 以提升测试效率
- 更改：按 internal/{user,http} 模块化；在 repo.go 添加 go:generate mockgen 指令。
- 好处：清晰的包边界、可生成仓储层 mock 做隔离测试，提升测试效率。
迁移与运行说明：
- 初始化模块：go mod init example
- 拉取依赖：go get github.com/gin-gonic/gin
- 可选（生成 mock）：go install github.com/golang/mock/mockgen@latest；在 internal/user 运行 go generate
- 运行：go run ./cmd/server
- 测试与基准：go test ./... -race；go test -bench=. ./internal/user
此重构将原本“共享可变全局状态 + 忽略错误”的示例，升级为面向生产的可扩展 Web 服务骨架，具备严格输入校验、结构化日志、上下文与超时控制、统一响应格式、并发安全与可测试性。
