Go语言中正确发送和接收JSON数据：避免fmt.Fprint陷阱

引言：Go语言中处理JSON的常见场景

在go语言中构建web服务或api时，json作为一种轻量级的数据交换格式被广泛应用。服务器通常需要将go结构体编码为json字符串发送给客户端，而客户端则需要接收并解码这些json数据。虽然go标准库提供了强大的encoding/json包来处理json的编解码，但在实际操作中，尤其是在将编码后的json字节写入http响应时，开发者可能会遇到一些意想不到的问题。

问题重现：Go服务器发送JSON，客户端解码失败

考虑一个典型的场景：Go服务器接收到客户端的请求后，构造一个Go结构体，将其编码为JSON，并通过http.ResponseWriter发送回客户端。客户端接收到响应后，尝试解码该JSON。

以下是原始服务器端的关键代码片段，展示了如何编码JSON并尝试发送：

// Message 结构体定义 (假设在服务器和客户端都存在)
type ClientId int
type Message struct {
    What     int `json:"What"`
    Tag      int `json:"Tag"`
    Id       int `json:"Id"`
    ClientId ClientId `json:"ClientId"`
    X        int `json:"X"`
    Y        int `json:"Y"`
}

// Join 方法处理客户端的连接请求
func (network *Network) Join(
    w http.ResponseWriter,
    r *http.Request) {
    log.Println("client wants to join")
    message := Message{-1, -1, -1, ClientId(len(network.Clients)), -1, -1}
    var buffer bytes.Buffer
    enc := json.NewEncoder(&buffer)

    err := enc.Encode(message)
    if err != nil {
        fmt.Println("error encoding the response to a join request")
        log.Fatal(err)
    }

    fmt.Printf("the json: %s\n", buffer.Bytes()) // 用于调试输出
    fmt.Fprint(w, buffer.Bytes()) // **问题所在**：使用 fmt.Fprint 发送字节切片
}

客户端代码则相对直接，它发送一个GET请求，并尝试解码响应：

func main() {
    var clientId ClientId
    var message Message
    resp, err := http.Get("http://localhost:5000/join")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close() // 确保关闭响应体

    fmt.Println(resp.Status)
    dec := json.NewDecoder(resp.Body)
    err = dec.Decode(&message) // 尝试解码
    if err != nil {
        fmt.Println("error decoding the response to the join request")
        log.Fatal(err) // 客户端在此处崩溃
    }

    fmt.Println(message)
    fmt.Println("with clientId", message.ClientId)
}

运行服务器和客户端后，观察到以下现象：

立即学习“go语言免费学习笔记（深入）”；

• 服务器日志显示JSON已正确编码，例如the json: {"What":-1,"Tag":-1,"Id":-1,"ClientId":0,"X":-1,"Y":-1}。
• 客户端接收到200 OK状态码。
• 客户端在尝试解码时报错：error decoding the response to the join request，具体错误是invalid character "3" after array element。
• 进一步调试，客户端使用ioutil.ReadAll(resp.Body)读取响应体并打印，发现输出并非预期的JSON字符串，而是字节的十进制表示，例如the json: [123 34 87 104 97 116 ...]。

这个错误信息和响应体的奇怪输出让许多初学者感到困惑，因为编码后的JSON中并没有字符3，而且响应体变成了字节数组的字符串表示。

深入剖析：fmt.Fprint与http.ResponseWriter的误用

问题的核心在于服务器端使用了fmt.Fprint(w, buffer.Bytes())来发送JSON数据。fmt.Fprint是一个格式化输出函数，它的设计目的是将数据以人类可读的格式写入输出流。当fmt.Fprint遇到一个[]byte类型的参数时，它不会将其视为一个原始的字节序列来直接写入，而是会将其中的每一个字节当作一个整数，并以十进制形式打印出来，并在每个数字之间添加空格。这就是为什么客户端会看到[123 34 87 104 97 116 ...]这样的输出。

