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

Question

我是 golang 泛型的新手，并且有以下设置。

1. 我收集了大量不同类型的报告。
2. 每个报告都有封闭字段
3. ，因此我将其包装在 ReportContainerImpl 中，

我使用了 [T Reportable] 的类型参数，其中定义了 Reportable如下

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 的类型断言（仅接口），因此在 Unmarshal。另外，go 不支持指向“raw”泛型类型的指针。因此，我创建了一个由 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...
    }

也许我理解错了？ - 但无论我这样做，我总是会在某个地方需要一个 interface{} 或在 Unmarshal 之前知道确切类型

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

干杯， Mario :)

为了完整起见，我在此处添加了 UnmarshalReportContainer

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