2015-12-15 14:40
浏览 375


In my app, I receive a json from the client. This json can be anything since the user defines the keys and the values. In the backend I store it as string in the datastore.

Now i'm trying to override the MarshalJson / UnmarshalJson functions so that what I send / receive from the client is not a string but a json.

I can't figure out how to convert a string to json in go.

my structure

type ContextData string
type Iot struct {
Id              IotId       `json:"id,string" datastore:"-" goon:"id"`
Name            string   `json:"name"`
Context         ContextData  `json:"context" datastore:",noindex"` }

example of received data

{ 'id' : '',
  'name' '',
  'context': {
           'key1': value1,
           'key2': value2 }}

how i want to store this Context field in the datastore as a noindex string '{'key1':value1, 'key2':value2}' example of data i want to send

{ 'id' : '',
  'name' '',
  'context': {
           'key1': value1,
           'key2': value2 }}

图片转代码服务由CSDN问答提供 功能建议

在我的应用中,我从客户端接收到json。 该json可以是任何东西,因为用户定义了键和值。 在后端,我将其作为字符串存储在数据存储中。

现在,我正尝试覆盖MarshalJson / UnmarshalJson函数,以便从客户端发送/接收的不是字符串,而是 一个json。



  type ContextData string 
type Iot struct {
Id IotId`json:“ id,string”数据存储区:“-” goon:“ id”`
Name字符串`json:“ name”`
Context ContextData`json:  “上下文”数据存储区:“,noindex”`} 


  {'id'  :'',

我如何将此Context字段作为noindex字符串存储在数据存储中'{'key1':value1,'key2':value2}' 我要发送的数据示例

'key2':value2  }} 
  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

3条回答 默认 最新

  • dop2144 2015-12-15 17:25

    If I understand your problem correctly, you want to use json.RawMessage as Context.

    RawMessage is a raw encoded JSON object. It implements Marshaler and Unmarshaler and can be used to delay JSON decoding or precompute a JSON encoding.

    RawMessage is just []byte, so you can keep it in data store and then attach it for an outgoing messages as "precomputed JSON".

    type Iot struct {
        Id      int             `json:"id"`
        Name    string          `json:"name"`
        Context json.RawMessage `json:"context"` // RawMessage here! (not a string)
    func main() {
        in := []byte(`{"id":1,"name":"test","context":{"key1":"value1","key2":2}}`)
        var iot Iot
        err := json.Unmarshal(in, &iot)
        if err != nil {
        // Context is []byte, so you can keep it as string in DB
        fmt.Println("ctx:", string(iot.Context))
        // Marshal back to json (as original)
        out, _ := json.Marshal(&iot)

    点赞 打赏 评论
  • doufu7835 2015-12-15 15:34

    I little also don't know what You want to do exacly, but in go I know two ways to convert some received data to json. This data should be as []byte type

    first is allow to compiler choice interface and try parsed to JSON in this way:

    bufferSingleMap   map[string]interface{}
    json.Unmarshal(buffer , &bufferSingleMap)

    socond if You know how exacly looks received data You can first define structure

    type Datas struct{
        Monster []struct {
            Basic int     `json:"basic"`
            Fun int       `json:"fun"`
            Count int     `json:"count"`
        }                 `json:"Monster"`
        M int             `json:"m"`
    Datas datas;
    json.Unmarshal(buffer , &datas)

    Imporant is name value. Should be writed with a capital letter (Fun, Count) This is a sign for Unmarshal that should be json. If You still don't can parsed to JSON show us Your received data, may be they have a bad syntax

    点赞 打赏 评论
  • duanchuang3182 2015-12-15 16:54

    If you have no structured data and you really need to send a full JSON, then you can read it like this:

    // an arbitrary json string
    jsonString := "{\"foo\":{\"baz\": [1,2,3]}}"
    var jsonMap map[string]interface{}
    json.Unmarshal([]byte(jsonString ), &jsonMap)
    // prints: map[foo:map[baz:[1 2 3]]]

    Of course, this has a big disadvantage, in that you don't know what is the content of each item, so you need to cast each of the children of the object to its proper type before using it.

    // inner items are of type interface{}
    foo := jsonMap["foo"]
    // convert foo to the proper type
    fooMap := foo.(map[string]interface{})
    // now we can use it, but its children are still interface{}

    You could simplify this if the JSON you send can be more structured, but if you want to accept any kind of JSON string then you have to check everything and cast to the correct type before using the data.

    You can find the code working in this playground.

    点赞 打赏 评论

相关推荐 更多相似问题