feat(Go-StudyExample):

2021/01/27:新增mapstructure源码阅读和单测代码

SourceAnalysisAndTool/Readme.md

@@ -3,3 +3,5 @@ validate.V8 源码分析文章：https://blog.csdn.net/qq_34326321/article/detai
 container源码分析文章：https://blog.csdn.net/qq_34326321/article/details/110804660
 
 copier源码分析文章：https://blog.csdn.net/qq_34326321/article/details/112177087
+
+mapstructure源码分析文章：https://blog.csdn.net/qq_34326321/article/details/113182689

SourceAnalysisAndTool/goinggo/mapstructure/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Mitchell Hashimoto, William Kennedy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

SourceAnalysisAndTool/goinggo/mapstructure/README.md

@@ -0,0 +1,219 @@
+# mapstructure
+
+mapstructure is a Go library for decoding generic map values to structures
+and vice versa, while providing helpful error handling.
+
+This library is most useful when decoding values from some data stream (JSON,
+Gob, etc.) where you don't _quite_ know the structure of the underlying data
+until you read a part of it. You can therefore read a `map[string]interface{}`
+and use this library to decode it into the proper underlying native Go
+structure.
+
+## Installation
+
+Standard `go get`:
+
+```
+$ go get github.com/goinggo/mapstructure
+```
+
+## Usage & Example
+
+For usage and examples see the [Godoc](http://godoc.org/github.com/mitchellh/mapstructure).
+
+The `Decode`, `DecodePath` and `DecodeSlicePath` functions have examples associated with it there.
+
+## But Why?!
+
+Go offers fantastic standard libraries for decoding formats such as JSON.
+The standard method is to have a struct pre-created, and populate that struct
+from the bytes of the encoded format. This is great, but the problem is if
+you have configuration or an encoding that changes slightly depending on
+specific fields. For example, consider this JSON:
+
+```json
+{
+  "type": "person",
+  "name": "Mitchell"
+}
+```
+
+Perhaps we can't populate a specific structure without first reading
+the "type" field from the JSON. We could always do two passes over the
+decoding of the JSON (reading the "type" first, and the rest later).
+However, it is much simpler to just decode this into a `map[string]interface{}`
+structure, read the "type" key, then use something like this library
+to decode it into the proper structure.
+
+## DecodePath
+
+Sometimes you have a large and complex JSON document where you only need to decode
+a small part.
+
+```
+{
+	"userContext": {
+		"conversationCredentials": {
+	            "sessionToken": "06142010_1:75bf6a413327dd71ebe8f3f30c5a4210a9b11e93c028d6e11abfca7ff"
+	    },
+	    "valid": true,
+	    "isPasswordExpired": false,
+	    "cobrandId": 10000004,
+	    "channelId": -1,
+	    "locale": "en_US",
+	    "tncVersion": 2,
+	    "applicationId": "17CBE222A42161A3FF450E47CF4C1A00",
+	    "cobrandConversationCredentials": {
+	        "sessionToken": "06142010_1:b8d011fefbab8bf1753391b074ffedf9578612d676ed2b7f073b5785b"
+	    },
+	     "preferenceInfo": {
+	         "currencyCode": "USD",
+	         "timeZone": "PST",
+	         "dateFormat": "MM/dd/yyyy",
+	         "currencyNotationType": {
+	             "currencyNotationType": "SYMBOL"
+	         },
+	         "numberFormat": {
+	             "decimalSeparator": ".",
+	             "groupingSeparator": ",",
+	             "groupPattern": "###,##0.##"
+	         }
+	     }
+	 },
+	 "lastLoginTime": 1375686841,
+	 "loginCount": 299,
+	 "passwordRecovered": false,
+	 "emailAddress": "johndoe@email.com",
+	 "loginName": "sptest1",
+	 "userId": 10483860,
+	 "userType":
+	     {
+	     "userTypeId": 1,
+	     "userTypeName": "normal_user"
+	     }
+}
+```
+
+It is nice to be able to define and pull the documents and fields you need without
+having to map the entire JSON structure.
+
+```
+type UserType struct {
+	UserTypeId   int
+	UserTypeName string
+}
+
+type NumberFormat struct {
+		DecimalSeparator  string `jpath:"userContext.preferenceInfo.numberFormat.decimalSeparator"`
+		GroupingSeparator string `jpath:"userContext.preferenceInfo.numberFormat.groupingSeparator"`
+		GroupPattern      string `jpath:"userContext.preferenceInfo.numberFormat.groupPattern"`
+	}
+	
+type User struct {
+		Session   string   `jpath:"userContext.cobrandConversationCredentials.sessionToken"`
+		CobrandId int      `jpath:"userContext.cobrandId"`
+		UserType  UserType `jpath:"userType"`
+		LoginName string   `jpath:"loginName"`
+		NumberFormat       // This can also be a pointer to the struct (*NumberFormat)
+}
+
+docScript := []byte(document)
+var docMap map[string]interface{}
+json.Unmarshal(docScript, &docMap)
+
+var user User
+mapstructure.DecodePath(docMap, &user)
+```
+
+## DecodeSlicePath
+
+Sometimes you have a slice of documents that you need to decode into a slice of structures
+
+```
+[
+	{"name":"bill"},
+	{"name":"lisa"}
+]
+```
+
+Just Unmarshal your document into a slice of maps and decode the slice
+
+```
+type NameDoc struct {
+	Name string `jpath:"name"`
+}
+
+sliceScript := []byte(document)
+var sliceMap []map[string]interface{}
+json.Unmarshal(sliceScript, &sliceMap)
+
+var myslice []NameDoc
+err := DecodeSlicePath(sliceMap, &myslice)
+
+var myslice []*NameDoc
+err := DecodeSlicePath(sliceMap, &myslice)
+```
+
+## Decode Structs With Embedded Slices
+
+Sometimes you have a document with arrays
+
+```
+{
+	"cobrandId": 10010352,
+	"channelId": -1,
+	"locale": "en_US",
+	"tncVersion": 2,
+	"people": [
+		{
+			"name": "jack",
+			"age": {
+			"birth":10,
+			"year":2000,
+			"animals": [
+				{
+				"barks":"yes",
+				"tail":"yes"
+				},
+				{
+				"barks":"no",
+				"tail":"yes"
+				}
+			]
+		}
+		},
+		{
+			"name": "jill",
+			"age": {
+				"birth":11,
+				"year":2001
+			}
+		}
+	]
+}
+```
+
+You can decode within those arrays
+
+```
+type Animal struct {
+	Barks string `jpath:"barks"`
+}
+
+type People struct {
+	Age     int      `jpath:"age.birth"` // jpath is relative to the array
+	Animals []Animal `jpath:"age.animals"`
+}
+
+type Items struct {
+	Categories []string `jpath:"categories"`
+	Peoples    []People `jpath:"people"` // Specify the location of the array
+}
+
+docScript := []byte(document)
+var docMap map[string]interface{}
+json.Unmarshal(docScript, &docMap)
+
+var items Items
+DecodePath(docMap, &items)
+```

SourceAnalysisAndTool/goinggo/mapstructure/error.go

@@ -0,0 +1,32 @@
+package mapstructure
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Error implements the error interface and can represents multiple
+// errors that occur in the course of a single decode.
+type Error struct {
+	Errors []string
+}
+
+func (e *Error) Error() string {
+	points := make([]string, len(e.Errors))
+	for i, err := range e.Errors {
+		points[i] = fmt.Sprintf("* %s", err)
+	}
+
+	return fmt.Sprintf(
+		"%d error(s) decoding:\n\n%s",
+		len(e.Errors), strings.Join(points, "\n"))
+}
+
+func appendErrors(errors []string, err error) []string {
+	switch e := err.(type) {
+	case *Error:
+		return append(errors, e.Errors...)
+	default:
+		return append(errors, e.Error())
+	}
+}

SourceAnalysisAndTool/goinggo/mapstructure/mapstructure.go

@@ -0,0 +1,990 @@
+// The mapstructure package exposes functionality to convert an
+// abitrary map[string]interface{} into a native Go structure.
+//
+// The Go structure can be arbitrarily complex, containing slices,
+// other structs, etc. and the decoder will properly decode nested
+// maps and so on into the proper structures in the native Go struct.
+// See the examples to see what the decoder is capable of.
+package mapstructure
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+//read note 钩子，起作用的地方是在Decode之前，这边主要的作用可以说比如 在转换之前把字符串转成Time类型等等，具体可以查看：https://godoc.org/github.com/mitchellh/mapstructure#DecodeHookFunc
+//read note  https://github.com/mitchellh/mapstructure/blob/master/decode_hooks.go 这边提供了一些默认的hook方法，可以看一下
+type DecodeHookFunc func(reflect.Kind, reflect.Kind, interface{}) (interface{}, error)
+
+// DecoderConfig is the configuration that is used to create a new decoder
+// and allows customization of various aspects of decoding.
+type DecoderConfig struct {
+	// DecodeHook, if set, will be called before any decoding and any
+	// type conversion (if WeaklyTypedInput is on). This lets you modify
+	// the values before they're set down onto the resulting struct.
+	//
+	// If an error is returned, the entire decode will fail with that
+	// error.
+	//read note 在Decode之前会调用该Hook,这边的注释说明,hook可以让你在Decode之前修改你的结构体现有值
+	DecodeHook DecodeHookFunc
+
+	// If ErrorUnused is true, then it is an error for there to exist
+	// keys in the original map that were unused in the decoding process
+	// (extra keys).
+	//read note 如果这个字段设置为true的话，在map当中只要有key不能转换成结构体的字段就会进行报错，感觉正常情况下是不会设置成true...
+	ErrorUnused bool
+
+	// If WeaklyTypedInput is true, the decoder will make the following
+	// "weak" conversions:
+	//
+	//   - bools to string (true = "1", false = "0")
+	//   - numbers to string (base 10)
+	//   - bools to int/uint (true = 1, false = 0)
+	//   - strings to int/uint (base implied by prefix)
+	//   - int to bool (true if value != 0)
+	//   - string to bool (accepts: 1, t, T, TRUE, true, True, 0, f, F,
+	//     FALSE, false, False. Anything else is an error)
+	//   - empty array = empty map and vice versa
+	//
+	//read note 弱类型转换，这个字段如果设置为true，则从某种类型 to 某种类型 会按照上面的转换规则来进行转换
+	WeaklyTypedInput bool
+
+	// Metadata is the struct that will contain extra metadata about
+	// the decoding. If this is nil, then no metadata will be tracked.
+	//read note 没搞明白这个是干啥的
+	Metadata *Metadata
+
+	// Result is a pointer to the struct that will contain the decoded
+	// value.
+	//read note 转换的结果
+	Result interface{}
+
+	// The tag name that mapstructure reads for field names. This
+	// defaults to "mapstructure"
+	//read note tag名称，默认是 mapstructure
+	TagName string
+}
+
+// A Decoder takes a raw interface value and turns it into structured
+// data, keeping track of rich error information along the way in case
+// anything goes wrong. Unlike the basic top-level Decode method, you can
+// more finely control how the Decoder behaves using the DecoderConfig
+// structure. The top-level Decode method is just a convenience that sets
+// up the most basic Decoder.
+type Decoder struct {
+	//read note 转换工具的配置
+	config *DecoderConfig
+}
+
+// Metadata contains information about decoding a structure that
+// is tedious or difficult to get otherwise.
+type Metadata struct {
+	// Keys are the keys of the structure which were successfully decoded
+	Keys []string
+
+	// Unused is a slice of keys that were found in the raw value but
+	// weren't decoded since there was no matching field in the result interface
+	Unused []string
+}
+
+// Decode takes a map and uses reflection to convert it into the
+// given Go native structure. val must be a pointer to a struct.
+func Decode(m interface{}, rawVal interface{}) error {
+	config := &DecoderConfig{
+		Metadata: nil,
+		Result:   rawVal,
+	}
+
+	//read note 创建包含配置的Decoder对象
+	decoder, err := NewDecoder(config)
+	if err != nil {
+		return err
+	}
+
+	//read note 进行Decode操作
+	return decoder.Decode(m)
+}
+
+// DecodePath takes a map and uses reflection to convert it into the
+// given Go native structure. Tags are used to specify the mapping
+// between fields in the map and structure
+func DecodePath(m map[string]interface{}, rawVal interface{}) error {
+	config := &DecoderConfig{
+		Metadata: nil,
+		Result:   nil,
+	}
+
+	decoder, err := NewPathDecoder(config)
+	if err != nil {
+		return err
+	}
+
+	_, err = decoder.DecodePath(m, rawVal)
+	return err
+}
+
+// DecodeSlicePath decodes a slice of maps against a slice of structures that
+// contain specified tags
+func DecodeSlicePath(ms []map[string]interface{}, rawSlice interface{}) error {
+	reflectRawSlice := reflect.TypeOf(rawSlice)
+	rawKind := reflectRawSlice.Kind()
+	rawElement := reflectRawSlice.Elem()
+
+	//read note 校验是否为切片
+	if (rawKind == reflect.Ptr && rawElement.Kind() != reflect.Slice) ||
+		(rawKind != reflect.Ptr && rawKind != reflect.Slice) {
+		return fmt.Errorf("Incompatible Value, Looking For Slice : %v : %v", rawKind, rawElement.Kind())
+	}
+
+	config := &DecoderConfig{
+		Metadata: nil,
+		Result:   nil,
+	}
+
+	decoder, err := NewPathDecoder(config)
+	if err != nil {
+		return err
+	}
+
+	// Create a slice large enough to decode all the values
+	//read note 构造一个新的数组
+	valSlice := reflect.MakeSlice(rawElement, len(ms), len(ms))
+
+	// Iterate over the maps and decode each one
+	//read note 循环被转换的map数组
+	for index, m := range ms {
+		sliceElementType := rawElement.Elem()
+		if sliceElementType.Kind() != reflect.Ptr {
+			// A slice of objects
+			//read note 如果转换的结果是结构体类型，处理转换
+			obj := reflect.New(rawElement.Elem())
+			decoder.DecodePath(m, reflect.Indirect(obj))
+			indexVal := valSlice.Index(index)
+			indexVal.Set(reflect.Indirect(obj))
+		} else {
+			// A slice of pointers
+			//read note 如果转换的结果是指针类型，处理转换
+			obj := reflect.New(rawElement.Elem().Elem())
+			decoder.DecodePath(m, reflect.Indirect(obj))
+			indexVal := valSlice.Index(index)
+			indexVal.Set(obj)
+		}
+	}
+
+	// Set the new slice
+	//read note 设置转换后的数组数据
+	reflect.ValueOf(rawSlice).Elem().Set(valSlice)
+	return nil
+}
+
+// NewDecoder returns a new decoder for the given configuration. Once
+// a decoder has been returned, the same configuration must not be used
+// again.
+func NewDecoder(config *DecoderConfig) (*Decoder, error) {
+	val := reflect.ValueOf(config.Result)
+	if val.Kind() != reflect.Ptr {
+		return nil, errors.New("result must be a pointer")
+	}
+
+	val = val.Elem()
+	if !val.CanAddr() {
+		return nil, errors.New("result must be addressable (a pointer)")
+	}
+
+	if config.Metadata != nil {
+		if config.Metadata.Keys == nil {
+			config.Metadata.Keys = make([]string, 0)
+		}
+
+		if config.Metadata.Unused == nil {
+			config.Metadata.Unused = make([]string, 0)
+		}
+	}
+
+	if config.TagName == "" {
+		config.TagName = "mapstructure"
+	}
+
+	result := &Decoder{
+		config: config,
+	}
+
+	return result, nil
+}
+
+// NewPathDecoder returns a new decoder for the given configuration.
+// This is used to decode path specific structures
+func NewPathDecoder(config *DecoderConfig) (*Decoder, error) {
+	if config.Metadata != nil {
+		if config.Metadata.Keys == nil {
+			config.Metadata.Keys = make([]string, 0)
+		}
+
+		if config.Metadata.Unused == nil {
+			config.Metadata.Unused = make([]string, 0)
+		}
+	}
+
+	if config.TagName == "" {
+		config.TagName = "mapstructure"
+	}
+
+	result := &Decoder{
+		config: config,
+	}
+
+	return result, nil
+}
+
+// Decode decodes the given raw interface to the target pointer specified
+// by the configuration.
+func (d *Decoder) Decode(raw interface{}) error {
+	//read note config中的Result配置的是指针，如果不是指针是没办法完成配置的.
+	//	所有这边的调用是通过 reflect.ValueOf().Elem()
+	return d.decode("", raw, reflect.ValueOf(d.config.Result).Elem())
+}
+
+// DecodePath decodes the raw interface against the map based on the
+// specified tags
+func (d *Decoder) DecodePath(m map[string]interface{}, rawVal interface{}) (bool, error) {
+	decoded := false
+
+	var val reflect.Value
+	reflectRawValue := reflect.ValueOf(rawVal)
+	kind := reflectRawValue.Kind()
+
+	// Looking for structs and pointers to structs
+	//read note 对传入的 转换结果的数据类型进行判断，转换成对应的结构体类型
+	switch kind {
+	case reflect.Ptr:
+		val = reflectRawValue.Elem()
+		if val.Kind() != reflect.Struct {
+			return decoded, fmt.Errorf("Incompatible Type : %v : Looking For Struct", kind)
+		}
+	case reflect.Struct:
+		var ok bool
+		val, ok = rawVal.(reflect.Value)
+		if ok == false {
+			return decoded, fmt.Errorf("Incompatible Type : %v : Looking For reflect.Value", kind)
+		}
+	default:
+		return decoded, fmt.Errorf("Incompatible Type : %v", kind)
+	}
+
+	// Iterate over the fields in the struct
+	//read note 循环结构体的所有Field
+	for i := 0; i < val.NumField(); i++ {
+		valueField := val.Field(i)
+		typeField := val.Type().Field(i)
+		tag := typeField.Tag
+		//read note 这边的tag是通过 jpath来识别的
+		tagValue := tag.Get("jpath")
+
+		// Is this a field without a tag
+		//read note 没有tag的单独处理
+		if tagValue == "" {
+			//read note 如果是结构体，调用DecodePath处理
+			if valueField.Kind() == reflect.Struct {
+				// We have a struct that may have indivdual tags. Process separately
+				d.DecodePath(m, valueField)
+				continue
+			} else if valueField.Kind() == reflect.Ptr && reflect.TypeOf(valueField).Kind() == reflect.Struct {
+				//read note 指针的处理，转换成结构体也是类型的DecodePath的处理
+
+				// We have a pointer to a struct
+				if valueField.IsNil() {
+					// Create the object since it doesn't exist
+					valueField.Set(reflect.New(valueField.Type().Elem()))
+					decoded, _ = d.DecodePath(m, valueField.Elem())
+					if decoded == false {
+						// If nothing was decoded for this object return the pointer to nil
+						valueField.Set(reflect.NewAt(valueField.Type().Elem(), nil))
+					}
+					continue
+				}
+
+				d.DecodePath(m, valueField.Elem())
+				continue
+			}
+		}
+
+		// Use mapstructure to populate the fields
+		//read note jpath后面支持的别名可以是递进到更进去的层次，通过.标识，比如说 Age.Birth.  表示 Age:{Birth:100,。。。}
+		keys := strings.Split(tagValue, ".")
+		//read note 通过keys去查找数据
+		data := d.findData(m, keys)
+		//read note 如果在map中找到的数据不为nil。需要开始设值操作
+		if data != nil {
+			//read note 如果当前Filed的类型是Slice
+			if valueField.Kind() == reflect.Slice {
+				// Ignore a slice of maps - This sucks but not sure how to check
+				//read note 如果Field是map数组，这边没办法处理，只能通过下面的decode方法进行具体的处理
+				if strings.Contains(valueField.Type().String(), "map[") {
+					goto normal_decode
+				}
+
+				// We have a slice
+				mapSlice := data.([]interface{})
+				if len(mapSlice) > 0 {
+					// Test if this is a slice of more maps
+					//read note 转换成切片的数据如果不是 map的数组，则跳转到下面通过 decode处理.因为这边是切片对切片，map对结构体
+					_, ok := mapSlice[0].(map[string]interface{})
+					if ok == false {
+						goto normal_decode
+					}
+
+					// Extract the maps out and run it through DecodeSlicePath
+					//read note 组转map数组
+					ms := make([]map[string]interface{}, len(mapSlice))
+					for index, m2 := range mapSlice {
+						ms[index] = m2.(map[string]interface{})
+					}
+
+					//调用DecodeSlicePath，转换 map数组 -》 结构体数组
+					DecodeSlicePath(ms, valueField.Addr().Interface())
+					continue
+				}
+			}
+		normal_decode:
+			//read note 通过decode处理，这边同样应该支持 mapstructure的tag标签
+			decoded = true
+			err := d.decode("", data, valueField)
+			if err != nil {
+				return false, err
+			}
+		}
+	}
+
+	return decoded, nil
+}
+
+// Decodes an unknown data type into a specific reflection value.
+//read note 入参说明：
+//	name： 字段名称
+//	data： 被转换的数据
+// 	val ： 转换最终的结构体
+func (d *Decoder) decode(name string, data interface{}, val reflect.Value) error {
+	//read note 结构体为空直接返回
+	if data == nil {
+		// If the data is nil, then we don't set anything.
+		return nil
+	}
+
+	dataVal := reflect.ValueOf(data)
+	//read note 非IsValid的对象，设置零值
+	if !dataVal.IsValid() {
+		// If the data value is invalid, then we just set the value
+		// to be the zero value.
+		val.Set(reflect.Zero(val.Type()))
+		return nil
+	}
+
+	//read note hook的调用，调用的结果data会用在下面的判断中
+	if d.config.DecodeHook != nil {
+		// We have a DecodeHook, so let's pre-process the data.
+		var err error
+		data, err = d.config.DecodeHook(d.getKind(dataVal), d.getKind(val), data)
+		if err != nil {
+			return err
+		}
+	}
+
+	var err error
+	//read note 获得 转换最终的结构体 的类型
+	dataKind := d.getKind(val)
+	//read note 依据类型进行不同的转换处理
+	switch dataKind {
+	case reflect.Bool:
+		err = d.decodeBool(name, data, val)
+	case reflect.Interface:
+		err = d.decodeBasic(name, data, val)
+	case reflect.String:
+		err = d.decodeString(name, data, val)
+	case reflect.Int:
+		err = d.decodeInt(name, data, val)
+	case reflect.Uint:
+		err = d.decodeUint(name, data, val) //read note 处理与decodeInt类似
+	case reflect.Float32:
+		err = d.decodeFloat(name, data, val) //read note 处理与decodeInt类似
+	case reflect.Struct:
+		err = d.decodeStruct(name, data, val)
+	case reflect.Map:
+		err = d.decodeMap(name, data, val)
+	case reflect.Slice:
+		err = d.decodeSlice(name, data, val)
+	default:
+		// If we reached this point then we weren't able to decode it
+		//read note 没办法处理指针类型,比如本来传入的就是指针的指针，这边是拒绝处理的
+		return fmt.Errorf("%s: unsupported type: %s", name, dataKind)
+	}
+
+	// If we reached here, then we successfully decoded SOMETHING, so
+	// mark the key as used if we're tracking metadata.
+	//read note 对处理玩的Metadata进行组装，但是这边看好像一定是不会处理的，因为传进来的name一直是空字符串
+	if d.config.Metadata != nil && name != "" {
+		d.config.Metadata.Keys = append(d.config.Metadata.Keys, name)
+	}
+
+	return err
+}
+
+// findData locates the data by walking the keys down the map
+func (d *Decoder) findData(m map[string]interface{}, keys []string) interface{} {
+	//read note 这是一个递归方法，所以递归的结束就是keys最终变成一个值，查找该值，能找到则返回，否则返回nil
+	if len(keys) == 1 {
+		if value, ok := m[keys[0]]; ok == true {
+			return value
+		}
+		return nil
+	}
+
+	//read note 继续进行递归，下一次递归就是往下一个key开始，可以理解就是map一层一层的下去查找对应的key.
+	if value, ok := m[keys[0]]; ok == true {
+		if m, ok := value.(map[string]interface{}); ok == true {
+			return d.findData(m, keys[1:])
+		}
+	}
+
+	return nil
+}
+
+func (d *Decoder) getKind(val reflect.Value) reflect.Kind {
+	kind := val.Kind()
+
+	switch {
+	case kind >= reflect.Int && kind <= reflect.Int64:
+		return reflect.Int
+	case kind >= reflect.Uint && kind <= reflect.Uint64:
+		return reflect.Uint
+	case kind >= reflect.Float32 && kind <= reflect.Float64:
+		return reflect.Float32
+	default:
+		return kind
+	}
+}
+
+// This decodes a basic type (bool, int, string, etc.) and sets the
+// value to "data" of that type.
+func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
+	//read note 如果被转换的结果是interface，则只判断是否 AssignableTo
+	dataVal := reflect.ValueOf(data)
+	dataValType := dataVal.Type()
+	if !dataValType.AssignableTo(val.Type()) {
+		return fmt.Errorf(
+			"'%s' expected type '%s', got '%s'",
+			name, val.Type(), dataValType)
+	}
+
+	val.Set(dataVal)
+	return nil
+}
+
+func (d *Decoder) decodeString(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
+
+	//read note string这边的转换规则如下：
+	//	1、如果被转换的就是string，则直接转换成string
+	//	开启了弱类型转换标识的
+	//	2、bool转换从1或0
+	//	3、数值类型按照十进制转换成字符串
+	//	4、float类型，按照64位转换
+	switch {
+	case dataKind == reflect.String:
+		val.SetString(dataVal.String())
+	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+		if dataVal.Bool() {
+			val.SetString("1")
+		} else {
+			val.SetString("0")
+		}
+	case dataKind == reflect.Int && d.config.WeaklyTypedInput:
+		val.SetString(strconv.FormatInt(dataVal.Int(), 10))
+	case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
+		val.SetString(strconv.FormatUint(dataVal.Uint(), 10))
+	case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
+		val.SetString(strconv.FormatFloat(dataVal.Float(), 'f', -1, 64))
+	default:
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
+	}
+
+	return nil
+}
+
+func (d *Decoder) decodeInt(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
+
+	//read note int这边的转换大致如下
+	//	1、数值类型，直接转换成int，不考虑精度
+	//	如果开启了弱类型转换标识
+	//	2、bool类型按照0,1转换
+	//	3、字符串通过 ParseInt转换
+	//  4、否则错误
+	switch {
+	case dataKind == reflect.Int:
+		val.SetInt(dataVal.Int())
+	case dataKind == reflect.Uint:
+		val.SetInt(int64(dataVal.Uint()))
+	case dataKind == reflect.Float32:
+		val.SetInt(int64(dataVal.Float()))
+	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+		if dataVal.Bool() {
+			val.SetInt(1)
+		} else {
+			val.SetInt(0)
+		}
+	case dataKind == reflect.String && d.config.WeaklyTypedInput:
+		i, err := strconv.ParseInt(dataVal.String(), 0, val.Type().Bits())
+		if err == nil {
+			val.SetInt(i)
+		} else {
+			return fmt.Errorf("cannot parse '%s' as int: %s", name, err)
+		}
+	default:
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
+	}
+
+	return nil
+}
+
+func (d *Decoder) decodeUint(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
+
+	switch {
+	case dataKind == reflect.Int:
+		val.SetUint(uint64(dataVal.Int()))
+	case dataKind == reflect.Uint:
+		val.SetUint(dataVal.Uint())
+	case dataKind == reflect.Float32:
+		val.SetUint(uint64(dataVal.Float()))
+	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+		if dataVal.Bool() {
+			val.SetUint(1)
+		} else {
+			val.SetUint(0)
+		}
+	case dataKind == reflect.String && d.config.WeaklyTypedInput:
+		i, err := strconv.ParseUint(dataVal.String(), 0, val.Type().Bits())
+		if err == nil {
+			val.SetUint(i)
+		} else {
+			return fmt.Errorf("cannot parse '%s' as uint: %s", name, err)
+		}
+	default:
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
+	}
+
+	return nil
+}
+
+//read note 入参说明：
+//	name： 字段名称
+//	data： 被转换的数据
+// 	val ： 转换最终的结构体
+func (d *Decoder) decodeBool(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
+
+	//read note 这边的转换规则如下：
+	//	1、bool类型直接转换
+	//	开启了弱类型转换标识的
+	//	2、数值类型判断是否为0，0是false
+	//	3、string类型，先进行bool转换，如果不能转换，空字符表示false，否则错误
+	//	4、其他类型错误
+	switch {
+	case dataKind == reflect.Bool:
+		val.SetBool(dataVal.Bool())
+	case dataKind == reflect.Int && d.config.WeaklyTypedInput:
+		val.SetBool(dataVal.Int() != 0)
+	case dataKind == reflect.Uint && d.config.WeaklyTypedInput:
+		val.SetBool(dataVal.Uint() != 0)
+	case dataKind == reflect.Float32 && d.config.WeaklyTypedInput:
+		val.SetBool(dataVal.Float() != 0)
+	case dataKind == reflect.String && d.config.WeaklyTypedInput:
+		b, err := strconv.ParseBool(dataVal.String())
+		if err == nil {
+			val.SetBool(b)
+		} else if dataVal.String() == "" {
+			val.SetBool(false)
+		} else {
+			return fmt.Errorf("cannot parse '%s' as bool: %s", name, err)
+		}
+	default:
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
+	}
+
+	return nil
+}
+
+func (d *Decoder) decodeFloat(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.ValueOf(data)
+	dataKind := d.getKind(dataVal)
+
+	switch {
+	case dataKind == reflect.Int:
+		val.SetFloat(float64(dataVal.Int()))
+	case dataKind == reflect.Uint:
+		val.SetFloat(float64(dataVal.Uint()))
+	case dataKind == reflect.Float32:
+		val.SetFloat(float64(dataVal.Float()))
+	case dataKind == reflect.Bool && d.config.WeaklyTypedInput:
+		if dataVal.Bool() {
+			val.SetFloat(1)
+		} else {
+			val.SetFloat(0)
+		}
+	case dataKind == reflect.String && d.config.WeaklyTypedInput:
+		f, err := strconv.ParseFloat(dataVal.String(), val.Type().Bits())
+		if err == nil {
+			val.SetFloat(f)
+		} else {
+			return fmt.Errorf("cannot parse '%s' as float: %s", name, err)
+		}
+	default:
+		return fmt.Errorf(
+			"'%s' expected type '%s', got unconvertible type '%s'",
+			name, val.Type(), dataVal.Type())
+	}
+
+	return nil
+}
+
+//read note 入参说明：
+//	name： 字段名称
+//	data： 被转换的数据
+// 	val ： 转换最终的结构体
+func (d *Decoder) decodeMap(name string, data interface{}, val reflect.Value) error {
+	valType := val.Type()
+	valKeyType := valType.Key()
+	valElemType := valType.Elem()
+
+	// Make a new map to hold our result
+	//read note 通过反射创建新的map
+	mapType := reflect.MapOf(valKeyType, valElemType)
+	valMap := reflect.MakeMap(mapType)
+
+	// Check input type
+	dataVal := reflect.Indirect(reflect.ValueOf(data))
+	//read note 如果被转换的结构体不是map，这边需要满足
+	//	1、弱类型标识打开
+	//	2、空切片或空数组
+	//	才会返回空map，否则组装错误信息
+	if dataVal.Kind() != reflect.Map {
+		// Accept empty array/slice instead of an empty map in weakly typed mode
+		if d.config.WeaklyTypedInput &&
+			(dataVal.Kind() == reflect.Slice || dataVal.Kind() == reflect.Array) &&
+			dataVal.Len() == 0 {
+			val.Set(valMap)
+			return nil
+		} else {
+			return fmt.Errorf("'%s' expected a map, got '%s'", name, dataVal.Kind())
+		}
+	}
+
+	// Accumulate errors
+	errors := make([]string, 0)
+
+	//read note 遍历被转换结构体的所有key
+	for _, k := range dataVal.MapKeys() {
+		fieldName := fmt.Sprintf("%s[%s]", name, k)
+
+		// First decode the key into the proper type
+		//read note 对key进行转换 decode
+		currentKey := reflect.Indirect(reflect.New(valKeyType))
+		if err := d.decode(fieldName, k.Interface(), currentKey); err != nil {
+			errors = appendErrors(errors, err)
+			continue
+		}
+
+		// Next decode the data into the proper type
+		//read note 对value进行转换 decode
+		v := dataVal.MapIndex(k).Interface()
+		currentVal := reflect.Indirect(reflect.New(valElemType))
+		if err := d.decode(fieldName, v, currentVal); err != nil {
+			errors = appendErrors(errors, err)
+			continue
+		}
+
+		//read note 对结果map进行组装
+		valMap.SetMapIndex(currentKey, currentVal)
+	}
+
+	// Set the built up map to the value
+	//read note map设值
+	val.Set(valMap)
+
+	// If we had errors, return those
+	if len(errors) > 0 {
+		return &Error{errors}
+	}
+
+	return nil
+}
+
+func (d *Decoder) decodeSlice(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.Indirect(reflect.ValueOf(data))
+	dataValKind := dataVal.Kind()
+	valType := val.Type()
+	valElemType := valType.Elem()
+
+	// Make a new slice to hold our result, same size as the original data.
+	//read note 构造新的切片
+	sliceType := reflect.SliceOf(valElemType)
+	valSlice := reflect.MakeSlice(sliceType, dataVal.Len(), dataVal.Len())
+
+	// Check input type
+	//read note 同样的弱类型转换，空的map直接返回空数组（弱类型标识为true的情况下）
+	if dataValKind != reflect.Array && dataValKind != reflect.Slice {
+		// Accept empty map instead of array/slice in weakly typed mode
+		if d.config.WeaklyTypedInput && dataVal.Kind() == reflect.Map && dataVal.Len() == 0 {
+			val.Set(valSlice)
+			return nil
+		} else {
+			return fmt.Errorf(
+				"'%s': source data must be an array or slice, got %s", name, dataValKind)
+		}
+	}
+
+	// Accumulate any errors
+	errors := make([]string, 0)
+
+	//read note 遍历原来的数组，进行每个元素的转换 decode
+	for i := 0; i < dataVal.Len(); i++ {
+		currentData := dataVal.Index(i).Interface()
+		currentField := valSlice.Index(i)
+
+		fieldName := fmt.Sprintf("%s[%d]", name, i)
+		if err := d.decode(fieldName, currentData, currentField); err != nil {
+			errors = appendErrors(errors, err)
+		}
+	}
+
+	// Finally, set the value to the slice we built up
+	//read note 设置切片的值
+	val.Set(valSlice)
+
+	// If there were errors, we return those
+	if len(errors) > 0 {
+		return &Error{errors}
+	}
+
+	return nil
+}
+
+//read note 入参说明：
+//	name： 字段名称
+//	data： 被转换的数据
+// 	val ： 转换最终的结构体
+func (d *Decoder) decodeStruct(name string, data interface{}, val reflect.Value) error {
+	dataVal := reflect.Indirect(reflect.ValueOf(data))
+	dataValKind := dataVal.Kind()
+	//read note 被转换的类型不是map，错误
+	if dataValKind != reflect.Map {
+		return fmt.Errorf("'%s' expected a map, got '%s'", name, dataValKind)
+	}
+
+	dataValType := dataVal.Type()
+	//read note map的key不是string或者Interface类型，错误
+	if kind := dataValType.Key().Kind(); kind != reflect.String && kind != reflect.Interface {
+		return fmt.Errorf("'%s' needs a map with string keys, has '%s' keys", name, dataValType.Key().Kind())
+	}
+
+	//read note 这边组装了两个数组，一个是映射成功的key数组，一个是未映射的key数组
+	dataValKeys, dataValKeysUnused := d.getUseAndUnUseKeyList(dataVal)
+
+	// This slice will keep track of all the structs we'll be decoding. There can be more than one struct if there are embedded structs  that are squashed.
+	//read note 正常情况下只会有一个结构体才对，但是这边的处理，如果结构体中的某一个字段是匿名结构体，则会加入到structs中进行处理
+	// structs[0]是最外层的结构体，structs[1:]是最外层结构体中的匿名字段代表的结构体
+	structs := make([]reflect.Value, 1, 5)
+	structs[0] = val
+	errors := make([]string, 0)
+
+	// Compile the list of all the fields that we're going to be decoding from all the structs.
+	fields := make(map[*reflect.StructField]reflect.Value) //read note 创建【field->value】的map
+
+	//read note 循环structs数组，在循环的过程中遇到 【匿名结构体并且标注了squash的结构体字段会加入到structs数组中】
+	d.structLoopForFieldList(structs, errors, val, fields)
+
+	//read note 循环Filed数组，对每一个map能映射到的字段进行赋值（字段名不区分大小写）
+	d.fieldsLoopForDecode(fields, errors, dataVal, dataValKeys, dataValKeysUnused, name)
+
+	//read note errorUnused标识打开，如果map有未转换的可以，则组装错误信息
+	d.produceErrorWithUnused(dataValKeysUnused, name, errors)
+
+	if len(errors) > 0 {
+		return &Error{errors}
+	}
+
+	// Add the unused keys to the list of unused keys if we're tracking metadata
+	//read note 组装metadata.这边还要判断name不为空
+	d.produceMetadata(dataValKeysUnused, name)
+
+	return nil
+}
+
+func (d *Decoder) structLoopForFieldList(structs []reflect.Value, errors []string, val reflect.Value, fields map[*reflect.StructField]reflect.Value) {
+	for len(structs) > 0 {
+		structVal := structs[0]
+		structs = structs[1:]
+
+		structType := structVal.Type()
+		//read note 循环结构体的所有Field字段
+		for i := 0; i < structType.NumField(); i++ {
+			fieldType := structType.Field(i)
+
+			//read note 匿名字段处理
+			if fieldType.Anonymous {
+				fieldKind := fieldType.Type.Kind()
+				//read note 非结构体，错误
+				if fieldKind != reflect.Struct {
+					errors = appendErrors(errors,
+						fmt.Errorf("%s: unsupported type: %s", fieldType.Name, fieldKind))
+					continue
+				}
+
+				// We have an embedded field. We "squash" the fields down
+				// if specified in the tag.
+				//read note squash标签只作用在匿名字段上，会对匿名字段结构体的字段进行深入赋值.
+				squash := false
+				tagParts := strings.Split(fieldType.Tag.Get(d.config.TagName), ",")
+				for _, tag := range tagParts[1:] {
+					if tag == "squash" {
+						squash = true
+						break
+					}
+				}
+
+				//read note 如果是squash标签标识，会加入到structs数组中，在下一次循环开始之前进行循环
+				if squash {
+					structs = append(structs, val.FieldByName(fieldType.Name))
+					continue
+				}
+			}
+
+			// Normal struct field, store it away
+			//read note 组装map指向
+			fields[&fieldType] = structVal.Field(i)
+		}
+	}
+}
+
+func (d *Decoder) fieldsLoopForDecode(fields map[*reflect.StructField]reflect.Value, errors []string, dataVal reflect.Value, dataValKeys map[reflect.Value]struct{}, dataValKeysUnused map[interface{}]struct{}, name string) {
+	//read note 循环所有的Field，这边的field数组可能是当前结构体的，也可能是结构体中的匿名字段的field
+	for fieldType, field := range fields {
+		fieldName := fieldType.Name
+
+		//read note 获取tag标签，进行【,】切割，这边的标识默认是 mapstructure，比如说 mapstructure：name.获取的就是name
+		tagValue := fieldType.Tag.Get(d.config.TagName)
+		tagValue = strings.SplitN(tagValue, ",", 2)[0]
+		if tagValue != "" {
+			fieldName = tagValue
+		}
+
+		//read note 根据key获取map中的值
+		rawMapKey := reflect.ValueOf(fieldName)
+		rawMapVal := dataVal.MapIndex(rawMapKey)
+		//read note 循环Key数组，进行大小写不敏感匹配，获得map中可以，对应的value
+		if !rawMapVal.IsValid() {
+			// Do a slower search by iterating over each key and
+			// doing case-insensitive search.
+			for dataValKey, _ := range dataValKeys {
+				mK, ok := dataValKey.Interface().(string)
+				if !ok {
+					// Not a string key
+					continue
+				}
+
+				//read note 不区分大小写
+				if strings.EqualFold(mK, fieldName) {
+					rawMapKey = dataValKey
+					rawMapVal = dataVal.MapIndex(dataValKey)
+					break
+				}
+			}
+
+			if !rawMapVal.IsValid() {
+				// There was no matching key in the map for the value in
+				// the struct. Just ignore.
+				continue
+			}
+		}
+
+		// Delete the key we're using from the unused map so we stop tracking
+		//read note 未使用的key数组把被转换的key删掉
+		delete(dataValKeysUnused, rawMapKey.Interface())
+
+		//read note 非IsValid直接报错
+		if !field.IsValid() {
+			// This should never happen
+			panic("field is not valid")
+		}
+
+		// If we can't set the field, then it is unexported or something,
+		// and we just continue onwards.
+		if !field.CanSet() {
+			continue
+		}
+
+		// If the name is empty string, then we're at the root, and we
+		// don't dot-join the fields.
+		if name != "" {
+			fieldName = fmt.Sprintf("%s.%s", name, fieldName)
+		}
+
+		//read note 字段再递归进去处理，可能是对应的不同的类型
+		if err := d.decode(fieldName, rawMapVal.Interface(), field); err != nil {
+			errors = appendErrors(errors, err)
+		}
+	}
+}
+
+func (d *Decoder) produceErrorWithUnused(dataValKeysUnused map[interface{}]struct{}, name string, errors []string) {
+	if d.config.ErrorUnused && len(dataValKeysUnused) > 0 {
+		keys := make([]string, 0, len(dataValKeysUnused))
+		for rawKey, _ := range dataValKeysUnused {
+			keys = append(keys, rawKey.(string))
+		}
+		sort.Strings(keys)
+
+		err := fmt.Errorf("'%s' has invalid keys: %s", name, strings.Join(keys, ", "))
+		errors = appendErrors(errors, err)
+	}
+}
+
+func (d *Decoder) produceMetadata(dataValKeysUnused map[interface{}]struct{}, name string) {
+	if d.config.Metadata != nil {
+		for rawKey, _ := range dataValKeysUnused {
+			key := rawKey.(string)
+			if name != "" {
+				key = fmt.Sprintf("%s.%s", name, key)
+			}
+
+			d.config.Metadata.Unused = append(d.config.Metadata.Unused, key)
+		}
+	}
+}
+
+func (d *Decoder) getUseAndUnUseKeyList(dataVal reflect.Value) (map[reflect.Value]struct{}, map[interface{}]struct{}) {
+	dataValKeys := make(map[reflect.Value]struct{})
+	dataValKeysUnused := make(map[interface{}]struct{})
+	//read note 循环map的key，组装key数组和未使用的key数组
+	for _, dataValKey := range dataVal.MapKeys() {
+		dataValKeys[dataValKey] = struct{}{}
+		dataValKeysUnused[dataValKey.Interface()] = struct{}{}
+	}
+	return dataValKeys, dataValKeysUnused
+}

