Go JSON API 入门：Handler、请求解析和统一响应怎么组织

{
  "title": "整理 Go 学习笔记",
  "priority": 2
}

type CreateTaskRequest struct {
	Title    string `json:"title"`
	Priority int    `json:"priority"`
}

type TaskResponse struct {
	ID       int64  `json:"id"`
	Title    string `json:"title"`
	Priority int    `json:"priority"`
	Done     bool   `json:"done"`
}

func decodeJSON(w http.ResponseWriter, r *http.Request, dst any) error {
	r.Body = http.MaxBytesReader(w, r.Body, 1<<20) // 1 MB
	defer r.Body.Close()

	dec := json.NewDecoder(r.Body)
	dec.DisallowUnknownFields()
	if err := dec.Decode(dst); err != nil {
		return err
	}
	return nil
}

func (r CreateTaskRequest) Validate() error {
	if strings.TrimSpace(r.Title) == "" {
		return errors.New("title is required")
	}
	if r.Priority < 1 || r.Priority > 5 {
		return errors.New("priority must be between 1 and 5")
	}
	return nil
}

func TestCreateTaskRequestValidate(t *testing.T) {
	req := CreateTaskRequest{Title: "", Priority: 2}
	if err := req.Validate(); err == nil {
		t.Fatal("expected error")
	}
}

type TaskService interface {
	Create(ctx context.Context, input CreateTaskInput) (Task, error)
}

type CreateTaskInput struct {
	Title    string
	Priority int
}

type TaskHandler struct {
	service TaskService
}

func (h *TaskHandler) Create(w http.ResponseWriter, r *http.Request) {
	var req CreateTaskRequest
	if err := decodeJSON(w, r, &req); err != nil {
		writeError(w, http.StatusBadRequest, "invalid_json", "请求 JSON 格式不正确")
		return
	}
	if err := req.Validate(); err != nil {
		writeError(w, http.StatusBadRequest, "invalid_request", err.Error())
		return
	}

	task, err := h.service.Create(r.Context(), CreateTaskInput{
		Title:    strings.TrimSpace(req.Title),
		Priority: req.Priority,
	})
	if err != nil {
		writeError(w, http.StatusInternalServerError, "create_failed", "创建任务失败")
		return
	}

	writeJSON(w, http.StatusCreated, TaskResponse{
		ID:       task.ID,
		Title:    task.Title,
		Priority: task.Priority,
		Done:     task.Done,
	})
}

func writeJSON(w http.ResponseWriter, status int, value any) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	w.WriteHeader(status)
	if err := json.NewEncoder(w).Encode(value); err != nil {
		log.Printf("write json response: %v", err)
	}
}

type ErrorResponse struct {
	Error ErrorBody `json:"error"`
}

type ErrorBody struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

func writeError(w http.ResponseWriter, status int, code, message string) {
	writeJSON(w, status, ErrorResponse{
		Error: ErrorBody{Code: code, Message: message},
	})
}

type fakeTaskService struct {
	task Task
	err  error
}

func (f fakeTaskService) Create(ctx context.Context, input CreateTaskInput) (Task, error) {
	return f.task, f.err
}

func TestCreateTask(t *testing.T) {
	h := &TaskHandler{service: fakeTaskService{
		task: Task{ID: 1, Title: "写测试", Priority: 2},
	}}

	body := strings.NewReader(`{"title":"写测试","priority":2}`)
	req := httptest.NewRequest(http.MethodPost, "/tasks", body)
	rec := httptest.NewRecorder()

	h.Create(rec, req)

	if rec.Code != http.StatusCreated {
		t.Fatalf("status = %d", rec.Code)
	}
	if !strings.Contains(rec.Body.String(), `"id":1`) {
		t.Fatalf("body = %s", rec.Body.String())
	}
}

func recovery(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, "internal error", http.StatusInternalServerError)
            }
        }()
        next.ServeHTTP(w, r)
    })
}

func customMux() *http.ServeMux {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if r.URL.Path != "/" {
            writeError(w, http.StatusNotFound, "not_found", "resource not found")
            return
        }
        // handle root
    })
    return mux
}

func requestID(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        id := r.Header.Get("X-Request-ID")
        if id == "" {
            id = generateID()
        }
        w.Header().Set("X-Request-ID", id)
        ctx := context.WithValue(r.Context(), requestIDKey{}, id)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func negotiateContentType(r *http.Request) string {
    accept := r.Header.Get("Accept")
    if strings.Contains(accept, "application/json") {
        return "json"
    }
    if strings.Contains(accept, "text/csv") {
        return "csv"
    }
    return "json"
}