From b2315db276165facb8e55a277a3b68b198bcda12 Mon Sep 17 00:00:00 2001 From: Huangzj Date: Wed, 27 Jan 2021 14:01:19 +0800 Subject: [PATCH] =?UTF-8?q?feat(Go-StudyExample):=20=20=20=20=20=20=20=20?= =?UTF-8?q?=20=20=20=20=20=20=20=20=20=20=20=20=20=20=202021/01/27:?= =?UTF-8?q?=E6=96=B0=E5=A2=9Emapstructure=E6=BA=90=E7=A0=81=E9=98=85?= =?UTF-8?q?=E8=AF=BB=E5=92=8C=E5=8D=95=E6=B5=8B=E4=BB=A3=E7=A0=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- SourceAnalysisAndTool/Readme.md | 2 + .../goinggo/mapstructure/LICENSE | 21 + .../goinggo/mapstructure/README.md | 219 ++++ .../goinggo/mapstructure/error.go | 32 + .../goinggo/mapstructure/mapstructure.go | 990 ++++++++++++++++++ .../mapstructure/DefaultHook_test.go | 17 + .../mapstructure/Mapstructure_test.go | 132 +++ SourceAnalysisAndTool/mapstructure/Readme.md | 10 + .../testValidator/Validator_test.go | 22 +- readme.md | 2 + 10 files changed, 1436 insertions(+), 11 deletions(-) create mode 100644 SourceAnalysisAndTool/goinggo/mapstructure/LICENSE create mode 100644 SourceAnalysisAndTool/goinggo/mapstructure/README.md create mode 100644 SourceAnalysisAndTool/goinggo/mapstructure/error.go create mode 100644 SourceAnalysisAndTool/goinggo/mapstructure/mapstructure.go create mode 100644 SourceAnalysisAndTool/mapstructure/DefaultHook_test.go create mode 100644 SourceAnalysisAndTool/mapstructure/Mapstructure_test.go create mode 100644 SourceAnalysisAndTool/mapstructure/Readme.md diff --git a/SourceAnalysisAndTool/Readme.md b/SourceAnalysisAndTool/Readme.md index d53c86e..8ca3fda 100644 --- a/SourceAnalysisAndTool/Readme.md +++ b/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 \ No newline at end of file diff --git a/SourceAnalysisAndTool/goinggo/mapstructure/LICENSE b/SourceAnalysisAndTool/goinggo/mapstructure/LICENSE new file mode 100644 index 0000000..1622abe --- /dev/null +++ b/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. diff --git a/SourceAnalysisAndTool/goinggo/mapstructure/README.md b/SourceAnalysisAndTool/goinggo/mapstructure/README.md new file mode 100644 index 0000000..ddd103a --- /dev/null +++ b/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) +``` \ No newline at end of file diff --git a/SourceAnalysisAndTool/goinggo/mapstructure/error.go b/SourceAnalysisAndTool/goinggo/mapstructure/error.go new file mode 100644 index 0000000..3460799 --- /dev/null +++ b/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()) + } +} diff --git a/SourceAnalysisAndTool/goinggo/mapstructure/mapstructure.go b/SourceAnalysisAndTool/goinggo/mapstructure/mapstructure.go new file mode 100644 index 0000000..11cd1be --- /dev/null +++ b/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 +} diff --git a/SourceAnalysisAndTool/mapstructure/DefaultHook_test.go b/SourceAnalysisAndTool/mapstructure/DefaultHook_test.go new file mode 100644 index 0000000..3c68488 --- /dev/null +++ b/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() +} diff --git a/SourceAnalysisAndTool/mapstructure/Mapstructure_test.go b/SourceAnalysisAndTool/mapstructure/Mapstructure_test.go new file mode 100644 index 0000000..a8ba9ce --- /dev/null +++ b/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) +} diff --git a/SourceAnalysisAndTool/mapstructure/Readme.md b/SourceAnalysisAndTool/mapstructure/Readme.md new file mode 100644 index 0000000..dedb420 --- /dev/null +++ b/SourceAnalysisAndTool/mapstructure/Readme.md @@ -0,0 +1,10 @@ +## 官方包获取方式 + + go get github.com/goinggo/mapstructure + +## 官方提供默认Hook +获取方式: + + go get github.com/mitchellh/mapstructure + + \ No newline at end of file diff --git a/SourceAnalysisAndTool/validator.v8/testValidator/Validator_test.go b/SourceAnalysisAndTool/validator.v8/testValidator/Validator_test.go index d6a98bc..85e86e3 100644 --- a/SourceAnalysisAndTool/validator.v8/testValidator/Validator_test.go +++ b/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) diff --git a/readme.md b/readme.md index 9387146..b2a76de 100644 --- a/readme.md +++ b/readme.md @@ -51,6 +51,8 @@ json与struct之间转换处理工具使用示例 2021/01/07：新增copier源码阅读和单测代码 +2021/01/27:新增mapstructure源码阅读和单测代码 + # mod vendor模式加载包 通过go mod的方式加载的github上面的包会有报红的问题，但是包本身是可以运行的，这样就是会有一个问题，如果你想要点击去看方法的内容，没办法做到