Go语言中实现可扩展的JSON数据结构反序列化策略

{
  "CommonField": "foo",
  "Url": "http://example.com",
  "Name": "Wolf"
}

package mylib

import (
    "encoding/json"
    "fmt"
)

// Request 是一个富请求对象，包含通用字段和原始JSON数据。
type Request struct {
    CommonField string `json:"CommonField"` // 通用字段
    rawJSON     []byte                   // 存储原始JSON数据
}

// Unmarshal 方法允许客户端将原始JSON数据反序列化到其特定类型。
func (r *Request) Unmarshal(value interface{}) error {
    return json.Unmarshal(r.rawJSON, value)
}

// HandlerFn 是应用程序提供的处理函数类型，现在接收一个 *Request 对象。
type HandlerFn func(*Request)

// Service 模拟库的服务结构。
type Service struct {
    handler HandlerFn
}

// NewService 创建并返回一个 Service 实例。
func NewService(handler HandlerFn) *Service {
    return &Service{handler: handler}
}

// ProcessData 模拟服务处理传入数据的逻辑。
// 它负责解析原始JSON，构建 Request 对象，并调用客户端的处理器。
func (s *Service) ProcessData(data []byte) error {
    var temp struct {
        CommonField string `json:"CommonField"`
    }

    // 第一次解析：只提取通用字段
    if err := json.Unmarshal(data, &temp); err != nil {
        return fmt.Errorf("failed to unmarshal common fields: %w", err)
    }

    // 构建富请求对象，包含通用字段和原始JSON
    req := &Request{
        CommonField: temp.CommonField,
        rawJSON:     data, // 存储原始JSON数据
    }

    // 调用客户端的处理器
    s.handler(req)
    return nil
}

package main

import (
    "fmt"
    "log"
    "mylib" // 假设mylib是上面定义的库
)

// MyExtendedRequest 是应用程序定义的扩展结构，不需嵌入mylib.BaseRequest。
type MyExtendedRequest struct {
    Url  string `json:"Url"`
    Name string `json:"Name"`
}

// appHandler 是应用程序提供的处理函数。
func appHandler(req *mylib.Request) {
    // 直接访问通用字段
    fmt.Printf("通用字段 CommonField: %s\n", req.CommonField)

    // 如果需要，将原始JSON数据反序列化到应用程序的扩展结构中
    var myValue MyExtendedRequest
    if err := req.Unmarshal(&myValue); err != nil {
        log.Printf("Error unmarshaling extended fields: %v", err)
        return
    }

    fmt.Printf("扩展字段 Url: %s, Name: %s\n", myValue.Url, myValue.Name)
    fmt.Printf("完整解析后的MyExtendedRequest: %+v\n", myValue)
}

func main() {
    // 模拟JSON数据
    jsonData := []byte(`{
        "CommonField": "foo",
        "Url": "http://example.com",
        "Name": "Wolf"
    }`)

    // 创建服务实例，并传入应用程序的处理器
    service := mylib.NewService(appHandler)

    // 模拟服务处理数据
    if err := service.ProcessData(jsonData); err != nil {
        log.Fatalf("Service processing failed: %v", err)
    }

    // 另一个只包含通用字段的JSON
    jsonDataSimple := []byte(`{
        "CommonField": "bar"
    }`)

    fmt.Println("\n--- 处理只包含通用字段的JSON ---")
    if err := service.ProcessData(jsonDataSimple); err != nil {
        log.Fatalf("Service processing failed for simple JSON: %v", err)
    }
}

通用字段 CommonField: foo
扩展字段 Url: http://example.com, Name: Wolf
完整解析后的MyExtendedRequest: {Url:http://example.com Name:Wolf}

--- 处理只包含通用字段的JSON ---
通用字段 CommonField: bar
扩展字段 Url: , Name: 
完整解析后的MyExtendedRequest: {Url: Name:}