以 Go 为基础的方式用字符串解析 JSON 数据

编程并不是一个机械性的工作，而是需要有思考，有创新的工作，语法是固定的，但解决问题的思路则是依靠人的思维，这就需要我们坚持学习和更新自己的知识。今天golang学习网就整理分享《以 Go 为基础的方式用字符串解析 JSON 数据》，文章讲解的知识点主要包括，如果你对Golang方面的知识点感兴趣，就不要错过golang学习网，在这可以对大家的知识积累有所帮助，助力开发能力的提升。

我使用的是 go v1.17.3

我对 go 还很陌生，并且有 oop 背景，我很清楚我还没有进入 gopher 思维模式！所以我把问题分成两部分，第一部分是我试图解决的问题，第二部分是我到目前为止所做的事情。这样，如果我以一种非常奇怪的方式从惯用的 go 看起来应该看起来的解决方案，问题应该仍然是清楚的。

1。我试图解决的问题：

将 json 请求反序列化为结构，其中结构名称在请求的字段之一中指定。

示例代码

请求：

{
    "id": "1",
    "name": "example-document",
    "dtos": [
        {
            "type": "dtoa",
            "attributes": {
                "name": "geoff"
            }
        },
        {
            "type": "dtob",
            "attributes": {
                "length": "24cm"
            }
        }
    ]
}

我想最终得到一个接口类型的集合。

2。到目前为止我做了什么

我有一个名为 dto 的包，它对每个 dto 能够执行的行为进行建模。

package dto

type dto interface {
    deserialize(attributes json.rawmessage) error
    toentity() (*entity.entity, error)
}

type rawdto struct {
    type       string `json:"type"`
    attributes json.rawmessage
}

type dtoa {
    name string `json:"name"`
}

func (dto *dtoa) deserialize(attributes json.rawmessage) error {
  // unmarshall json to address of t
}

func (dto *dtoa) toentity() (*entity.entity, error) {
  // handle creation of entitya
}

type dtob {
    length string `json:"length"`
}

func (dto *dtob) deserialize(attributes json.rawmessage) error {
  // unmarshall json to address of t
}

func (dto *dtob) toentity() (*entity.entity, error) {
  // handle creation of entityb
}

就上下文而言，entity 是另一个包中的接口。

我按照此 stackoverflow 问题建议的答案创建了一个类型注册表

这看起来像：

package dto

var typeregistry = make(map[string]reflect.type)

func registertype(typednil interface{}) {
    t := reflect.typeof(typednil).elem()
    typeregistry[t.pkgpath()+"."+t.name()] = t
}

func loadtypes() {
    registertype((*dtoa)(nil))
    registertype((*dtob)(nil))
}

func makeinstance(name string) (dto, error) {
    if _, ok := typeregistry[name]; ok {
        return reflect.new(typeregistry[name]).elem().addr().interface().(dto), nil
    }

    return nil, fmt.errorf("[%s] is not a registered type", name)
}

当我把这些放在一起时：

package commands

type CreateCommand struct {
    ID   string       `json:"id"`
    Name string       `json:"name"`
    DTOs []dto.RawDTO `json:"dtos"`
}

func CreateCommandHandler(w http.ResponseWriter, r *http.Request) {
    var cmd CreateCommand
    bodyBytes, err := ioutil.ReadAll(r.Body)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    err = json.Unmarshal(bodyBytes, &cmd)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    var entities []*entity.Entity
    for _, v := range cmd.DTOs {
        // I have a zero instance of a type that implements the DTO interface
        dto, err := dto.MakeInstance("path_to_package." + v.Type)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            return
        }
        // Each registered type implements Deserialize
        err = dto.Deserialize(v.Attributes)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            return
        }
        // Each registered type implements ToEntity
        e, err := dto.ToEntity()
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            return
        }
        entities = append(entities, e)
    }

    w.WriteHeader(http.StatusOK)
}

问题

当我执行此代码并发送请求时，出现以下错误：

http: 恐慌服务 127.0.0.1:34020: 接口转换: *dto.dtoa 不是 dto.dto: 缺少方法 toentity goroutine 18 [运行]：

我不明白为什么会发生这种情况。 deserialize 方法工作正常。

正确答案

func createcommandhandler(w http.responsewriter, r *http.request) {
    var cmd createcommand
    if err := json.newdecoder(r.body).decode(&cmd); err != nil {
        w.writeheader(http.statusbadrequest)
        return
    }

    var entities []*entity.entity
    for _, v := range cmd.dtos {
        e, err := v.dto.toentity()
        if err != nil {
            w.writeheader(http.statusbadrequest)
            return
        }
        entities = append(entities, e)
    }

    w.writeheader(http.statusok)
}

如果您执行以下操作，您的处理程序可能如下所示：

1. 从注册表中删除反射。

var typeregistry = map[string]func() dto{
    "dtoa": func() dto { return new(dtoa) },
    "dtob": func() dto { return new(dtob) },
}

1. 实现自定义 json.unmarshaler。

type dtounmarshaler struct {
    dto dto
}

func (u *dtounmarshaler) unmarshaljson(data []byte) error {
    var raw struct {
        type       string `json:"type"`
        attributes json.rawmessage
    }
    if err := json.unmarshal(data, &raw); err != nil {
        return err
    }
    u.dto = typeregistry[raw.type]()
    return json.unmarshal(raw.attributes, u.dto)
}

1. 在 createcommand 类型中，使用自定义解组器而不是 rawdto 类型。

type createcommand struct {
    id   string               `json:"id"`
    name string               `json:"name"`
    dtos []dto.dtounmarshaler `json:"dtos"`
}

完成。

奖励：您可以简化 dto，因为您不再需要 deserialize。

type DTO interface {
    ToEntity() (*entity.Entity, error)
}

type DTOA struct {
    Name string `json:"name"`
}

func (dto *DTOA) ToEntity() (*entity.Entity, error) {
    // Handle creation of EntityA
}

type DTOB struct {
    Length string `json:"length"`
}

func (dto *DTOB) ToEntity() (*entity.Entity, error) {
    // Handle creation of EntityB
}

今天关于《以 Go 为基础的方式用字符串解析 JSON 数据》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！