Go中JSON反序列化必填字段处理策略：使用指针与后置检查

type JsonStruct struct {
    String *string  `json:"string"`  // 使用指针类型，当JSON字段缺失或为null时，此字段为nil
    Number *float64 `json:"number"`  // 使用指针类型，当JSON字段缺失或为null时，此字段为nil
}

package main

import (
    "encoding/json"
    "fmt"
)

// JsonStruct 定义了一个包含指针类型字段的结构体，用于区分缺失/null和零值。
type JsonStruct struct {
    String *string  `json:"string"` // 使用指针类型，当字段缺失或为null时，此字段为nil
    Number *float64 `json:"number"` // 使用指针类型，当字段缺失或为null时，此字段为nil
}

func main() {
    // 示例JSON数据 1: "number"字段缺失
    rawJsonMissingNumber := []byte(`{
        "string": "Hello Go Developers!"
    }`)

    // 示例JSON数据 2: "string"字段为null
    rawJsonNullString := []byte(`{
        "string": null,
        "number": 123.45
    }`)

    // 示例JSON数据 3: 所有字段都存在
    rawJsonAllFields := []byte(`{
        "string": "All fields present",
        "number": 987.65
    }`)

    // 示例JSON数据 4: 字段存在但值为零值
    rawJsonZeroValue := []byte(`{
        "string": "",
        "number": 0.0
    }`)

    fmt.Println("--- 处理缺失'number'字段的JSON ---")
    processJson(rawJsonMissingNumber)

    fmt.Println("\n--- 处理'string'字段为null的JSON ---")
    processJson(rawJsonNullString)

    fmt.Println("\n--- 处理所有字段都存在的JSON ---")
    processJson(rawJsonAllFields)

    fmt.Println("\n--- 处理字段存在但值为零值的JSON ---")
    processJson(rawJsonZeroValue)
}

// processJson 函数封装了JSON反序列化和必填字段检查的逻辑
func processJson(jsonData []byte) {
    var s JsonStruct // 注意这里直接声明结构体，而不是结构体指针，因为Unmarshal会填充到&s
    err := json.Unmarshal(jsonData, &s)
    if err != nil {
        fmt.Printf("JSON反序列化失败: %v\n", err)
        return
    }

    fmt.Printf("原始JSON: %s\n", string(jsonData))

    // 检查String字段是否缺失或为null
    if s.String == nil {
        fmt.Println("错误：'string'字段缺失或为null！")
    } else {
        // 注意：在使用指针字段的值之前，必须先解引用
        fmt.Printf("String: \"%s\"\n", *s.String)
    }

    // 检查Number字段是否缺失或为null
    if s.Number == nil {
        fmt.Println("错误：'number'字段缺失或为null！")
    } else {
        // 注意：在使用指针字段的值之前，必须先解引用
        fmt.Printf("Number: %f\n", *s.Number)
    }
}

--- 处理缺失'number'字段的JSON ---
原始JSON: {"string": "Hello Go Developers!"}
String: "Hello Go Developers!"
错误：'number'字段缺失或为null！

--- 处理'string'字段为null的JSON ---
原始JSON: {"string": null, "number": 123.45}
错误：'string'字段缺失或为null！
Number: 123.450000

--- 处理所有字段都存在的JSON ---
原始JSON: {"string": "All fields present", "number": 987.65}
String: "All fields present"
Number: 987.650000

--- 处理字段存在但值为零值的JSON ---
原始JSON: {"string": "", "number": 0.0}
String: ""
Number: 0.000000

// 示例：自定义UnmarshalJSON方法
type User struct {
    Name    string `json:"name"`
    Email   string `json:"email"`
    Age     *int   `json:"age"` // 可选字段，使用指针
}

func (u *User) UnmarshalJSON(data []byte) error {
    // 定义一个辅助结构体，用于初步解析，或者使用 map[string]json.RawMessage
    // 这里的字段可以是非指针类型，因为我们会在后续手动检查
    type Alias User
    aux := &struct {
        Name  string `json:"name"`
        Email string `json:"email"`
        *Alias
    }{
        Alias: (*Alias)(u),
    }

    if err := json.Unmarshal(data, &aux); err != nil {
        return err
    }

    // 手动检查必填字段
    if aux.Name == "" {
        return fmt.Errorf("required field 'name' is missing or empty")
    }
    if aux.Email == "" {
        return fmt.Errorf("required field 'email' is missing or empty")
    }
    // 对于可选字段，如果需要特殊处理，也可以在这里进行

    // 将辅助结构体的值赋给原始结构体
    u.Name = aux.Name
    u.Email = aux.Email
    // Age字段由于是Alias的一部分，已经通过json.Unmarshal(&aux)处理了

    return nil
}