SourceAnalysisAndTool/mapstructure/DefaultHook_test.go

@@ -0,0 +1,17 @@
+/*
+ *  @Author : huangzj
+ *  @Time : 2021/1/25 16:09
+ *  @Description：
+ */
+
+package example
+
+import (
+	"github.com/mitchellh/mapstructure"
+	"testing"
+)
+
+func TestDefaultHook(t *testing.T) {
+	//在 mitchellh/mapstructure 这个工程中提供了部分的默认Hook方法，主要作用是进行转换，具体可以查看源码
+	mapstructure.StringToIPNetHookFunc()
+}

SourceAnalysisAndTool/mapstructure/Mapstructure_test.go

@@ -0,0 +1,132 @@
+package example
+
+import (
+	entity2 "Go-StudyExample/entity"
+	"encoding/json"
+	"fmt"
+	"github.com/goinggo/mapstructure"
+	"testing"
+)
+
+//-----------------------json数据---------------------
+var document = `{"loginName":"sptest1","userType":{"userTypeId":1,"userTypeName":"normal_user","t":"2026-01-02 15:04:05"}}`
+
+var document1 = `{"cobrandId":10010352,"channelId":-1,"locale":"en_US","tncVersion":2,"people":[{"name":"jack","age":{"birth":10,"year":2000,"animals":[{"barks":"yes","tail":"yes"},{"barks":"no","tail":"yes"}]}},{"name":"jill","age":{"birth":11,"year":2001}}]}`
+
+var document2 = `[{"name":"bill"},{"name":"lisa"}]`
+
+var document3 = `{"categories":["12","222","333"],"people":{"name":"jack","age":{"birth":10,"year":2000,"animals":[{"barks":"yes","tail":"yes"},{"barks":"no","tail":"yes"}]}}}`
+
+//-----------------------------结构体-----------------------
+type Animal struct {
+	Barks string `jpath:"barks"`
+}
+
+type People struct {
+	Age     int      `jpath:"age.birth"` // jpath is relative to the array
+	Animals []Animal `jpath:"age.animals"`
+}
+
+type Items struct {
+	Categories []string `jpath:"categories"`
+	Peoples    []People `jpath:"people"` // Specify the location of the array
+}
+
+type Items1 struct {
+	Categories []string `mapstructure:"Categories"`
+	Peoples    People1  `mapstructure:"People"` // Specify the location of the array
+}
+
+type People1 struct {
+	Age     int      `mapstructure:"age.birth"` // jpath is relative to the array
+	Animals []Animal `mapstructure:"age.animals"`
+}
+
+type NameDoc struct {
+	Name string `jpath:"name"`
+}
+
+//---------------------------------测试方法------------------------
+
+//基本测试
+func TestMapStructureTestFunc(t *testing.T) {
+	var te entity2.Entity
+	m := make(map[string]interface{})
+	m["Num"] = 1
+	m["S"] = "test"
+	m["T"] = map[string]string{"1": "1", "2": "2"}
+
+	err := mapstructure.Decode(m, &te)
+	if err != nil {
+		panic(err.Error())
+	}
+
+	fmt.Print(te.Num, " ", te.S, " ", te.T)
+}
+
+//基本测试
+func TestMapStructureTestFunc1(t *testing.T) {
+	var docMap map[string]interface{}
+	_ = json.Unmarshal([]byte(document), &docMap)
+
+	var user entity2.User
+	err := mapstructure.Decode(docMap, &user)
+
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Println(user.T.Format("2006-01-02 15:04:05"))
+	fmt.Println(user, " ", user.UserType.UserTypeId, " ", user.UserType.UserTypeName)
+}
+
+//测试切片转换
+func TestMapStructureTestFunc2(t *testing.T) {
+
+	sliceScript := []byte(document2)
+	var sliceMap []map[string]interface{}
+	_ = json.Unmarshal(sliceScript, &sliceMap)
+
+	var myslice []NameDoc
+	err := mapstructure.DecodeSlicePath(sliceMap, &myslice)
+
+	if err != nil {
+		panic(err.Error())
+	}
+
+	fmt.Println(myslice[0], " ", myslice[1])
+}
+
+//测试DecodePath
+func TestMapStructureTestFunc3(t *testing.T) {
+	docScript := []byte(document1)
+	var docMap map[string]interface{}
+	_ = json.Unmarshal(docScript, &docMap)
+
+	var items Items
+	err := mapstructure.DecodePath(docMap, &items)
+	if err != nil {
+		panic(err.Error())
+	}
+	fmt.Println(items.Peoples[0], items.Peoples[1])
+}
+
+//MetaData的测试例子
+//decode不支持 mapstructure的标识是  xxxx.xxxx
+//并且这边是对tag别名不区分大小写的
+func TestMetaData(t *testing.T) {
+	var items1 Items1
+	config := &mapstructure.DecoderConfig{
+		Metadata: &mapstructure.Metadata{
+			Keys:   nil,
+			Unused: nil,
+		},
+		Result: &items1,
+	}
+	decoder, _ := mapstructure.NewDecoder(config)
+	docScript := []byte(document3)
+	var docMap map[string]interface{}
+	_ = json.Unmarshal(docScript, &docMap)
+
+	_ = decoder.Decode(docMap)
+	fmt.Println(config.Metadata)
+}

