Golang 实现 JSend 规范的 JSON 响应格式化

JSend 是一个简单的 JSON 响应格式规范，它定义了成功、失败和错误三种基本响应类型。下面我将介绍如何在 Go 中实现 JSend 规范的响应格式化。

JSend 规范概述

JSend 定义了三种响应类型：

1. 成功 (success): 请求成功处理

   {
     "status": "success",
     "data": {...}
   }
   

2. 失败 (fail): 请求处理失败（客户端错误）

   {
     "status": "fail",
     "data": {...}
   }
   

3. 错误 (error): 请求处理错误（服务器端错误）

   {
     "status": "error",
     "message": "...",
     "code": 500
   }
   

Go 实现

1. 定义结构体

首先定义 JSend 响应结构体：

package jsend

type Response struct {
    Status  string      `json:"status"`
    Data    interface{} `json:"data,omitempty"`
    Message string      `json:"message,omitempty"`
    Code    int         `json:"code,omitempty"`
}

2. 创建构造函数

func Success(data interface{}) *Response {
    return &Response{
        Status: "success",
        Data:   data,
    }
}

func Fail(data interface{}) *Response {
    return &Response{
        Status: "fail",
        Data:   data,
    }
}

func Error(message string, code int, data interface{}) *Response {
    return &Response{
        Status:  "error",
        Message: message,
        Code:    code,
        Data:    data,
    }
}

3. 完整实现

package jsend

import "encoding/json"

// Response represents a JSend-compliant response
type Response struct {
    Status  string      `json:"status"`
    Data    interface{} `json:"data,omitempty"`
    Message string      `json:"message,omitempty"`
    Code    int         `json:"code,omitempty"`
}

// Success creates a success response
func Success(data interface{}) *Response {
    return &Response{
        Status: "success",
        Data:   data,
    }
}

// Fail creates a fail response
func Fail(data interface{}) *Response {
    return &Response{
        Status: "fail",
        Data:   data,
    }
}

// Error creates an error response
func Error(message string, code int, data interface{}) *Response {
    return &Response{
        Status:  "error",
        Message: message,
        Code:    code,
        Data:    data,
    }
}

// ToJSON converts the response to JSON
func (r *Response) ToJSON() ([]byte, error) {
    return json.Marshal(r)
}

// WriteJSON writes the response as JSON to the http.ResponseWriter
func (r *Response) WriteJSON(w http.ResponseWriter) error {
    w.Header().Set("Content-Type", "application/json")
    if r.Code > 0 {
        w.WriteHeader(r.Code)
    }
    return json.NewEncoder(w).Encode(r)
}

4. 使用示例

package main

import (
    "net/http"
    "yourpackage/jsend"
)

func main() {
    http.HandleFunc("/success", func(w http.ResponseWriter, r *http.Request) {
        data := map[string]interface{}{
            "user": map[string]string{
                "name":  "John Doe",
                "email": "john@example.com",
            },
        }
        jsend.Success(data).WriteJSON(w)
    })

    http.HandleFunc("/fail", func(w http.ResponseWriter, r *http.Request) {
        data := map[string]string{
            "email": "Invalid email format",
        }
        jsend.Fail(data).WriteJSON(w)
    })

    http.HandleFunc("/error", func(w http.ResponseWriter, r *http.Request) {
        jsend.Error("Database connection failed", http.StatusInternalServerError, nil).WriteJSON(w)
    })

    http.ListenAndServe(":8080", nil)
}

5. 中间件实现

可以创建一个中间件来统一处理响应：

func JSendMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 创建一个自定义的 ResponseWriter 来捕获响应
        rw := &responseWriter{ResponseWriter: w}
        next.ServeHTTP(rw, r)
        
        // 根据状态码自动转换为 JSend 格式
        if rw.status >= 400 {
            var data interface{}
            if rw.body != nil {
                json.Unmarshal(rw.body, &data)
            }
            
            if rw.status >= 500 {
                jsend.Error(http.StatusText(rw.status), rw.status, data).WriteJSON(w)
            } else {
                jsend.Fail(data).WriteJSON(w)
            }
            return
        }
        
        // 成功响应
        var data interface{}
        if rw.body != nil {
            json.Unmarshal(rw.body, &data)
        }
        jsend.Success(data).WriteJSON(w)
    })
}

type responseWriter struct {
    http.ResponseWriter
    status int
    body   []byte
}

func (rw *responseWriter) WriteHeader(code int) {
    rw.status = code
}

func (rw *responseWriter) Write(b []byte) (int, error) {
    rw.body = b
    return rw.ResponseWriter.Write(b)
}

总结

这个实现提供了：

1. 符合 JSend 规范的响应结构
2. 三种响应类型的便捷构造函数
3. 直接写入 HTTP 响应的功能
4. 可选的中间件支持

你可以根据需要扩展这个实现，比如添加更多的辅助方法或自定义选项。这个实现保持了 JSend 的简洁性，同时提供了足够的灵活性来处理各种 API 响应场景。