例如，JSON字符串{"What":...}的第一个字符是{，其ASCII码是123。fmt.Fprint会将其打印为123。紧接着是"，ASCII码是34，打印为34。这样，原始的JSON结构就被破坏了，变成了由空格分隔的数字字符串。客户端的json.NewDecoder在尝试解析这个非标准的字符串时，自然会因为遇到非JSON格式的字符（例如数字3在不该出现的位置）而报错。

http.ResponseWriter接口提供了一个Write([]byte) (int, error)方法，这个方法正是用于将原始字节数据直接写入HTTP响应体，而不会进行任何格式化处理。

AI-Text-Classifier

OpenAI官方出品，可以区分人工智能书写的文本和人类书写的文本

59

查看详情

解决方案：使用w.Write()发送原始字节

要解决这个问题，服务器端只需将fmt.Fprint(w, buffer.Bytes())替换为w.Write(buffer.Bytes())。w.Write()会直接将buffer.Bytes()中的原始字节序列写入HTTP响应流，确保客户端接收到的是未经修改的、正确的JSON数据。

修正后的服务器端Join方法如下：

import (
    "bytes"
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    // 其他导入
)

// Message 结构体定义 (同上)
type ClientId int
type Message struct {
    What     int `json:"What"`
    Tag      int `json:"Tag"`
    Id       int `json:"Id"`
    ClientId ClientId `json:"ClientId"`
    X        int `json:"X"`
    Y        int `json:"Y"`
}

// Join 方法处理客户端的连接请求
func (network *Network) Join(
    w http.ResponseWriter,
    r *http.Request) {
    log.Println("client wants to join")
    message := Message{-1, -1, -1, ClientId(len(network.Clients)), -1, -1}
    var buffer bytes.Buffer
    enc := json.NewEncoder(&buffer)

    err := enc.Encode(message)
    if err != nil {
        fmt.Println("error encoding the response to a join request")
        log.Fatal(err)
    }

    // 最佳实践：设置 Content-Type 头
    w.Header().Set("Content-Type", "application/json")

    // **修正**：使用 w.Write() 发送原始字节
    _, err = w.Write(buffer.Bytes()) 
    if err != nil {
        fmt.Println("error writing response to client")
        log.Fatal(err)
    }
    fmt.Printf("the json: %s\n", buffer.Bytes()) // 调试输出不受影响
}

经过这个修改后，客户端将能够正确接收并解码JSON响应，不再出现invalid character "3"的错误。客户端代码无需任何修改即可正常工作，因为它期望接收的是合法的JSON数据流，而w.Write()正是提供了这样的数据流。

最佳实践与注意事项

1. 设置 Content-Type 头：在发送JSON响应时，始终应该设置Content-Type头为application/json。这告知客户端响应体的内容类型，有助于客户端正确处理数据。

   w.Header().Set("Content-Type", "application/json")

   登录后复制

2. 更简洁的JSON直接写入方式：如果不需要将JSON编码到bytes.Buffer中进行额外的处理（例如打印到日志），可以直接将json.Encoder绑定到http.ResponseWriter上，这样可以避免中间的bytes.Buffer，代码更简洁高效。

   func (network *Network) Join(
       w http.ResponseWriter,
       r *http.Request) {
       log.Println("client wants to join")
       message := Message{-1, -1, -1, ClientId(len(network.Clients)), -1, -1}
   
       w.Header().Set("Content-Type", "application/json") // 同样需要设置 Content-Type
   
       // 直接编码并写入响应体
       err := json.NewEncoder(w).Encode(message)
       if err != nil {
           fmt.Println("error encoding and writing response to client")
           // 此时可能已经写入部分头信息，需要更优雅的错误处理，例如 http.Error
           http.Error(w, "Internal server error", http.StatusInternalServerError)
           log.Printf("Error encoding/writing JSON: %v", err)
           return
       }
   }

   登录后复制

3. 错误处理的重要性：在网络编程中，对所有可能发生的错误（如JSON编码失败、写入响应失败）进行适当的处理至关重要。例如，使用http.Error向客户端返回错误状态码和消息，而不是简单地log.Fatal，因为log.Fatal会终止整个服务器进程。

总结

在Go语言中处理HTTP响应时，理解fmt.Fprint和http.ResponseWriter.Write对[]byte参数的不同处理方式至关重要。fmt.Fprint用于格式化输出，会将字节切片中的每个字节解释为整数并打印；而w.Write()则是用于直接写入原始字节数据，这正是发送JSON等二进制数据所需要的。通过采用w.Write()并结合设置Content-Type头以及适当的错误处理，我们可以确保Go服务器正确、高效地发送JSON响应，从而构建健壮可靠的API服务。

以上就是Go语言中正确发送和接收JSON数据：避免fmt.Fprint陷阱的详细内容，更多请关注php中文网其它相关文章！