Golangカスタム構造体をマップする

次のような構造があるとします。

func newUser() User {
	name := "user"
	MyGithub := GithubPage{
		URL: "https://.com/liangyaopei",
		Star: 1,
	}
	NoDive := StructNoDive{NoDive: 1}
	dateStr := "2020-07-21 12:00:00"
	date, _ := time.Parse(timeLayout, dateStr)
	profile := Profile{
		Experience: "my experience",
		Date: date,
	}
	return User{
		Name: name,
		Github: MyGithub,
		NoDive: NoDive,
		MyProfile: profile,
	}
}
type User struct {
	Name string `map:"name,omitempty"` // string
	Github GithubPage `map:"github,dive,omitempty"` // struct dive
	NoDive StructNoDive `map:"no_dive,omitempty"` // no dive struct
	MyProfile Profile `map:"my_profile,omitempty"` // struct implements its own method
}
type GithubPage struct {
	URL string `map:"url"`
	Star int `map:"star"`
}
type StructNoDive struct {
	NoDive int
}
type Profile struct {
	Experience string `map:"experience"`
	Date time.Time `map:"time"`
}
// its own toMap method
func (p Profile) StructToMap() (key string, value interface{}) {
	return "time", p.Date.Format(timeLayout)
}

jsonパッケージ marshal，unmarshal

まず構造体を[]バイト配列にシリアライズし、次に[]バイト配列から構造体にシリアライズします。

data, _ := json.Marshal(&user)
m := make(map[string]interface{})
json.Unmarshal(data, &m)

最先端

• これは
• 効率が悪くなります。
• 一部のカスタム・キーや、構造体のフィールドの展開などのカスタム・メソッドをサポートできません。

リフレクションの使用

この記事では、リフレクションを使用して構造体をマップに変換するメソッドを実装します。上の例のnewUser()が返す結果を、ラベリングとリフレクションによって以下のようにマップに変換します。

map[string]interface{}{
	"name": "user",
	"no_dive": StructNoDive{NoDive: 1},
 // dive struct field
	"url": "https://.com/liangyaopei",
	"star": 1,
 // customized method
	"time": "2020-07-21 12:00:00",
}

実装のアイデアとソースコード解析

タグの認識。

readTag メソッドを使用してドメインのタグを読み取ります。タグがない場合はドメイン名を使用します。次に、タグ内のオプションを読み取ります。現在、3つのオプションがサポートされています。

• '-':現在のフィールドを無視
• 'omitempty' : 値が空の場合、このフィールドは無視されます。
• 'dive' : すべてのフィールドをキーとして、この構造体を再帰的に繰り返します。

オプションがチェックされている場合、このフィールドに対応するバイナリ位置を1として話します。

const (
	OptIgnore = "-"
	OptOmitempty = "omitempty"
	OptDive = "dive"
)
const (
	flagIgnore = 1 << iota
	flagOmiEmpty
	flagDive
)
func readTag(f reflect.StructField, tag string) (string, int) {
	val, ok := f.Tag.Lookup(tag)
	fieldTag := ""
	flag := 0
	// no tag, use field name
	if !ok {
		return f.Name, flag
	}
	opts := strings.Split(val, ",")
	fieldTag = opts[0]
	for i := 1; i < len(opts); i++ {
		switch opts[i] {
		case OptIgnore:
			flag |= flagIgnore
		case OptOmitempty:
			flag |= flagOmiEmpty
		case OptDive:
			flag |= flagDive
		}
	}
	return fieldTag, flag
}

構造体のドメインのトラバーサル。

構造体の各フィールドを繰り返し処理し、フィールドの型を決定します。string,intのような基本的な型であれば、値を直接取り、ラベルの値をキーとして使用します。

for i := 0; i < t.NumField(); i++ {
 ...
 switch fieldValue.Kind() {
		case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int, reflect.Int64:
			res[tagVal] = fieldValue.Int()
		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint, reflect.Uint64:
			res[tagVal] = fieldValue.Uint()
		case reflect.Float32, reflect.Float64:
			res[tagVal] = fieldValue.Float()
		case reflect.String:
			res[tagVal] = fieldValue.String()
		case reflect.Bool:
			res[tagVal] = fieldValue.Bool()
		default:
		}
 }
}

埋め込み構造の変換

構造体であれば、まず入力パラメータを実装したメソッドがあるかどうかをチェックし、あればそのメソッドを呼び出します。実装されていない場合は、StructToMapメソッドを再帰的に呼び出し、展開されているかどうかに応じてresのマップに戻り結果を書き込みます。

for i := 0; i < t.NumField(); i++ {
		fieldType := t.Field(i)
		// ignore unexported field
		if fieldType.PkgPath != "" {
			continue
		}
		// read tag
		tagVal, flag := readTag(fieldType, tag)
		if flag&flagIgnore != 0 {
			continue
		}
		fieldValue := v.Field(i)
		if flag&flagOmiEmpty != 0 && fieldValue.IsZero() {
			continue
		}
		// ignore nil pointer in field
		if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
			continue
		}
		if fieldValue.Kind() == reflect.Ptr {
			fieldValue = fieldValue.Elem()
		}
		// get kind
		switch fieldValue.Kind() {
		case reflect.Struct:
			_, ok := fieldValue.Type().MethodByName(methodName)
			if ok {
				key, value, err := callFunc(fieldValue, methodName)
				if err != nil {
					return nil, err
				}
				res[key] = value
				continue
			}
			// recursive
			deepRes, deepErr := StructToMap(fieldValue.Interface(), tag, methodName)
			if deepErr != nil {
				return nil, deepErr
			}
			if flag&flagDive != 0 {
				for k, v := range deepRes {
					res[k] = v
				}
			} else {
				res[tagVal] = deepRes
			}
		default:
		}
 }
 ...
}
// call function
func callFunc(fv reflect.Value, methodName string) (string, interface{}, error) {
	methodRes := fv.MethodByName(methodName).Call([]reflect.Value{})
	if len(methodRes) != methodResNum {
		return "", nil, fmt.Errorf("wrong method %s, should have 2 output: (string,interface{})", methodName)
	}
	if methodRes[0].Kind() != reflect.String {
		return "", nil, fmt.Errorf("wrong method %s, first output should be string", methodName)
	}
	key := methodRes[0].String()
	return key, methodRes[1], nil
}

array,slice型の変換

array,slice型の場合も同様に、渡されたパラメータのメソッドが実装されていないか確認し、実装されていればこのメソッドを呼び出します。実装されていない場合は、このフィールドのタグをキーとして、フィールドの値を値として使用します。

switch fieldValue.Kind() {
		case reflect.Slice, reflect.Array:
			_, ok := fieldValue.Type().MethodByName(methodName)
			if ok {
				key, value, err := callFunc(fieldValue, methodName)
				if err != nil {
					return nil, err
				}
				res[key] = value
				continue
			}
 res[tagVal] = fieldValue
 ....
}

その他の型

インライン・マップのような他の型では、結果の値を返すのが簡単です。

switch fieldValue.Kind() {
		...
		case reflect.Map:
			res[tagVal] = fieldValue
		case reflect.Chan:
			res[tagVal] = fieldValue
		case reflect.Interface:
			res[tagVal] = fieldValue.Interface()
		default:
		}