Question

我从Redis那里给我的应用程序提供了一个json，然后我解组并循环。

这是从Redis喂养的json Im的样子：

[
    {
        "titel": "test 1",
        "event": "some value",
        "pair": "some value",
        "condition": [
            "or",
            [
                "contains",
                "url",
                "/"
            ],[
                "notcontains",
                "url",
                "hello"
            ]
        ],
        "actions": [
            [
                "option1",
                "12",
                "1"
            ],
            [
                "option2",
                "3",
                "1"
            ]
        ]
    }, {
        "titel": "test 2",
        "event": "some value",
        "pair": "some value",
        "condition": [
            "or",
            [
                "contains",
                "url",
                "/"
            ]
        ],
        "actions": [
            [
                "option1",
                "12",
                "1"
            ],
            [
                "option2",
                "3",
                "1"
            ]
        ]
    }
]

我存储json的结构如下所示：

type Trigger struct {
    Event     string        `json:"event"`  
    Pair      string        `json:"pair"`   
    Actions   [][]string    `json:"actions"`
    Condition Condition     `json:"condition"`
}

type Condition []interface{}

func (c *Condition) Typ() string {
    return (*c)[0].(string)
}

func (c *Condition) Val() []string {
    xs := (*c)[1].([]interface{})
    ys := make([]string, len(xs))
    for i, x := range xs {
        ys[i] = x.(string)
    }
    return ys
}

func (c *Condition) String() (string, string, string) {
    return c.Val()[0], c.Val()[1], c.Val()[2]
}

type Triggers struct {
    Collection []Trigger
}

我将它解组到结构中就像这样：

var triggers Triggers
err := json.Unmarshal([]byte(triggersJson), &triggers.Collection)
if err != nil {
    fmt.Println("Error while unmarshaling triggers json: ", err)
}

在使用围攻进行测试时，此功能完美无缺。但是，只要我想在结构上开始循环，我就会看到很长的响应时间和超时。

这是我循环的方式：

for _,element := range triggers.Collection {
    if element.Event == "some value" {
        fmt.Println("We got: some value")
    }
 }

没有循环的性能在500个并发连接上是2ms。循环使用600ihs ms，500并发一系列超时

理想情况下，我喜欢将json的结构更改为不包括：

"or",

但是我无法控制json，所以不幸的是这不可能。

有什么想法可以解决这个问题以及如何解决这个问题？

修改

我发现什么东西放慢了整个过程。

编辑我的结构，如：

type Trigger struct {
    Event     string        `json:"event"`  
    Pair      string        `json:"pair"`   
    Actions   [][]string    `json:"actions"`
    //Condition Condition     `json:"condition"`
}

从600ms到100ms。但是现在我无法解析Condition。

现在确定如何以另一种方式解析条件，因为它有两种不同的格式

Answer 1

听起来很奇怪，但尽量避免复制Collection元素。像这样：

for i := range triggers.Collection {
if triggers.Collection[i].Event == "some value" {
    fmt.Println("We got: some value")
}

循环收集时Golang变慢

1 个答案: