Go-複製結構之間的所有常見字段

Question

我有一個存儲JSON的數據庫和一個通過HTTP post提供外部API的服務器，可以更改此數據庫中的值。數據庫由內部的不同進程使用，因此具有通用的命名方案。

顧客看到的鑰匙是不同的，但映射1：1與數據庫中的鑰匙（有未暴露的鑰匙）。例如：

這是在數據庫：

{ "bit_size": 8, "secret_key": false } 

，這是呈現給客戶：

{ "num_bits": 8 } 

該API可相對於字段名稱改變，但數據庫總是有一致的鍵。

我有一個名爲域的結構相同，標誌不同的JSON編碼器：

type DB struct { 
    NumBits int `json:"bit_size"` 
    Secret bool `json:"secret_key"` 
} 
type User struct { 
    NumBits int `json:"num_bits"` 
} 

我使用encoding/json做元帥/解組。

是reflect正確的工具嗎？有沒有更簡單的方法，因爲所有的鍵都是一樣的？我在想某種memcpy（如果我保持用戶字段的順序相同）。

Answer 1

下面是使用反射的解決方案。如果你需要更復雜的嵌入結構域等結構，你必須進一步開發它。

http://play.golang.org/p/iTaDgsdSaI

package main 

import (
    "encoding/json" 
    "fmt" 
    "reflect" 
) 

type M map[string]interface{} // just an alias 

var Record = []byte(`{ "bit_size": 8, "secret_key": false }`) 

type DB struct { 
    NumBits int `json:"bit_size"` 
    Secret bool `json:"secret_key"` 
} 

type User struct { 
    NumBits int `json:"num_bits"` 
} 

func main() { 
    d := new(DB) 
    e := json.Unmarshal(Record, d) 
    if e != nil { 
     panic(e) 
    } 
    m := mapFields(d) 
    fmt.Println("Mapped fields: ", m) 
    u := new(User) 
    o := applyMap(u, m) 
    fmt.Println("Applied map: ", o) 
    j, e := json.Marshal(o) 
    if e != nil { 
     panic(e) 
    } 
    fmt.Println("Output JSON: ", string(j)) 
} 

func applyMap(u *User, m M) M { 
    t := reflect.TypeOf(u).Elem() 
    o := make(M) 
    for i := 0; i < t.NumField(); i++ { 
     f := t.FieldByIndex([]int{i}) 
     // skip unexported fields 
     if f.PkgPath != "" { 
      continue 
     } 
     if x, ok := m[f.Name]; ok { 
      k := f.Tag.Get("json") 
      o[k] = x 
     } 
    } 
    return o 
} 

func mapFields(x *DB) M { 
    o := make(M) 
    v := reflect.ValueOf(x).Elem() 
    t := v.Type() 
    for i := 0; i < v.NumField(); i++ { 
     f := t.FieldByIndex([]int{i}) 
     // skip unexported fields 
     if f.PkgPath != "" { 
      continue 
     } 
     o[f.Name] = v.FieldByIndex([]int{i}).Interface() 
    } 
    return o 
} 

Answer 2

這是一個沒有反射，不安全或每個結構函數的解決方案。這個例子有點複雜，也許你不需要像這樣做，但關鍵是使用map [string] interface {}從帶有字段標籤的結構中解脫出來。您可能能夠在類似的解決方案中使用該想法。

package main 

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

// example full database record 
var dbj = `{ "bit_size": 8, "secret_key": false }` 

// User type has only the fields going to the API 
type User struct { 
    // tag still specifies internal name, not API name 
    NumBits int `json:"bit_size"` 
} 

// mapping from internal field names to API field names. 
// (you could have more than one mapping, or even construct this 
// at run time) 
var ApiField = map[string]string{ 
    // internal: API 
    "bit_size": "num_bits", 
    // ... 
} 

func main() { 
    fmt.Println(dbj) 
    // select user fields from full db record by unmarshalling 
    var u User 
    if err := json.Unmarshal([]byte(dbj), &u); err != nil { 
     log.Fatal(err) 
    } 
    // remarshal from User struct back to json 
    exportable, err := json.Marshal(u) 
    if err != nil { 
     log.Fatal(err) 
    } 
    // unmarshal into a map this time, to shrug field tags. 
    type jmap map[string]interface{} 
    mInternal := jmap{} 
    if err := json.Unmarshal(exportable, &mInternal); err != nil { 
     log.Fatal(err) 
    } 
    // translate field names 
    mExportable := jmap{} 
    for internalField, v := range mInternal { 
     mExportable[ApiField[internalField]] = v 
    } 
    // marshal final result with API field names 
    if exportable, err = json.Marshal(mExportable); err != nil { 
     log.Fatal(err) 
    } 
    fmt.Println(string(exportable)) 
} 