SourceAnalysisAndTool/mapstructure/Readme.md

@@ -0,0 +1,10 @@
+## 官方包获取方式
+    
+    go get github.com/goinggo/mapstructure
+
+## 官方提供默认Hook 
+获取方式: 
+  
+    go get github.com/mitchellh/mapstructure
+    
+    

SourceAnalysisAndTool/validator.v8/testValidator/Validator_test.go

@@ -7,7 +7,7 @@
 package testValidator
 
 import (
-	"Go-Tool/SourceAnalysisAndTool/validator.v8/sourceAnalysis/gopkg.in/go-playground/validator.v8"
+	. "Go-StudyExample/SourceAnalysisAndTool/validator.v8/sourceAnalysis/gopkg.in/go-playground/validator.v8"
 	"fmt"
 	"reflect"
 	"strconv"
@@ -35,11 +35,11 @@ func TestValidator(t *testing.T) {
 
 func testStruct() {
 	//添加结构体校验，对结构体进行处理之后，validator的标签还是会起作用
-	config := &validator.Config{
+	config := &Config{
 		TagName: "validate",
 	}
-	valid := validator.New(config)
-	valid.RegisterStructValidation(func(v *validator.Validate, structLevel *validator.StructLevel) {
+	valid := New(config)
+	valid.RegisterStructValidation(func(v *Validate, structLevel *StructLevel) {
 		c := structLevel.CurrentStruct.Interface().(Cat)
 		if c.Age < 100 {
 			fmt.Println("猫的岁数不能小于100")
@@ -64,10 +64,10 @@ func testStruct() {
 func testField() {
 	//如果注册了对应的Field，则会调用自定义的方法，不会再使用validator定义的标签
 	//这边测试了结构体和基本类型，都是如上述描述的这么处理
-	config := &validator.Config{
+	config := &Config{
 		TagName: "validate",
 	}
-	valid := validator.New(config)
+	valid := New(config)
 	valid.RegisterAliasValidation("ipe", "ip|ipv4|ipv6")
 
 	valid.RegisterCustomTypeFunc(func(field reflect.Value) interface{} {
@@ -114,11 +114,11 @@ func testTag() {
 		Name: "my name is wo-man",
 	}
 
-	config := &validator.Config{
+	config := &Config{
 		TagName: "validate",
 	}
-	valid := validator.New(config)
-	_ = valid.RegisterValidation("diy", func(v *validator.Validate, topStruct reflect.Value, currentStruct reflect.Value, field reflect.Value, fieldtype reflect.Type, fieldKind reflect.Kind, param string) bool {
+	valid := New(config)
+	_ = valid.RegisterValidation("diy", func(v *Validate, topStruct reflect.Value, currentStruct reflect.Value, field reflect.Value, fieldtype reflect.Type, fieldKind reflect.Kind, param string) bool {
 		s := field.Interface().(string)
 
 		i, _ := strconv.ParseInt(param, 0, 64)
@@ -145,10 +145,10 @@ func testAlias() {
 		Name: "213123123",
 	}
 
-	config := &validator.Config{
+	config := &Config{
 		TagName: "validate",
 	}
-	valid := validator.New(config)
+	valid := New(config)
 	valid.RegisterAliasValidation("ipe", "ip|ipv4|ipv6")
 	err := valid.Struct(m)
 	fmt.Println(err)

readme.md

@@ -51,6 +51,8 @@ json与struct之间转换处理工具使用示例
 
 2021/01/07：新增copier源码阅读和单测代码
 
+2021/01/27:新增mapstructure源码阅读和单测代码
+
 # mod vendor模式加载包
 通过go mod的方式加载的github上面的包会有报红的问题，但是包本身是可以运行的，这样就是会有一个问题，如果你想要点击去看方法的内容，没办法做到