Felder aus struct entfernen oder in JSON Response ausblenden

Ich habe in Go eine API erstellt, die beim Aufruf eine Abfrage ausführt, eine Instanz einer Struktur erstellt und diese Struktur dann als JSON codiert, bevor sie an den Aufrufer zurückgesendet wird. Ich möchte dem Aufrufer jetzt ermöglichen, die spezifischen Felder auszuwählen, die er zurückgeben möchte, indem er einen GET-Parameter "Felder" übergibt.

Dies bedeutet, dass sich meine Struktur abhängig von den Feldwerten ändern würde. Gibt es eine Möglichkeit, Felder aus einer Struktur zu entfernen? Oder sie zumindest dynamisch in der JSON-Antwort ausblenden? (Hinweis: Manchmal habe ich leere Werte, sodass das JSON-Tag omitEmpty hier nicht funktioniert.) Wenn beides nicht möglich ist, gibt es einen Vorschlag für eine bessere Vorgehensweise? Danke im Voraus.

Eine kleinere Version der von mir verwendeten Strukturen ist unten aufgeführt:

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

Ich codiere dann die Antwort und gebe sie wie folgt aus:

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

EDIT: Ich habe ein paar Abstimmungen bemerkt und mir diese Fragen und Antworten noch einmal angesehen. Die meisten Leute scheinen zu vermissen, dass das OP die dynamische Auswahl von Feldern basierend auf der vom Anrufer bereitgestellten Liste von Feldern verlangte . Sie können dies nicht mit dem statisch definierten json struct-Tag tun.

Wenn Sie immer ein Feld zur JSON-Codierung überspringen möchten json:"-", ignorieren Sie das Feld natürlich (beachten Sie auch, dass dies nicht erforderlich ist, wenn Ihr Feld nicht exportiert wird - diese Felder werden vom JSON-Encoder immer ignoriert). Das ist aber nicht die Frage des OP.

Um den Kommentar zur json:"-"Antwort zu zitieren :

Dies [die json:"-"Antwort] ist die Antwort, die die meisten Leute von der Suche hier haben möchten, aber es ist nicht die Antwort auf die Frage.

In diesem Fall würde ich anstelle einer Struktur eine map [string] -Schnittstelle {} verwenden. Sie können Felder einfach entfernen, indem Sie das deletein der Karte integrierte Element aufrufen, damit die Felder entfernt werden.

Das heißt, wenn Sie nicht erst die angeforderten Felder abfragen können.

