从struct中删除字段或将其隐藏在JSON Response中

Question

我在Go中创建了一个API,在被调用时,执行查询,创建结构的实例,然后在发送回调用者之前将该结构编码为JSON.我现在想让调用者能够通过传入"fields"GET参数来选择他们想要返回的特定字段.

这意味着取决于字段值,我的结构会改变.有没有办法从结构中删除字段？或者至少动态地将它们隐藏在JSON响应中？(注意:有时候我有空值,所以JSON omitEmpty标签在这里不起作用)如果这些都不可能,那么是否有更好的方法来处理这个？提前致谢.

我正在使用的结构的较小版本如下:

type SearchResult struct {
    Date        string      `json:"date"`
    IdCompany   int         `json:"idCompany"`
    Company     string      `json:"company"`
    IdIndustry  interface{} `json:"idIndustry"`
    Industry    string      `json:"industry"`
    IdContinent interface{} `json:"idContinent"`
    Continent   string      `json:"continent"`
    IdCountry   interface{} `json:"idCountry"`
    Country     string      `json:"country"`
    IdState     interface{} `json:"idState"`
    State       string      `json:"state"`
    IdCity      interface{} `json:"idCity"`
    City        string      `json:"city"`
} //SearchResult

type SearchResults struct {
    NumberResults int            `json:"numberResults"`
    Results       []SearchResult `json:"results"`
} //type SearchResults

然后我编码并输出响应,如下所示:

err := json.NewEncoder(c.ResponseWriter).Encode(&msg)

Answer 1

编辑:我注意到了一些downvotes,又看了一下这个Q&A.大多数人似乎错过了OP要求根据呼叫者提供的字段列表动态选择字段.您无法使用静态定义的json struct标记执行此操作.

如果你想要的是总是跳过一个字段到json-encode,那么当然要使用json:"-"忽略该字段(还要注意,如果你的字段是未导出的,那么这不是必需的 - 这些字段总是被json编码器忽略).但这不是OP的问题.

引用对json:"-"答案的评论:

这个[ json:"-"答案]是大多数人在搜索结束时想要的答案,但这不是问题的答案.

在这种情况下,我使用map [string] interface {}而不是struct.您可以通过调用delete地图上的内置字段来删除字段,从而轻松删除字段.

也就是说,如果您不能首先查询请求的字段.

Answer 2

使用`json:" - "`

// Field is ignored by this package.
Field int `json:"-"`

// Field appears in JSON as key "myName".
Field int `json:"myName"`

// Field appears in JSON as key "myName" and
// the field is omitted from the object if its value is empty,
// as defined above.
Field int `json:"myName,omitempty"`

// Field appears in JSON as key "Field" (the default), but
// the field is skipped if empty.
// Note the leading comma.
Field int `json:",omitempty"`

doc:http://golang.org/pkg/encoding/json/#Marshal

Answer 3

另一种方法是使用带有标记的指针结构,omitempty.如果指针为nil,则字段不会被编组.

此方法不需要额外的反射或低效使用地图.

与使用此方法的jorelli相同的例子:http://play.golang.org/p/JJNa0m2_nw

Answer 4

您可以使用该reflect包通过反映字段标记并选择json标记值来选择所需的字段.定义选择你想要的字段并返回它们作为您SearchResult所类型的方法map[string]interface{},然后元帅说,而不是SearchResult所结构本身.这是一个如何定义该方法的示例:

func fieldSet(fields ...string) map[string]bool {
    set := make(map[string]bool, len(fields))
    for _, s := range fields {
        set[s] = true
    }
    return set
}

func (s *SearchResult) SelectFields(fields ...string) map[string]interface{} {
    fs := fieldSet(fields...)
    rt, rv := reflect.TypeOf(*s), reflect.ValueOf(*s)
    out := make(map[string]interface{}, rt.NumField())
    for i := 0; i < rt.NumField(); i++ {
        field := rt.Field(i)
        jsonKey := field.Tag.Get("json")
        if fs[jsonKey] {
            out[jsonKey] = rv.Field(i).Interface()
        }
    }
    return out
}

这是一个可运行的解决方案,展示了如何调用此方法并整理您的选择:http: //play.golang.org/p/1K9xjQRnO8

Answer 5

我创建了这个函数，通过忽略某些字段将结构转换为 JSON 字符串。希望它会有所帮助。

