Go语言库设计：灵活处理JSON反序列化与可扩展性

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

package library

import (
    "encoding/json"
    "fmt"
)

// BaseRequest 定义了通用的JSON请求字段
type BaseRequest struct {
    CommonField string
}

// AllocateFn 是客户端提供的分配函数类型
type AllocateFn func() interface{}

// HandlerFn 是客户端提供的处理函数类型
type HandlerFn func(interface{})

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

// NewService 创建一个新的服务实例
func NewService(allocator AllocateFn, handler HandlerFn) *Service {
    return &Service{allocator, handler}
}

// SomeHandler 模拟库内部处理请求的方法
func (s *Service) SomeHandler(data []byte) error {
    v := s.allocator() // 调用客户端的分配器获取实例
    if err := json.Unmarshal(data, v); err != nil {
        return fmt.Errorf("failed to unmarshal JSON: %w", err)
    }
    s.handler(v) // 将反序列化后的实例传递给客户端处理器
    return nil
}

package main

import (
    "fmt"
    "log"
    "your_library_path" // 替换为实际的库路径
)

// MyRequest 扩展了BaseRequest，增加了自定义字段
type MyRequest struct {
    library.BaseRequest // 嵌入通用结构体
    Url         string
    Name        string
}

// allocator 实现：返回MyRequest的指针
func allocator() interface{} {
    return &MyRequest{}
}

// handler 实现：处理反序列化后的MyRequest实例
func handler(v interface{}) {
    // 需要进行类型断言
    req, ok := v.(*MyRequest)
    if !ok {
        fmt.Printf("Error: unexpected type %T\n", v)
        return
    }
    fmt.Printf("Received MyRequest: CommonField=%s, Url=%s, Name=%s\n", 
        req.CommonField, req.Url, req.Name)
}

func main() {
    s := library.NewService(allocator, handler)
    jsonData := []byte(`{ "CommonField": "foo", "Url": "http://example.com", "Name": "Wolf" }`)

    if err := s.SomeHandler(jsonData); err != nil {
        log.Fatalf("Service handler failed: %v", err)
    }
}

package library

import (
    "encoding/json"
    "fmt"
)

// Request 是库提供的富请求对象
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 创建一个新的服务实例
func NewService(handler HandlerFn) *Service {
    return &Service{handler: handler}
}

// SomeHandler 模拟库内部处理请求的方法
func (s *Service) SomeHandler(data []byte) error {
    // 1. 先反序列化通用字段
    var req Request
    if err := json.Unmarshal(data, &req); err != nil {
        return fmt.Errorf("failed to unmarshal common fields: %w", err)
    }

    // 2. 存储完整的原始JSON数据
    req.rawJSON = data 

    // 3. 将富请求对象传递给客户端处理器
    s.handler(&req)
    return nil
}

package main

import (
    "fmt"
    "log"
    "your_library_path" // 替换为实际的库路径
)

// MyRequest 不再需要嵌入BaseRequest，只需定义所有字段
type MyRequest struct {
    CommonField string `json:"CommonField"` // 必须包含库关心的通用字段
    Url         string `json:"Url"`
    Name        string `json:"Name"`
}

// handler 实现：直接接收库提供的Request对象
func handler(req *library.Request) {
    // 直接使用库已反序列化的通用字段
    fmt.Printf("Received CommonField from library: %s\n", req.CommonField)

    // 如果需要，将原始JSON反序列化到自定义结构体
    var myValue MyRequest
    if err := req.Unmarshal(&myValue); err != nil {
        fmt.Printf("Error unmarshaling to MyRequest: %v\n", err)
        return
    }
    fmt.Printf("Received MyRequest: CommonField=%s, Url=%s, Name=%s\n", 
        myValue.CommonField, myValue.Url, myValue.Name)
}

func main() {
    s := library.NewService(handler)
    jsonData := []byte(`{ "CommonField": "foo", "Url": "http://example.com", "Name": "Wolf" }`)

    if err := s.SomeHandler(jsonData); err != nil {
        log.Fatalf("Service handler failed: %v", err)
    }
}