benutze `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

Ein anderer Weg , dies zu tun , ist es, eine Struktur zu haben , Zeiger mit dem ,omitemptyTag. Wenn die Zeiger Null sind , werden die Felder nicht gemarshallt.

Diese Methode erfordert keine zusätzliche Reflexion oder ineffiziente Verwendung von Karten.

Gleiches Beispiel wie Jorelli mit dieser Methode: http://play.golang.org/p/JJNa0m2_nw

Sie können das reflectPaket verwenden, um die gewünschten Felder auszuwählen, indem Sie über die Feld-Tags nachdenken und die jsonTag-Werte auswählen . Definieren Sie eine Methode auf dem Search Typ, der wählt die gewünschten Felder und gibt sie als ein map[string]interface{}, und dann Marschall , dass anstelle der Search selbst struct. Hier ist ein Beispiel, wie Sie diese Methode definieren können:

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
}

und hier ist eine ausführbare Lösung, die zeigt, wie Sie diese Methode aufrufen und Ihre Auswahl zusammenstellen würden: http://play.golang.org/p/1K9xjQRnO8

Ich habe gerade Sheriff veröffentlicht , der Strukturen in eine Karte umwandelt, die auf Tags basiert, die in den Strukturfeldern mit Anmerkungen versehen sind. Sie können dann die generierte Karte marshallen (JSON oder andere). Es erlaubt Ihnen wahrscheinlich nicht, nur die vom Anrufer angeforderten Felder zu serialisieren, aber ich kann mir vorstellen, dass die Verwendung einer Gruppe von Gruppen es Ihnen ermöglichen würde, die meisten Fälle abzudecken. Die direkte Verwendung von Gruppen anstelle der Felder würde höchstwahrscheinlich auch die Cache-Fähigkeit erhöhen.

Beispiel:

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)
}

Nehmen Sie drei Zutaten:

1. Das reflectPaket, das alle Felder einer Struktur durchläuft.

2. Eine ifAnweisung zum Aufnehmen der gewünschten Felder Marshalund

3. Das encoding/jsonPaket nach MarshalIhren Wünschen.

Vorbereitung:

1. Mischen Sie sie in einem guten Verhältnis. Verwenden Sie reflect.TypeOf(your_struct).Field(i).Name()diese Option , um einen Namen für das idritte Feld von zu erhalten your_struct.

2. Verwenden Sie reflect.ValueOf(your_struct).Field(i)diese Option , um eine Typdarstellung Valueeines ith-Felds von zu erhalten your_struct.

3. Verwenden Sie fieldValue.Interface()diese Option, um den tatsächlichen Wert (der auf den Typ interface {} übertragen wurde) fieldValuedes Typs abzurufen Value(beachten Sie die Verwendung der Klammer - die Interface () -Methode erzeugtinterface{}

Wenn Sie es glücklicherweise schaffen, dabei keine Transistoren oder Leistungsschalter zu verbrennen, sollten Sie Folgendes erhalten:

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
}

Portion:

dienen mit einer beliebigen Struktur und einer Reihe map[string]boolvon Feldern, die Sie beispielsweise einschließen möchten

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))
    }

}

Guten Appetit!

Sie können das Tagging-Attribut "omitifempty" verwenden oder optionale Feldzeiger erstellen und die zu überspringenden Felder nicht initialisiert lassen.

Ich war auch mit diesem Problem konfrontiert. Zuerst wollte ich nur die Antworten in meinem http-Handler spezialisieren. Mein erster Ansatz bestand darin, ein Paket zu erstellen, das die Informationen einer Struktur in eine andere Struktur kopiert und diese zweite Struktur dann zusammenstellt. Ich habe dieses Paket mit Reflection gemacht, also hat mir dieser Ansatz nie gefallen und ich war auch nicht dynamisch.

Deshalb habe ich beschlossen, das encoding / json-Paket zu ändern, um dies zu tun. Die Funktionen Marshal, MarshalIndentund (Encoder) Encodeempfängt zusätzlich ein

type F map[string]F

Ich wollte einen JSON der Felder simulieren, die zum Marshalling benötigt werden, daher werden nur die Felder in der Karte gemarshallt.

https://github.com/JuanTorr/jsont

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/JuanTorr/jsont"
)

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
func main() {
    msg := SearchResults{
        NumberResults: 2,
        Results: []SearchResult{
            {
                Date:        "12-12-12",
                IdCompany:   1,
                Company:     "alfa",
                IdIndustry:  1,
                Industry:    "IT",
                IdContinent: 1,
                Continent:   "america",
                IdCountry:   1,
                Country:     "México",
                IdState:     1,
                State:       "CDMX",
                IdCity:      1,
                City:        "Atz",
            },
            {
                Date:        "12-12-12",
                IdCompany:   2,
                Company:     "beta",
                IdIndustry:  1,
                Industry:    "IT",
                IdContinent: 1,
                Continent:   "america",
                IdCountry:   2,
                Country:     "USA",
                IdState:     2,
                State:       "TX",
                IdCity:      2,
                City:        "XYZ",
            },
        },
    }
    fmt.Println(msg)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {

        //{"numberResults":2,"results":[{"date":"12-12-12","idCompany":1,"idIndustry":1,"country":"México"},{"date":"12-12-12","idCompany":2,"idIndustry":1,"country":"USA"}]}
        err := jsont.NewEncoder(w).Encode(msg, jsont.F{
            "numberResults": nil,
            "results": jsont.F{
                "date":       nil,
                "idCompany":  nil,
                "idIndustry": nil,
                "country":    nil,
            },
        })
        if err != nil {
            log.Fatal(err)
        }
    })

    http.ListenAndServe(":3009", nil)
}

Die Frage ist jetzt etwas alt, aber ich bin vor einiger Zeit auf dasselbe Problem gestoßen, und da ich keinen einfachen Weg gefunden habe, dies zu tun, habe ich eine Bibliothek gebaut, die diesen Zweck erfüllt. Es ermöglicht die einfache Generierung einer map[string]interface{}aus einer statischen Struktur.

https://github.com/tuvistavie/structomap

Ich hatte nicht das gleiche Problem, aber ähnlich. Der folgende Code löst natürlich auch Ihr Problem, wenn Sie nichts gegen Leistungsprobleme haben. Bevor Sie diese Art von Lösung in Ihr System implementieren, empfehle ich Ihnen, Ihre Struktur neu zu gestalten, wenn Sie können. Das Senden einer Antwort mit variabler Struktur ist überentwickelt. Ich glaube, eine Antwortstruktur stellt einen Vertrag zwischen einer Anfrage und einer Ressource dar und sollte keine abhängigen Anfragen sein (Sie können unerwünschte Felder auf Null setzen, das tue ich). In einigen Fällen müssen wir dieses Design implementieren. Wenn Sie glauben, dass Sie sich in diesen Fällen befinden, finden Sie hier den von mir verwendeten Play-Link und Code.

type User2 struct {
    ID       int    `groups:"id" json:"id,omitempty"`
    Username string `groups:"username" json:"username,omitempty"`
    Nickname string `groups:"nickname" json:"nickname,omitempty"`
}

type User struct {
    ID       int    `groups:"private,public" json:"id,omitempty"`
    Username string `groups:"private" json:"username,omitempty"`
    Nickname string `groups:"public" json:"nickname,omitempty"`
}

var (
    tagName = "groups"
)

//OmitFields sets fields nil by checking their tag group value and access control tags(acTags)
func OmitFields(obj interface{}, acTags []string) {
    //nilV := reflect.Value{}
    sv := reflect.ValueOf(obj).Elem()
    st := sv.Type()
    if sv.Kind() == reflect.Struct {
        for i := 0; i < st.NumField(); i++ {
            fieldVal := sv.Field(i)
            if fieldVal.CanSet() {
                tagStr := st.Field(i).Tag.Get(tagName)
                if len(tagStr) == 0 {
                    continue
                }
                tagList := strings.Split(strings.Replace(tagStr, " ", "", -1), ",")
                //fmt.Println(tagList)
                // ContainsCommonItem checks whether there is at least one common item in arrays
                if !ContainsCommonItem(tagList, acTags) {
                    fieldVal.Set(reflect.Zero(fieldVal.Type()))
                }
            }
        }
    }
}

//ContainsCommonItem checks if arrays have at least one equal item
func ContainsCommonItem(arr1 []string, arr2 []string) bool {
    for i := 0; i < len(arr1); i++ {
        for j := 0; j < len(arr2); j++ {
            if arr1[i] == arr2[j] {
                return true
            }
        }
    }
    return false
}
func main() {
    u := User{ID: 1, Username: "very secret", Nickname: "hinzir"}
    //assume authenticated user doesn't has permission to access private fields
    OmitFields(&u, []string{"public"}) 
    bytes, _ := json.Marshal(&u)
    fmt.Println(string(bytes))


    u2 := User2{ID: 1, Username: "very secret", Nickname: "hinzir"}
    //you want to filter fields by field names
    OmitFields(&u2, []string{"id", "nickname"}) 
    bytes, _ = json.Marshal(&u2)
    fmt.Println(string(bytes))

}

Ich habe diese Funktion erstellt, um Struktur in JSON-Zeichenfolge zu konvertieren, indem einige Felder ignoriert wurden. Hoffe es wird helfen.

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
}

Beispiel: https://play.golang.org/p/nmq7MFF47Gp