将类型转换为结构的编组流

Question

I'm currently dealing with a stream of json objects coming in to my application, and am having some difficulties figuring out what the best way of parsing them is. The stream consists of objects that have a defined type. The problem is that one of the fields in the object is of changing type. It looks like this:

[{
  "status": "closed",
  "type": "transaction",
  "transaction": {
    "TransactionType": "TypeA",
    "Account": "Some string",
    "Fee": "14",
    "date": 45325680
  },
  "validated": true
},

{
  "status": "closed",
  "type": "transaction",
  "transaction": {
    "TransactionType" : "TypeB",
    "Account" : "Some string",
    "Fee": "42",
    "Destination" : "Some string"
  },
  "validated": true
}]

You can see that the "parent" does not change, but the "transaction" does. I removed a lot of fields from the "transaction" field to make it easier to explain, but this is a type with 10-ish common fields and 10-ish changing fields that are dependent on the type. There are also 10 transaction types, this makes it pretty annoying to put everything into one struct and have a ton of optional fields. I was also thinking about one struct for every transaction type, but this does not work because then there is no way of specifying which type the field should have in the parent.

How would I parse these objects effectively? Unfortunately, I can't change the structure of the elements coming out of the stream. What would be the best way to solve this?

Answer 1

Perhaps keep your transaction as map[string]interface{}

Example https://play.golang.com/p/j_u_ztw04M

package main

import (
    "encoding/json"
    "fmt"
)

type Stream []struct {
    Status string `json:"status"`
    Type   string `json:"type"`

    // map instead of struct
    Transaction map[string]interface{} `json:"transaction"`

    Validated bool `json:"validated"`
}

func main() {

    stream := Stream{}

    err := json.Unmarshal(rawj, &stream)
    if err != nil {
        fmt.Println("error:", err)
        return
    }

    for i, s := range stream {
        fmt.Println("thing:", i)
        for k, v := range s.Transaction {

            // do manual stuff here, perhaps long switch on k and/or
            // as suggested by Cerise Limón type switch on v
            fmt.Printf("key: %s, val: %v, val type: %T
", k, v, v)

        }
        fmt.Println()
    }

}

var rawj = []byte(`[{
  "status": "closed",
  "type": "transaction",
  "transaction": {
    "TransactionType": "TypeA",
    "Account": "Some string",
    "Fee": "14",
    "date": 45325680
  },
  "validated": true
},

{
  "status": "closed",
  "type": "transaction",
  "transaction": {
    "TransactionType" : "TypeB",
    "Account" : "Some string",
    "Fee": "42",
    "Destination" : "Some string"
  },
  "validated": true
}]`)

Have fun!