func GetJSONString(obj interface{}, ignoreFields ...string) (string, error) {
    toJson, err := json.Marshal(obj)
    if err != nil {
        return "", err
    }

    if len(ignoreFields) == 0 {
        return string(toJson), nil
    }

    toMap := map[string]interface{}{}
    json.Unmarshal([]byte(string(toJson)), &toMap)

    for _, field := range ignoreFields {
        delete(toMap, field)
    }

    toJson, err = json.Marshal(toMap)
    if err != nil {
        return "", err
    }
    return string(toJson), nil
}

示例： https: //play.golang.org/p/nmq7MFF47Gp

Answer 6

这是我定义结构的方式。

type User struct {
    Username string  `json:"username" bson:"username"`
    Email    string  `json:"email" bson:"email"`
    Password *string `json:"password,omitempty" bson:"password"`
    FullName string  `json:"fullname" bson:"fullname"`
}

在我的函数内部设置user.Password = nil为不被编组。

Answer 7

您可以使用标记属性“omitifempty”或制作可选字段指针，并保留您想要跳过的未初始化的字段。

Answer 8

采取三种成分:

1. 在reflect超过一个结构的所有字段包循环.

2. 一个if声明,用于获取您想要的字段Marshal,以及

3. 该encoding/json包Marshal你喜欢的领域.

制备:

1. 将它们混合均匀.使用reflect.TypeOf(your_struct).Field(i).Name()得到的名字i的日场your_struct.

2. 使用reflect.ValueOf(your_struct).Field(i)得到一个类型Value的代表性i的日场your_struct.

3. 使用fieldValue.Interface()检索实际值(upcasted输入接口{})的fieldValue类型的Value(注意支架使用-所述接口()方法产生interface{}

如果你幸运地设法在这个过程中不燃烧任何晶体管或断路器,你应该得到这样的东西:

func MarshalOnlyFields(structa interface{},
    includeFields map[string]bool) (jsona []byte, status error) {
    value := reflect.ValueOf(structa)
    typa := reflect.TypeOf(structa)
    size := value.NumField()
    jsona = append(jsona, '{')
    for i := 0; i < size; i++ {
        structValue := value.Field(i)
        var fieldName string = typa.Field(i).Name
        if marshalledField, marshalStatus := json.Marshal((structValue).Interface()); marshalStatus != nil {
            return []byte{}, marshalStatus
        } else {
            if includeFields[fieldName] {
                jsona = append(jsona, '"')
                jsona = append(jsona, []byte(fieldName)...)
                jsona = append(jsona, '"')
                jsona = append(jsona, ':')
                jsona = append(jsona, (marshalledField)...)
                if i+1 != len(includeFields) {
                    jsona = append(jsona, ',')
                }
            }
        }
    }
    jsona = append(jsona, '}')
    return
}

服务:

例如,使用任意结构和map[string]bool要包含的字段

type magic struct {
    Magic1 int
    Magic2 string
    Magic3 [2]int
}

func main() {
    var magic = magic{0, "tusia", [2]int{0, 1}}
    if json, status := MarshalOnlyFields(magic, map[string]bool{"Magic1": true}); status != nil {
        println("error")
    } else {
        fmt.Println(string(json))
    }

}

好胃口!

Answer 9

我刚刚发布了警长,它根据结构字段上注释的标签将结构转换为地图.然后,您可以封送(JSON或其他)生成的地图.它可能不允许您仅序列化调用者请求的字段集,但我想使用一组组将允许​​您覆盖大多数情况.直接使用组而不是字段很可能也会提高缓存能力.

例:

package main

import (
    "encoding/json"
    "fmt"
    "log"

    "github.com/hashicorp/go-version"
    "github.com/liip/sheriff"
)

type User struct {
    Username string   `json:"username" groups:"api"`
    Email    string   `json:"email" groups:"personal"`
    Name     string   `json:"name" groups:"api"`
    Roles    []string `json:"roles" groups:"api" since:"2"`
}

func main() {
    user := User{
        Username: "alice",
        Email:    "alice@example.org",
        Name:     "Alice",
        Roles:    []string{"user", "admin"},
    }

    v2, err := version.NewVersion("2.0.0")
    if err != nil {
        log.Panic(err)
    }

    o := &sheriff.Options{
        Groups:     []string{"api"},
        ApiVersion: v2,
    }

    data, err := sheriff.Marshal(o, user)
    if err != nil {
        log.Panic(err)
    }

    output, err := json.MarshalIndent(data, "", "  ")
    if err != nil {
        log.Panic(err)
    }
    fmt.Printf("%s", output)
}