輸出：

{ 「BIT_SIZE」：8中， 「SECRET_KEY」：假}
{ 「num_bits」：8}

編輯：更多的解釋。正如Tom在評論中所指出的那樣，代碼背後有一些反思。這裏的目標是通過使用庫的可用功能來簡化代碼。包json目前提供了兩種處理[string] interface {}的數據，結構標籤和映射的方法。結構標籤可以讓你選擇字段，但強制你靜態選擇一個單一的json字段名稱。這些地圖讓你可以在運行時選擇字段名稱，但不能將哪些字段添加到Marshal。如果json包允許你同時做兩件事，那將會很好，但事實並非如此。這裏的答案只是顯示了兩種技術，以及如何將它們組合爲解決OP中的示例問題的方案。

Answer 3

「是反映了這個正確的工具？」一個更好的問題可能是，「struct標記是否是正確的工具？」答案可能不是。

package main 

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

var dbj = `{ "bit_size": 8, "secret_key": false }` 

// translation from internal field name to api field name 
type apiTrans struct { 
    db, api string 
} 

var User = []apiTrans{ 
    {db: "bit_size", api: "num_bits"}, 
} 

func main() { 
    fmt.Println(dbj) 
    type jmap map[string]interface{} 
    // unmarshal full db record 
    mdb := jmap{} 
    if err := json.Unmarshal([]byte(dbj), &mdb); err != nil { 
     log.Fatal(err) 
    } 
    // build result 
    mres := jmap{} 
    for _, t := range User { 
     if v, ok := mdb[t.db]; ok { 
      mres[t.api] = v 
     } 
    } 
    // marshal result 
    exportable, err := json.Marshal(mres) 
    if err != nil { 
     log.Fatal(err) 
    } 
    fmt.Println(string(exportable)) 
} 

Answer 4

使用結構標籤，下面就肯定是很好，

package main 

import (
    "fmt" 
    "log" 

    "hacked/json" 
) 

var dbj = `{ "bit_size": 8, "secret_key": false }` 

type User struct { 
    NumBits int `json:"bit_size" api:"num_bits"` 
} 

func main() { 
    fmt.Println(dbj) 
    // unmarshal from full db record to User struct 
    var u User 
    if err := json.Unmarshal([]byte(dbj), &u); err != nil { 
     log.Fatal(err) 
    } 
    // remarshal User struct using api field names 
    api, err := json.MarshalTag(u, "api") 
    if err != nil { 
     log.Fatal(err) 
    } 
    fmt.Println(string(api)) 
} 

添加MarshalTag只需要一個小補丁encode.go：

106c106,112 
<  e := &encodeState{} 
--- 
>  return MarshalTag(v, "json") 
> } 
> 
> // MarshalTag is like Marshal but marshalls fields with 
> // the specified tag key instead of the default "json". 
> func MarshalTag(v interface{}, tag string) ([]byte, error) { 
>  e := &encodeState{tagKey: tag} 
201a208 
>  tagKey  string 
328c335 
<    for _, ef := range encodeFields(v.Type()) { 
--- 
>    for _, ef := range encodeFields(v.Type(), e.tagKey) { 
509c516 
< func encodeFields(t reflect.Type) []encodeField { 
--- 
> func encodeFields(t reflect.Type, tagKey string) []encodeField { 
540c547 
<    tv := f.Tag.Get("json") 
--- 
>    tv := f.Tag.Get(tagKey) 

Answer 5

無法嵌入結構是有用嗎？

package main 

import (
    "fmt" 
) 

type DB struct { 
    User 
    Secret bool `json:"secret_key"` 
} 

type User struct { 
    NumBits int `json:"num_bits"` 
} 

func main() { 
    db := DB{User{10}, true} 
    fmt.Printf("Hello, DB: %+v\n", db) 
    fmt.Printf("Hello, DB.NumBits: %+v\n", db.NumBits) 
    fmt.Printf("Hello, User: %+v\n", db.User) 
} 

http://play.golang.org/p/9s4bii3tQ2

Answer 6

b := bytes.Buffer{} 
gob.NewEncoder(&b).Encode(&DbVar) 
u := User{} 
gob.NewDecoder(&b).Decode(&u)