Go语言中实现JSON字段只读不写：分离结构体的方法

在go语言中处理json序列化与反序列化时，若需实现某些结构体字段只在反序列化时读取（从json到go对象），而在序列化时忽略（从go对象到json），传统的`json:"-"`标签无法满足此需求，因为它会同时禁用读写。本文将介绍一种通过语义分离结构体来优雅解决此问题的方案，确保敏感信息在输出时被有效过滤。

问题背景与json:"-"的局限性

在构建API或处理数据存储时，我们经常会遇到这样的场景：某个结构体字段（例如用户密码哈希PasswordHash）在从JSON数据解析（反序列化）到Go对象时是必需的，以便完整构建内部数据模型；但在将Go对象转换为JSON数据（序列化）输出时，该字段必须被忽略，以避免泄露敏感信息。

Go语言的encoding/json包提供了结构体标签来控制JSON的序列化行为。其中，json:"-"标签常用于指示JSON编码器和解码器忽略某个字段。然而，这个标签是双向的，它会导致字段在反序列化时无法被读取，在序列化时也无法被写入。这与我们“只读不写”的需求相悖。

考虑以下用户结构体示例：

type User struct {
    UserName     string   // 用户名，必须唯一
    Projects     []string // 用户所属项目列表
    PasswordHash string   `json:"-"` // 密码哈希，不应在响应中序列化
    IsAdmin      bool     // 是否为管理员
}

使用json:"-"标签标记PasswordHash字段后，虽然在序列化时该字段会被忽略，但在反序列化时，即使JSON输入中包含PasswordHash，它也无法被解析到User结构体中，这显然不是我们想要的结果。

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

解决方案：结构体的语义分离

解决此问题的最佳实践是根据数据在不同上下文中的语义，将结构体进行分离。我们可以定义一个包含所有字段（包括敏感字段）的内部结构体，用于数据的完整存储和反序列化；同时定义一个只包含公共字段（不含敏感字段）的外部结构体，用于数据输出和序列化。

这种方法清晰地表达了数据的使用场景，提高了代码的可读性和安全性。

实现细节与代码示例

我们将原始的User结构体拆分为两个：UserInfo用于表示公共的用户信息，User则包含完整的用户数据，并通过嵌入UserInfo来复用公共字段。

法语写作助手

法语助手旗下的AI智能写作平台，支持语法、拼写自动纠错，一键改写、润色你的法语作文。

31

查看详情

1. 定义公共信息结构体 UserInfo： 这个结构体将包含所有可以对外暴露的字段。

   type UserInfo struct {
       UserName string   `json:"userName"` // 用户名
       Projects []string `json:"projects"` // 用户所属项目列表
       IsAdmin  bool     `json:"isAdmin"`  // 是否为管理员
   }

   登录后复制

   注意：这里我为字段添加了json标签以遵循Go语言JSON字段命名惯例（通常使用camelCase）。

2. 定义完整用户数据结构体 User： 这个结构体将包含所有内部数据，包括敏感字段PasswordHash。它可以通过嵌入UserInfo来继承公共字段，也可以直接包含一个UserInfo类型的字段。嵌入式结构体在这里更为简洁。

   type User struct {
       UserInfo // 嵌入UserInfo，包含公共字段
   
       // 密码哈希，此字段仅用于内部处理，不应被序列化到外部JSON
       PasswordHash string `json:"passwordHash,omitempty"` 
   }

   登录后复制

   注意：PasswordHash字段不需要json:"-"标签，因为我们不会直接序列化User结构体来作为响应。omitempty标签在这里的作用是当PasswordHash为空字符串时，在序列化User结构体时省略该字段，但这与我们只序列化UserInfo的策略不冲突。

3. 反序列化（读取）操作： 在从JSON读取数据时，我们使用完整的User结构体进行反序列化。encoding/json包会自动将JSON中的相应字段填充到UserInfo的字段和PasswordHash字段中。

   import (
       "encoding/json"
       "fmt"
   )
   
   func main() {
       jsonContent := `{
           "userName": "john.doe",
           "projects": ["projectA", "projectB"],
           "passwordHash": "some_super_secret_hash",
           "isAdmin": true
       }`
   
       var user User
       err := json.Unmarshal([]byte(jsonContent), &user)
       if err != nil {
           fmt.Println("Unmarshal error:", err)
           return
       }
   
       fmt.Println("--- 反序列化结果 ---")
       fmt.Printf("用户名: %s\n", user.UserName)
       fmt.Printf("项目: %v\n", user.Projects)
       fmt.Printf("密码哈希 (内部): %s\n", user.PasswordHash) // 密码哈希已被成功读取
       fmt.Printf("管理员: %t\n", user.IsAdmin)
   
       // ... (接下来的序列化操作)
   }

   登录后复制

