Go语言中构建可扩展的JSON解组库：优雅处理自定义结构体

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

// mylib/service.go
package mylib

import (
    "encoding/json"
    "fmt"
)

// BaseRequest 定义了库关注的公共字段
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(alloc AllocateFn, hdlr HandlerFn) *Service {
    return &Service{allocator: alloc, handler: hdlr}
}

// ProcessData 模拟库接收并处理原始JSON数据
func (s *Service) ProcessData(data []byte) error {
    v := s.allocator() // 调用应用提供的分配器创建实例
    if err := json.Unmarshal(data, v); err != nil {
        return fmt.Errorf("failed to unmarshal JSON into provided type: %w", err)
    }
    s.handler(v) // 将解组后的实例传递给应用处理器
    return nil
}

// main.go
package main

import (
    "fmt"
    "log"
    "mylib" // 导入库
)

// MyRequest 扩展了库的BaseRequest，添加了应用特有字段
type MyRequest struct {
    mylib.BaseRequest // 嵌入库的基础结构体
    Url               string
    Name              string
}

// myAllocator 应用提供的分配器，返回MyRequest的实例
func myAllocator() interface{} {
    return &MyRequest{}
}

// myHandler 应用提供的处理器，处理解组后的数据
func myHandler(v interface{}) {
    if req, ok := v.(*MyRequest); ok {
        fmt.Printf("应用处理器接收到数据: %+v\n", req)
        fmt.Printf("CommonField: %s, Url: %s, Name: %s\n", req.CommonField, req.Url, req.Name)
    } else {
        fmt.Println("错误：接收到未知类型的数据")
    }
}

func main() {
    service := mylib.NewService(myAllocator, myHandler)
    jsonData := []byte(`{ "CommonField": "foo", "Url": "http://example.com", "Name": "Wolf" }`)

    if err := service.ProcessData(jsonData); err != nil {
        log.Fatalf("处理数据失败: %v", err)
    }
}

// mylib/service.go
package mylib

import (
    "encoding/json"
    "fmt"
)

// Request 是库提供的富请求