简化将动态类型从 JSON 解析并发送到通道的重复代码

“纵有疾风来，人生不言弃”，这句话送给正在学习Golang的朋友们，也希望在阅读本文《简化将动态类型从 JSON 解析并发送到通道的重复代码》后，能够真的帮助到大家。我也会在后续的文章中，陆续更新Golang相关的技术文章，有好的建议欢迎大家在评论留言，非常感谢！

考虑下面的示例，它接受一条 json 消息，该消息最终被解组为几种可能的类型。如何减少或删除与添加其他事件类型相关的样板代码。

package main

import (
    "encoding/json"
    "fmt"
)

const input = `
{
    "type": "hello",
    "event": {
        "name": "picard"
    }
}
`

type eventenvelope struct {
    type  string
    event interface{}
}

type eventhello struct {
    name string
}

type eventhowdy struct {
    name string
}

type display struct {
    formal  chan eventhello
    western chan eventhowdy
}

func newdisplay() *display {
    return &display{
        formal:  make(chan eventhello),
        western: make(chan eventhowdy),
    }
}

func (display *display) run() {
    for {
        select {
        case formal := <-display.formal:
            fmt.println("hello", formal.name)
        case western := <-display.western:
            fmt.println("howdy", western.name)
        }
    }
}

func main() {
    var event json.rawmessage
    env := eventenvelope{
        event: &event,
    }
    if err := json.unmarshal([]byte(input), &env); err != nil {
        fmt.print(err)
    }

    display := newdisplay()
    go display.run()
    events(display, event, env.type)
}

func events(display *display, raw json.rawmessage, event string) {
    switch event {
    case "hello":
        hello := eventhello{}
        if err := json.unmarshal(raw, &hello); err != nil {
            fmt.println(err)
        } else {
            display.formal <- hello
        }
    case "howdy":
        howdy := eventhowdy{}
        if err := json.unmarshal(raw, &howdy); err != nil {
            fmt.println(err)
        } else {
            display.western <- howdy
        }
    default:
        fmt.println("no event handler")
    }

}

解组 eventenvelope 后，实际事件将作为 rawmessage 保留。 然后，事件 rawmessage 被解组为特定类型。这可以是动态的吗？ 只有没有错误，我们才应将其发送到频道。

hello := EventHello{}
        if err := json.Unmarshal(raw, &hello); err != nil {
            fmt.Println(err)
        } else {
            display.formal <- hello
        }

演示中的相同代码：https://play.golang.org/p/wpc8jafyxgq

解决方案

您可以使用类型工厂：

var types map[string]func() interface{} {"hello":func() interface{} {return &eventhello{}}, 
    "howdy": func() interface{} {return &eventhowdy{}}}

工厂可用于使用其名称创建类型的新实例。您可以向这些类型添加新功能，以便他们可以选择自己的渠道：

type sender interface {
   send(display)
}

func (e eventhello) send(d display) {
   d.formal<-e
}

然后可以编写events函数来处理所有可能的事件类型：

func events(display *Display, raw json.RawMessage, event string) {
   evInstance:=types[event]()
   if err := json.Unmarshal(raw, evInstance); err != nil {
       fmt.Println(err)
   } else {
       evInstance.(sender).send(display)
   }
}

本篇关于《简化将动态类型从 JSON 解析并发送到通道的重复代码》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于Golang的相关知识，请关注golang学习网公众号！