4. 序列化（写入）操作： 在将Go对象转换为JSON输出时，我们只序列化User结构体中的UserInfo部分。这样，PasswordHash字段将不会出现在最终的JSON输出中。

   // ... (接续上面的main函数)
   
       fmt.Println("\n--- 序列化结果 ---")
       // 只序列化UserInfo部分
       userBytes, err := json.MarshalIndent(user.UserInfo, "", "    ")
       if err != nil {
           fmt.Println("Marshal error:", err)
           return
       }
   
       fmt.Println("输出JSON (不含密码哈希):")
       fmt.Println(string(userBytes))
   }

   登录后复制

完整示例代码：

package main

import (
    "encoding/json"
    "fmt"
)

// UserInfo 结构体用于表示公共的用户信息，可用于JSON输出
type UserInfo struct {
    UserName string   `json:"userName"`
    Projects []string `json:"projects"`
    IsAdmin  bool     `json:"isAdmin"`
}

// User 结构体包含完整的用户数据，包括敏感字段
type User struct {
    UserInfo // 嵌入UserInfo，包含公共字段

    // PasswordHash 字段仅用于内部处理，不应被序列化到外部JSON
    PasswordHash string `json:"passwordHash,omitempty"` 
}

func main() {
    // 模拟从外部接收到的JSON数据，包含所有字段
    jsonContent := `{
        "userName": "john.doe",
        "projects": ["projectA", "projectB"],
        "passwordHash": "some_super_secret_hash_value",
        "isAdmin": true
    }`

    // 1. 反序列化：将JSON数据解析到完整的User结构体
    var user User
    err := json.Unmarshal([]byte(jsonContent), &user)
    if err != nil {
        fmt.Println("Unmarshal error:", err)
        return
    }

    fmt.Println("--- 反序列化结果 (内部User对象) ---")
    fmt.Printf("用户名: %s\n", user.UserName)
    fmt.Printf("项目: %v\n", user.Projects)
    fmt.Printf("密码哈希 (内部): %s\n", user.PasswordHash) // 密码哈希已被成功读取
    fmt.Printf("管理员: %t\n", user.IsAdmin)

    // 2. 序列化：将User对象的UserInfo部分序列化为JSON输出
    fmt.Println("\n--- 序列化结果 (对外输出JSON) ---")
    // 仅序列化 UserInfo 部分，PasswordHash 不会被包含
    outputBytes, err := json.MarshalIndent(user.UserInfo, "", "    ")
    if err != nil {
        fmt.Println("Marshal error:", err)
        return
    }

    fmt.Println("对外输出JSON (不含密码哈希):")
    fmt.Println(string(outputBytes))

    // 验证 PasswordHash 确实没有被序列化
    // 如果直接序列化 user 对象，PasswordHash 可能会被包含 (如果设置了json标签)
    // 但我们的策略是只序列化 user.UserInfo
    fmt.Println("\n--- 直接序列化完整User对象 (仅作对比，不推荐对外输出) ---")
    fullUserBytes, err := json.MarshalIndent(user, "", "    ")
    if err != nil {
        fmt.Println("Marshal full user error:", err)
        return
    }
    fmt.Println(string(fullUserBytes))
    // 注意：这里的PasswordHash字段因为有`json:"passwordHash,omitempty"`标签，
    // 如果其值非空，仍会被序列化。这进一步说明了语义分离的重要性，
    // 我们需要明确地选择序列化哪个部分。
}

优势与注意事项

1. 清晰的语义分离：这种方法使得代码意图明确，User结构体代表完整的内部数据模型，而UserInfo代表对外暴露的公共数据视图。
2. 安全性：通过明确控制序列化的对象，可以有效防止敏感数据（如PasswordHash）被意外地序列化到外部响应中。
3. 可维护性：当数据模型发生变化时，只需修改相应的结构体，而不会影响到其他上下文中的数据处理逻辑。
4. 灵活性：如果需要不同的输出视图（例如，管理员视图包含更多信息，普通用户视图包含较少信息），可以轻松地创建更多的UserXxxInfo结构体。

注意事项：

• 确保在反序列化时使用包含所有必要字段的完整结构体。
• 在序列化时，务必明确指定只序列化对外输出的结构体（例如user.UserInfo），而不是整个内部结构体。
• 虽然可以在User结构体的PasswordHash字段上使用json:"passwordHash,omitempty"标签，但其主要作用是当字段为空时省略，并不能阻止该字段在序列化User结构体时出现（如果它有值）。因此，关键在于选择正确的对象进行序列化。

总结

在Go语言中，当需要实现JSON字段只在反序列化时读取，而在序列化时忽略的场景时，直接使用json:"-"标签是不足的。通过将结构体进行语义分离，定义一个包含所有数据的内部结构体用于反序列化，以及一个只包含公共数据的外部结构体用于序列化输出，是解决此问题的优雅且安全的方法。这种实践不仅提升了代码的清晰度和可维护性，也有效保障了敏感信息的安全。

以上就是Go语言中实现JSON字段只读不写：分离结构体的方法的详细内容，更多请关注php中文网其它相关文章！