如何在Unmarshal中使用仿制药（GO 1.18）

Question

我是Golang Generics的新手，并拥有以下设置。

1. 我收集了许多不同类型的报告。
2. 每个报告都包含字段
3. ，因此我将其包装在reportContainerimpl

我使用的类型参数[t efortable] 中，其中定义了efortboble如下所示，

type Reportable interface {
    ExportDataPointReport | ImportDataPointReport | MissingDataPointReport | SensorThresoldReport
}

类型约束中的每种类型都是要嵌入容器中的结构。

type ReportContainerImpl[T Reportable] struct {
    LocationID string `json:"lid"`
    Provider string `json:"pn"`
    ReportType ReportType `json:"m"`
    Body T `json:"body"`
}

我使用歧视器reportType在unmarshal时确定具体类型。

type ReportType string

const (
    ReportTypeExportDataPointReport ReportType = "ExportDataPointReport"
    ReportTypeImportDataPointReport ReportType = "ImportDataPointReport"
    ReportTypeMissingDataPointReport ReportType = "MissingDataPointReport"
    ReportTypeSensorThresoldReport ReportType = "SensorThresoldReport"
)

由于 go 不支持 struct （仅 interfaces ）的类型断言，因此当unmarshal）不可能施放类型>。另外， go 不支持指向“原始” 通用类型的指针。因此，我创建了一个接口，reportContainerimpl实施。

type ReportContainer interface {
    GetLocationID() string
    GetProvider() string
    GetReportType() ReportType
    GetBody() interface{}
}

然后我得到的问题是，我无法对任何形式或形状的返回类型进行键入约束，然后在上回到 上的getbody（）函数到当完成unmarshal时，允许类型断言。

    container, err := UnmarshalReportContainer(data)

    if rep, ok := container.GetBody().(ExportDataPointReport); ok {
      // Use the ReportContainerImpl[ExportDataPointReport] here...
    }

也许我弄错了？ - 但是我这样做，我总是最终到达某个地方需要一个接口{}或在 exact eact type之前unmarshal

• 您是否有更好的建议如何以类型（更安全的）方式解决这个问题？

干杯， Mario :)

为了完整性，我在此处添加umarshalreportContainer

func UnmarshalReportContainer(data []byte) (ReportContainer, error) {

    type Temp struct {
        LocationID string `json:"lid"`
        Provider string `json:"pn"`
        ReportType ReportType `json:"m"`
        Body *json.RawMessage `json:"body"`
    }

    var temp Temp
    err := json.Unmarshal(data, &temp)
    if err != nil {
        return nil, err
    }

    switch temp.ReportType {
    case ReportTypeExportDataPointReport:
        var report ExportDataPointReport
        err := json.Unmarshal(*temp.Body, &report)
        return &ReportContainerImpl[ExportDataPointReport]{
            LocationID: temp.LocationID,
            Provider:   temp.Provider,
            ReportType: temp.ReportType,
            Body:       report,
        }, err

      // ...
    }
}

Answer 1

但是，但是我这样做，最终我总是需要一个接口{}或在unmarshal

之前知道确切的类型

精确地知道unmarshal之前的确切类型。

实例化某些通用类型或功能所需的具体类型，例如ReportContainerimpl或unmarshalreportContainer必须在编译时（编写代码）在编译时知道。相反，当您将字节切片带有实际数据时，JSON UNMARSHALLING会发生在运行时。

要基于某些歧视价值来解开“动态JSON”，您仍然需要switch。

您有更好的建议如何以类型（更安全）的方式解决此问题？

仅仅是放弃参数多态性。这里不合适。保留您现在使用json.rawmessage的代码，在switch中有条件地删除动态数据，然后返回实现report> Report> ReportContainer接口的混凝土结构。

---

作为一般解决方案 - 如果并且只有在您可以克服这个鸡和蛋的问题并在编译时间已知的类型参数时，您可以写出这样的最小通用的透明函数：

func unmarshalAny[T any](bytes []byte) (*T, error) {
    out := new(T)
    if err := json.Unmarshal(bytes, out); err != nil {
        return nil, err
    }
    return out, nil
}

这仅是为了说明原理。请注意，json.unmarshal已经接受任何类型，因此，如果您的通用函数实际上没有执行任何操作“在unmarshalany不存在”整个过程中“插入”。

v, err := unmarshalAny[SomeType](src)

在功能上等效，就好像

out := &SomeType{}
err := json.Unmarshal(bytes, out)

您打算在umarshalany中放置更多逻辑一样，可能需要使用其用法。您的里程可能会有所不同；通常，在实际上不是必需的情况下，请勿使用类型参数。