header key 信息增加cache-control 与 connection

Reviewed-on: #3

data_type.go

@@ -14,12 +14,12 @@ package consts
 // Date : 14:10 2024/11/25
 type DataType string
 
-func (df *DataType) String() string {
+func (df DataType) String() string {
-	return string(*df)
+	return string(df)
 }
 
-func (df *DataType) MarshalJSON() ([]byte, error) {
+func (df DataType) MarshalJSON() ([]byte, error) {
-	return []byte(df.String()), nil
+	return []byte(`"` + df.String() + `"`), nil
 }
 
 // IsValid 判断枚举值是否有效
@@ -27,22 +27,31 @@ func (df *DataType) MarshalJSON() ([]byte, error) {
 // Author : go_developer@163.com<白茶清欢>
 //
 // Date : 14:45 2024/11/25
-func (df *DataType) IsValid() bool {
+func (df DataType) IsValid() bool {
 	for _, item := range DataTypeList {
-		if item.Value == *df {
+		if item.Value == df || item.Value.String() == df.String() {
 			return true
 		}
 	}
 	return false
 }
 
-const (
+var (
 	DataTypeUnknown                      DataType = "unknown"                   // 位置数据类型
 	DataTypeNil                          DataType = "nil"                       // nil
 	DataTypePtr                          DataType = "ptr"                       // 指针
 	DataTypeInt                          DataType = "int"                       // int类型 -> int64
+	DataTypeInt8                         DataType = "int8"                      // int8类型
+	DataTypeInt16                        DataType = "int16"                     // int16类型
+	DataTypeInt32                        DataType = "int32"                     // int32类型
+	DataTypeInt64                        DataType = "int64"                     // int64类型
 	DataTypeUint                         DataType = "uint"                      // uint类型 -> uint64
-	DataTypeFloat                        DataType = "float"                     // float类型 -> float64
+	DataTypeUint8                        DataType = "uint8"                     // uint8类型
+	DataTypeUint16                       DataType = "uint16"                    // uint16类型
+	DataTypeUint32                       DataType = "uint32"                    // uint32类型
+	DataTypeUint64                       DataType = "uint64"                    // uint64类型
+	DataTypeFloat32                      DataType = "float32"                   // float32类型
+	DataTypeFloat64                      DataType = "float64"                   // float64类型
 	DataTypeBool                         DataType = "bool"                      // bool类型
 	DataTypeString                       DataType = "string"                    // 字符串类型
 	DataTypeSliceAny                     DataType = "[]any"                     // any数组 -> []any
@@ -67,7 +76,7 @@ const (
 	DataTypeSliceMapAnyAny               DataType = "[]map[any]any"             // 字符串数组 -> []map[any]any, slice对象
 	DataTypeSliceMapAnyAnyWithMarshal    DataType = "[]map[any]any_marshal"     // 字符串数组 -> []map[any]any, json序列化后的结果
 	DataTypeSliceMapStringAny            DataType = "[]map[string]any"          // 字符串数组 -> map[string]any, slice对象
-	DataTypeSliceMapStringAnyWithMarshal          = "[]map[string]any_marshal"  // 字符串数组 -> []map[string]any, slice对象, json序列化之后的结果
+	DataTypeSliceMapStringAnyWithMarshal DataType = "[]map[string]any_marshal"  // 字符串数组 -> []map[string]any, slice对象, json序列化之后的结果
 	DataTypeMapStrInt                    DataType = "map[string]int"            // map -> map[string]int64
 	DataTypeMapStrIntWithMarshal         DataType = "map[string]int_marshal"    // map -> map[string]int64,json序列化之后的结果
 	DataTypeMapStrUint                   DataType = "map[string]uint"           // map -> map[string]uint64
@@ -87,8 +96,17 @@ const (
 	DataTypeAny                          DataType = "any"                       // 任意类型 -> any
 	DataTypeStringPtr                    DataType = "string_ptr"                // *string, 字符串指针
 	DataTypeIntPtr                       DataType = "int_ptr"                   // *int64, int64指针
+	DataTypeInt8Ptr                      DataType = "int8_ptr"                  // *int8, int8指针
+	DataTypeInt16Ptr                     DataType = "int16_ptr"                 // *int16, int16指针
+	DataTypeInt32Ptr                     DataType = "int32_ptr"                 // *int32, int32指针
+	DataTypeInt64Ptr                     DataType = "int64_ptr"                 // *int64, int64指针
 	DataTypeUintPtr                      DataType = "uint_ptr"                  // *uint64, uint64指针
-	DataTypeFloatPtr                     DataType = "float_ptr"                 // *float64, float64指针
+	DataTypeUint8Ptr                     DataType = "uint8_ptr"                 // *uint8, uint8指针
+	DataTypeUint16Ptr                    DataType = "uint16_ptr"                // *uint16, uint16指针
+	DataTypeUint32Ptr                    DataType = "uint32_ptr"                // *uint32, uint32指针
+	DataTypeUint64Ptr                    DataType = "uint64_ptr"                // *uint64, uint64指针
+	DataTypeFloat32Ptr                   DataType = "float32_ptr"               // *float32, float32指针
+	DataTypeFloat64Ptr                   DataType = "float64_ptr"               // *float64, float64指针
 	DataTypeBoolPtr                      DataType = "bool_ptr"                  // *bool, 字符串指针
 )
 
@@ -125,9 +143,18 @@ var (
 	DataTypeList = []DataTypeDesc{
 		// 基础数据类型
 		getDataTypeDesc(DataTypeAny, "任意数据类型"),
-		getDataTypeDesc(DataTypeInt, "int类型 -> int64"),
+		getDataTypeDesc(DataTypeInt, "int类型"),
-		getDataTypeDesc(DataTypeUint, "uint类型 -> uint64"),
+		getDataTypeDesc(DataTypeInt8, "int8类型"),
-		getDataTypeDesc(DataTypeFloat, "float类型 -> float64"),
+		getDataTypeDesc(DataTypeInt16, "int16类型"),
+		getDataTypeDesc(DataTypeInt32, "int32类型"),
+		getDataTypeDesc(DataTypeInt64, "int64类型"),
+		getDataTypeDesc(DataTypeUint, "uint类型"),
+		getDataTypeDesc(DataTypeUint8, "uint8类型"),
+		getDataTypeDesc(DataTypeUint16, "uint16类型"),
+		getDataTypeDesc(DataTypeUint32, "uint32类型"),
+		getDataTypeDesc(DataTypeUint64, "uint64类型"),
+		getDataTypeDesc(DataTypeFloat32, "float32类型"),
+		getDataTypeDesc(DataTypeFloat64, "float64类型"),
 		getDataTypeDesc(DataTypeBool, "bool类型"),
 		getDataTypeDesc(DataTypeString, "字符串类型"),
 
@@ -176,9 +203,18 @@ var (
 
 		// 基础类型的指针类型
 		getDataTypeDesc(DataTypeStringPtr, "*string, 字符串指针"),
-		getDataTypeDesc(DataTypeUintPtr, "*int64, int64指针"),
+		getDataTypeDesc(DataTypeUintPtr, "*uint, uint指针"),
-		getDataTypeDesc(DataTypeIntPtr, "*int64, *uint64, uint64指针"),
+		getDataTypeDesc(DataTypeUintPtr, "*uint8, uint8指针"),
-		getDataTypeDesc(DataTypeFloatPtr, "*float64, float64指针"),
+		getDataTypeDesc(DataTypeUintPtr, "*uint16, uint16指针"),
+		getDataTypeDesc(DataTypeUintPtr, "*uint32, uint32指针"),
+		getDataTypeDesc(DataTypeUintPtr, "*uint64, uint64指针"),
+		getDataTypeDesc(DataTypeIntPtr, "*int, int指针"),
+		getDataTypeDesc(DataTypeIntPtr, "*int8, int8指针"),
+		getDataTypeDesc(DataTypeIntPtr, "*int16, int16指针"),
+		getDataTypeDesc(DataTypeIntPtr, "*int32, int32指针"),
+		getDataTypeDesc(DataTypeIntPtr, "*int64, int64指针"),
+		getDataTypeDesc(DataTypeFloat32Ptr, "*float32, float32指针"),
+		getDataTypeDesc(DataTypeFloat32Ptr, "*float64, float64指针"),
 		getDataTypeDesc(DataTypeBoolPtr, "*bool, 字符串指针"),
 	}
 )
@@ -197,10 +233,23 @@ func getDataTypeDesc(value DataType, description string) DataTypeDesc {
 
 var (
 	// DataTypeBaseNumber 基础的int类型
-	DataTypeBaseNumber   = []DataType{DataTypeInt, DataTypeUint, DataTypeFloat, DataTypeIntPtr, DataTypeUintPtr, DataTypeFloatPtr}
+	DataTypeBaseNumber = []DataType{
-	DataTypeBaseInt      = []DataType{DataTypeInt, DataTypeIntPtr}
+		DataTypeInt, DataTypeInt8, DataTypeInt16, DataTypeInt32, DataTypeInt64,
-	DataTypeBaseUint     = []DataType{DataTypeUint, DataTypeUintPtr}
+		DataTypeUint, DataTypeUint8, DataTypeUint16, DataTypeUint32, DataTypeUint64,
-	DataTypeBaseFloat    = []DataType{DataTypeFloat, DataTypeFloatPtr}
+		DataTypeFloat32, DataTypeFloat64,
+		DataTypeIntPtr, DataTypeInt8Ptr, DataTypeInt16Ptr, DataTypeInt32Ptr, DataTypeInt64Ptr,
+		DataTypeUintPtr, DataTypeUint8Ptr, DataTypeUint16Ptr, DataTypeUint32Ptr, DataTypeUint64Ptr,
+		DataTypeFloat32Ptr, DataTypeFloat64Ptr,
+	}
+	DataTypeBaseInt = []DataType{
+		DataTypeInt, DataTypeInt8, DataTypeInt16, DataTypeInt32, DataTypeInt64,
+		DataTypeIntPtr, DataTypeInt8Ptr, DataTypeInt16Ptr, DataTypeInt32Ptr, DataTypeInt64Ptr,
+	}
+	DataTypeBaseUint = []DataType{
+		DataTypeUint, DataTypeUint8, DataTypeUint16, DataTypeUint32, DataTypeUint64,
+		DataTypeUintPtr, DataTypeUint8Ptr, DataTypeUint16Ptr, DataTypeUint32Ptr, DataTypeUint64Ptr,
+	}
+	DataTypeBaseFloat    = []DataType{DataTypeFloat32, DataTypeFloat64, DataTypeFloat32Ptr, DataTypeFloat64Ptr}
 	DataTypeBaseString   = []DataType{DataTypeString, DataTypeStringPtr}
 	DataTypeBaseBool     = []DataType{DataTypeBool, DataTypeBoolPtr}
 	DataTypeSliceMarshal = []DataType{
@@ -261,3 +310,123 @@ func getMergeDataTypeList(dataTypeList ...[]DataType) []DataType {
 	}
 	return res
 }
+
+// GetDataTypeDefaultValue 获取不同类型的默认值
+func GetDataTypeDefaultValue(dataType DataType) any {
+	switch dataType {
+	case DataTypeInt:
+		return int(0)
+	case DataTypeInt8:
+		return int8(0)
+	case DataTypeInt16:
+		return int16(0)
+	case DataTypeInt32:
+		return int32(0)
+	case DataTypeInt64:
+		return int64(0)
+	case DataTypeUint:
+		return uint(0)
+	case DataTypeUint8:
+		return uint8(0)
+	case DataTypeUint16:
+		return uint16(0)
+	case DataTypeUint32:
+		return uint32(0)
+	case DataTypeUint64:
+		return uint64(0)
+	case DataTypeFloat32:
+		return float32(0)
+	case DataTypeFloat64:
+		return float64(0)
+	case DataTypeBool:
+		return false
+	case DataTypeString:
+		return ""
+	case DataTypeIntPtr:
+		return new(int)
+	case DataTypeInt8Ptr:
+		return new(int8)
+	case DataTypeInt16Ptr:
+		return new(int16)
+	case DataTypeInt32Ptr:
+		return new(int32)
+	case DataTypeInt64Ptr:
+		return new(int64)
+	case DataTypeUintPtr:
+		return new(uint)
+	case DataTypeUint8Ptr:
+		return new(uint8)
+	case DataTypeUint16Ptr:
+		return new(uint16)
+	case DataTypeUint32Ptr:
+		return new(uint32)
+	case DataTypeUint64Ptr:
+		return new(uint64)
+	case DataTypeFloat32Ptr:
+		return new(float32)
+	case DataTypeFloat64Ptr:
+		return new(float64)
+	case DataTypeBoolPtr:
+		return new(bool)
+	case DataTypeMapStrAny:
+		return map[string]any{}
+	case DataTypeMapAnyAny:
+		return map[any]any{}
+	case DataTypeMapStrBool:
+		return map[string]bool{}
+	case DataTypeMapStrInt:
+		return map[string]int{}
+	case DataTypeMapStrFloat:
+		return map[string]float64{}
+	case DataTypeMapStrUint:
+		return map[string]uint{}
+	case DataTypeMapStrSlice:
+		return map[string][]any{}
+	case DataTypeMapStrStr:
+		return map[string]string{}
+	case DataTypeSliceAny:
+		return []any{}
+	case DataTypeSliceString:
+		return []string{}
+	case DataTypeSliceBool:
+		return []bool{}
+	case DataTypeSliceInt:
+		return []int{}
+	case DataTypeSliceUint:
+		return []uint{}
+	case DataTypeSliceFloat:
+		return []float64{}
+	case DataTypeSliceMapAnyAny:
+		// map[any]any 序列化会有问题，当做 map[string]any 处理
+		return []map[string]any{}
+	case DataTypeSliceMapStringAny:
+		return []map[string]any{}
+	default:
+		// 序列化之后的map
+		for _, dataTypeItem := range DataTypeMapMarshal {
+			if dataTypeItem == dataType {
+				return "{}"
+			}
+		}
+		// 序列化之后的slice
+		for _, dataTypeItem := range DataTypeSliceMarshal {
+			if dataTypeItem == dataType {
+				return "[]"
+			}
+		}
+		// 指定分隔符分割的slice
+		for _, dataTypeItem := range DataTypeSliceSplit {
+			if dataTypeItem == dataType {
+				return ""
+			}
+		}
+		// 未枚举的slice类型用any接收
+		for _, dataTypeItem := range DataTypeSlice {
+			if dataTypeItem == dataType {
+				return []any{}
+			}
+		}
+	}
+	// 未枚举的一律用any接收
+	return *new(any)
+}

data_type_test.go

@@ -0,0 +1,188 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 15:06
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestDataType_String(t *testing.T) {
+	Convey("data type 字符串值", t, func() {
+		byteData, err := json.Marshal(DataTypeString)
+		So(err, ShouldBeNil)
+		So(DataTypeString.String(), ShouldEqual, "string")
+		So(string(byteData), ShouldEqual, `"string"`)
+	})
+	Convey("data type MarshalJSON", t, func() {
+		str, err := DataTypeString.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"string"`)
+		dataList := []DataType{DataTypeString}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["string"]`)
+	})
+}
+
+func TestDataType_IsValid(t *testing.T) {
+	Convey("data type 非法验证", t, func() {
+		So(DataType("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("data type 合法验证", t, func() {
+		So(DataType("string").IsValid(), ShouldBeTrue)
+	})
+}
+
+func TestGetDataTypeDefaultValue(t *testing.T) {
+	Convey("int 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt), ShouldEqual, 0)
+	})
+	Convey("int8 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt8), ShouldEqual, int8(0))
+	})
+	Convey("int16 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt16), ShouldEqual, int16(0))
+	})
+	Convey("int32 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt32), ShouldEqual, int32(0))
+	})
+	Convey("int64 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt64), ShouldEqual, int64(0))
+	})
+	Convey("uint 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint), ShouldEqual, uint(0))
+	})
+	Convey("uint8 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint8), ShouldEqual, uint8(0))
+	})
+	Convey("uint16 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint16), ShouldEqual, uint16(0))
+	})
+	Convey("uint32 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint32), ShouldEqual, uint32(0))
+	})
+	Convey("uint64 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint64), ShouldEqual, uint64(0))
+	})
+	Convey("float32 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeFloat32), ShouldEqual, float32(0))
+	})
+	Convey("uint64 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeFloat64), ShouldEqual, float64(0))
+	})
+	Convey("bool 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeBool), ShouldBeFalse)
+	})
+	Convey("string 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeString), ShouldBeEmpty)
+	})
+	Convey("IntPtr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeIntPtr), ShouldEqual, new(int))
+	})
+	Convey("Int8Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt8Ptr), ShouldEqual, new(int8))
+	})
+	Convey("Int16Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt16Ptr), ShouldEqual, new(int16))
+	})
+	Convey("Int32Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt32Ptr), ShouldEqual, new(int32))
+	})
+	Convey("Int64Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeInt64Ptr), ShouldEqual, new(int64))
+	})
+	Convey("UintPtr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUintPtr), ShouldEqual, new(uint))
+	})
+	Convey("Uint8Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint8Ptr), ShouldEqual, new(uint8))
+	})
+	Convey("Uint16Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint16Ptr), ShouldEqual, new(uint16))
+	})
+	Convey("Uint32Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint32Ptr), ShouldEqual, new(uint32))
+	})
+	Convey("Uint64Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeUint64Ptr), ShouldEqual, new(uint64))
+	})
+	Convey("Float32Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeFloat32Ptr), ShouldEqual, new(float32))
+	})
+	Convey("Float64Ptr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeFloat64Ptr), ShouldEqual, new(float64))
+	})
+	Convey("BoolPtr 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeBoolPtr), ShouldEqual, new(bool))
+	})
+	Convey("map[string]any 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrAny), ShouldEqual, map[string]any{})
+	})
+	Convey("map[any]any 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapAnyAny), ShouldEqual, map[any]any{})
+	})
+	Convey("map[string]bool 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrBool), ShouldEqual, map[string]bool{})
+	})
+	Convey("map[string]int 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrInt), ShouldEqual, map[string]int{})
+	})
+	Convey("map[string]float 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrFloat), ShouldEqual, map[string]float64{})
+	})
+	Convey("map[string]uint 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrUint), ShouldEqual, map[string]uint{})
+	})
+	Convey("map[string]slice 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrSlice), ShouldEqual, map[string][]any{})
+	})
+	Convey("map[string]string 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrStr), ShouldEqual, map[string]string{})
+	})
+	Convey("[]any 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceAny), ShouldEqual, []any{})
+	})
+	Convey("[]string 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceString), ShouldEqual, []string{})
+	})
+	Convey("[]bool 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceBool), ShouldEqual, []bool{})
+	})
+	Convey("[]int 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceInt), ShouldEqual, []int{})
+	})
+	Convey("[]uint 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceUint), ShouldEqual, []uint{})
+	})
+	Convey("[]float 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceFloat), ShouldEqual, []float64{})
+	})
+	Convey("[]map[string]any 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceMapStringAny), ShouldEqual, []map[string]any{})
+	})
+	Convey("[]map[any]any 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceMapAnyAny), ShouldEqual, []map[string]any{})
+	})
+	Convey("map marshal 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeMapStrAnyWithMarshal), ShouldEqual, "{}")
+	})
+	Convey("slice marshal 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceBoolWithMarshal), ShouldEqual, "[]")
+	})
+	Convey("slice split 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceIntWithChar), ShouldEqual, "")
+	})
+	Convey("未枚举的alice 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataTypeSliceSlice), ShouldEqual, []any{})
+	})
+	Convey("unknown 默认值", t, func() {
+		So(GetDataTypeDefaultValue(DataType("unknown")), ShouldEqual, nil)
+	})
+}

database.go

@@ -30,3 +30,8 @@ const (
 	WhereOperateLike     = "like"      // like
 	WhereOperateNotLike  = "not_like"  // not like
 )
+
+const (
+	OrderRuleAsc  = "asc"  // 升序
+	OrderRuleDesc = "desc" // 降序
+)

enums/data_location.go

@@ -1,8 +0,0 @@
-// Package enums ...
-//
-// Description : enums ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2024-11-25 14:39
-package enums

enums/data_type.go

@@ -1,8 +0,0 @@
-// Package enums ...
-//
-// Description : enums ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 2024-11-25 14:08
-package enums

file_type.go

@@ -9,26 +9,17 @@ package consts
 
 type FileType string
 
-func (ft *FileType) String() string {
+func (ft FileType) String() string {
-	return string(*ft)
+	return string(ft)
 }
 
-func (ft *FileType) MarshalJSON() ([]byte, error) {
+func (ft FileType) MarshalJSON() ([]byte, error) {
-	return []byte(ft.String()), nil
+	return []byte(`"` + ft.String() + `"`), nil
 }
 
-func (ft *FileType) IsValid() bool {
+func (ft FileType) IsValid() bool {
-	supportFileTypeList := []FileType{
+	for _, fileType := range SupportFileTypeList {
-		FileTypeJson,
+		if fileType.Value == ft || fileType.Value.String() == ft.String() {
-		FileTypeIni,
-		FileTypeYml,
-		FileTypeYaml,
-		FileTypeToml,
-		FileTypeXml,
-		FileTypeTxt,
-	}
-	for _, fileType := range supportFileTypeList {
-		if fileType == *ft {
 			return true
 		}
 	}
@@ -45,3 +36,41 @@ const (
 	FileTypeTxt     FileType = "txt"     // txt格式文件
 	FileTypeUnknown FileType = "unknown" // 未知格式
 )
+
+type FileTypeDesc struct {
+	Value FileType
+	Desc  string
+}
+
+var (
+	SupportFileTypeList = []FileTypeDesc{
+		{
+			Value: FileTypeJson,
+			Desc:  "json格式文件",
+		},
+		{
+			Value: FileTypeIni,
+			Desc:  "init格式文件",
+		},
+		{
+			Value: FileTypeYml,
+			Desc:  "yml格式文件",
+		},
+		{
+			Value: FileTypeYaml,
+			Desc:  "yaml格式文件",
+		},
+		{
+			Value: FileTypeToml,
+			Desc:  "toml格式文件",
+		},
+		{
+			Value: FileTypeTxt,
+			Desc:  "txt格式文件",
+		},
+		{
+			Value: FileTypeXml,
+			Desc:  "xml格式文件",
+		},
+	}
+)

file_type_test.go

@@ -0,0 +1,41 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 15:17
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestFileType_String(t *testing.T) {
+	Convey("file type 字符串值", t, func() {
+		byteData, err := json.Marshal(FileTypeJson)
+		So(err, ShouldBeNil)
+		So(FileTypeJson.String(), ShouldEqual, "json")
+		So(string(byteData), ShouldEqual, `"json"`)
+	})
+	Convey("file type MarshalJSON", t, func() {
+		str, err := FileTypeJson.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"json"`)
+		dataList := []FileType{FileTypeJson}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["json"]`)
+	})
+}
+
+func TestFileType_IsValid(t *testing.T) {
+	Convey("file type 非法验证", t, func() {
+		So(FileType("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("file type 合法验证", t, func() {
+		So(FileType("json").IsValid(), ShouldBeTrue)
+	})
+}

go.mod

@@ -1,3 +1,13 @@
 module git.zhangdeman.cn/zhangdeman/consts
 
-go 1.19
+go 1.23.0
+
+toolchain go1.24.2
+
+require github.com/smartystreets/goconvey v1.8.1
+
+require (
+	github.com/gopherjs/gopherjs v1.17.2 // indirect
+	github.com/jtolds/gls v4.20.0+incompatible // indirect
+	github.com/smarty/assertions v1.15.0 // indirect
+)

go.sum

@@ -0,0 +1,8 @@
+github.com/gopherjs/gopherjs v1.17.2 h1:fQnZVsXk8uxXIStYb0N4bGk7jeyTalG/wsZjQ25dO0g=
+github.com/gopherjs/gopherjs v1.17.2/go.mod h1:pRRIvn/QzFLrKfvEz3qUuEhtE/zLCWfreZ6J5gM2i+k=
+github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/smarty/assertions v1.15.0 h1:cR//PqUBUiQRakZWqBiFFQ9wb8emQGDb0HeGdqGByCY=
+github.com/smarty/assertions v1.15.0/go.mod h1:yABtdzeQs6l1brC900WlRNwj6ZR55d7B+E8C6HtKdec=
+github.com/smartystreets/goconvey v1.8.1 h1:qGjIddxOk4grTu9JPOU31tVfq3cNdBlNa5sSznIX1xY=
+github.com/smartystreets/goconvey v1.8.1/go.mod h1:+/u4qLyY6x1jReYOp7GOM2FSt8aP9CzCZL03bI28W60=

header.go

@@ -9,12 +9,12 @@ package consts
 
 type HttpHeader string
 
-func (hh *HttpHeader) String() string {
+func (hh HttpHeader) String() string {
-	return string(*hh)
+	return string(hh)
 }
 
-func (hh *HttpHeader) MarshalJSON() ([]byte, error) {
+func (hh HttpHeader) MarshalJSON() ([]byte, error) {
-	return []byte(hh.String()), nil
+	return []byte(`"` + hh.String() + `"`), nil
 }
 
 const (
@@ -24,3 +24,18 @@ const (
 	HeaderKeyAccessControlExposeHeaders HttpHeader = "Access-Control-Expose-Headers" // 允许浏览器端能够获取相应的header值
 	HeaderKeyAccessControlMaxAge        HttpHeader = "Access-Control-Max-Age"        // 控制发送预检请求options的频率，单位 : 秒
 )
+
+const (
+	HeaderKeyContentType    HttpHeader = "Content-Type"    // 请求头中Content-Type的key
+	HeaderKeyCacheControl   HttpHeader = "Cache-Control"   // 禁用缓存
+	HeaderKeyConnection     HttpHeader = "Connection"      // 连接信息
+	HeaderKeyReferer        HttpHeader = "Referer"         // 请求头中Referer的key
+	HeaderKeyUserAgent      HttpHeader = "User-Agent"      // 请求头中User-Agent的key
+	HeaderKeyAccept         HttpHeader = "Accept"          // accept
+	HeaderKeyAcceptEncoding HttpHeader = "Accept-Encoding" // accept-encoding
+	HeaderKeyAcceptLanguage HttpHeader = "Accept-Language" // accept-language
+	HeaderKeyAuthorization  HttpHeader = "Authorization"   // authorization
+	HeaderKeyCookie         HttpHeader = "Cookie"          // cookie
+	HeaderKeyOrigin         HttpHeader = "Origin"          // origin
+	HeaderKeyHost           HttpHeader = "Host"            // host
+)

header_test.go

@@ -0,0 +1,32 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 14:22
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestHttpHeader_String(t *testing.T) {
+	Convey("http header字符串值", t, func() {
+		byteData, err := json.Marshal(HeaderKeyContentType)
+		So(err, ShouldBeNil)
+		So(HeaderKeyContentType.String(), ShouldEqual, "Content-Type")
+		So(string(byteData), ShouldEqual, `"Content-Type"`)
+	})
+	Convey("http header MarshalJSON", t, func() {
+		str, err := HeaderKeyContentType.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"Content-Type"`)
+		dataList := []HttpHeader{HeaderKeyContentType}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["Content-Type"]`)
+	})
+}

http_code.go

@@ -0,0 +1,112 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-19 12:38
+package consts
+
+import (
+	"fmt"
+	"net/http"
+)
+
+type HttpCode struct {
+	Value any    `json:"value"`
+	Code  int    `json:"code"`
+	Desc  string `json:"desc"`
+}
+
+func newHttpCodeData(httpCode int) HttpCode {
+	desc := http.StatusText(httpCode)
+	if len(desc) == 0 {
+		if httpCode == 499 {
+			desc = "client request timeout"
+		} else {
+			desc = fmt.Sprintf("%v: unknown error", httpCode)
+		}
+	}
+	return HttpCode{
+		Value: httpCode,
+		Code:  httpCode,
+		Desc:  desc,
+	}
+}
+
+var (
+	HttpCodeList = []HttpCode{
+		// 1xx
+		newHttpCodeData(http.StatusContinue),
+		newHttpCodeData(http.StatusSwitchingProtocols),
+		newHttpCodeData(http.StatusProcessing),
+		newHttpCodeData(http.StatusEarlyHints),
+
+		// 2xx
+		newHttpCodeData(http.StatusOK),
+		newHttpCodeData(http.StatusCreated),
+		newHttpCodeData(http.StatusAccepted),
+		newHttpCodeData(http.StatusNonAuthoritativeInfo),
+		newHttpCodeData(http.StatusNoContent),
+		newHttpCodeData(http.StatusResetContent),
+		newHttpCodeData(http.StatusPartialContent),
+		newHttpCodeData(http.StatusMultiStatus),
+		newHttpCodeData(http.StatusAlreadyReported),
+		newHttpCodeData(http.StatusIMUsed),
+
+		// 3xx
+		newHttpCodeData(http.StatusMultipleChoices),
+		newHttpCodeData(http.StatusMovedPermanently),
+		newHttpCodeData(http.StatusFound),
+		newHttpCodeData(http.StatusSeeOther),
+		newHttpCodeData(http.StatusNotModified),
+		newHttpCodeData(http.StatusUseProxy),
+		newHttpCodeData(http.StatusTemporaryRedirect),
+		newHttpCodeData(http.StatusPermanentRedirect),
+
+		// 4xx
+		newHttpCodeData(http.StatusBadRequest),
+		newHttpCodeData(http.StatusUnauthorized),
+		newHttpCodeData(http.StatusPaymentRequired),
+		newHttpCodeData(http.StatusForbidden),
+		newHttpCodeData(http.StatusNotFound),
+		newHttpCodeData(http.StatusMethodNotAllowed),
+		newHttpCodeData(http.StatusNotAcceptable),
+		newHttpCodeData(http.StatusProxyAuthRequired),
+		newHttpCodeData(http.StatusRequestTimeout),
+		newHttpCodeData(http.StatusConflict),
+		newHttpCodeData(http.StatusGone),
+		newHttpCodeData(http.StatusLengthRequired),
+		newHttpCodeData(http.StatusPreconditionFailed),
+		newHttpCodeData(http.StatusRequestEntityTooLarge),
+		newHttpCodeData(http.StatusRequestURITooLong),
+		newHttpCodeData(http.StatusUnsupportedMediaType),
+		newHttpCodeData(http.StatusRequestedRangeNotSatisfiable),
+		newHttpCodeData(http.StatusExpectationFailed),
+		newHttpCodeData(http.StatusTeapot),
+		newHttpCodeData(http.StatusMisdirectedRequest),
+		newHttpCodeData(http.StatusUnprocessableEntity),
+		newHttpCodeData(http.StatusLocked),
+		newHttpCodeData(http.StatusFailedDependency),
+		newHttpCodeData(http.StatusTooEarly),
+		newHttpCodeData(http.StatusUpgradeRequired),
+		newHttpCodeData(http.StatusPreconditionRequired),
+		newHttpCodeData(http.StatusTooManyRequests),
+		newHttpCodeData(http.StatusRequestHeaderFieldsTooLarge),
+		newHttpCodeData(http.StatusUnavailableForLegalReasons),
+		newHttpCodeData(499),
+
+		// 5xx
+		newHttpCodeData(http.StatusInternalServerError),
+		newHttpCodeData(http.StatusNotImplemented),
+		newHttpCodeData(http.StatusBadGateway),
+		newHttpCodeData(http.StatusServiceUnavailable),
+		newHttpCodeData(http.StatusGatewayTimeout),
+		newHttpCodeData(http.StatusHTTPVersionNotSupported),
+		newHttpCodeData(http.StatusVariantAlsoNegotiates),
+		newHttpCodeData(http.StatusInsufficientStorage),
+		newHttpCodeData(http.StatusLoopDetected),
+		newHttpCodeData(http.StatusNotExtended),
+		newHttpCodeData(http.StatusNetworkAuthenticationRequired),
+	}
+)

http_code_test.go

@@ -0,0 +1,27 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 15:29
+package consts
+
+import (
+	. "github.com/smartystreets/goconvey/convey"
+	"strings"
+	"testing"
+)
+
+func Test_newHttpCodeData(t *testing.T) {
+	Convey("newHttpCode 验证", t, func() {
+		hCode := newHttpCodeData(499)
+		So(hCode.Code, ShouldEqual, 499)
+		So(hCode.Desc, ShouldEqual, "client request timeout")
+		So(hCode.Value, ShouldEqual, 499)
+		hCode = newHttpCodeData(4990)
+		So(hCode.Code, ShouldEqual, 4990)
+		So(strings.Contains(hCode.Desc, "unknown error"), ShouldBeTrue)
+		So(hCode.Value, ShouldEqual, 4990)
+	})
+}

logger.go

@@ -9,15 +9,15 @@ package consts
 
 type LogLevel string
 
-func (ll *LogLevel) String() string {
+func (ll LogLevel) String() string {
-	return string(*ll)
+	return string(ll)
 }
 
-func (ll *LogLevel) MarshalJSON() ([]byte, error) {
+func (ll LogLevel) MarshalJSON() ([]byte, error) {
-	return []byte(ll.String()), nil
+	return []byte(`"` + ll.String() + `"`), nil
 }
 
-func (ll *LogLevel) IsValid() bool {
+func (ll LogLevel) IsValid() bool {
 	levelList := []LogLevel{
 		LogLevelDebug,
 		LogLevelInfo,
@@ -26,7 +26,7 @@ func (ll *LogLevel) IsValid() bool {
 		LogLevelPanic,
 	}
 	for _, level := range levelList {
-		if level == *ll {
+		if level == ll {
 			return true
 		}
 	}
@@ -47,18 +47,12 @@ func (ls LogSplit) String() string {
 	return string(ls)
 }
 func (ls LogSplit) MarshalJSON() ([]byte, error) {
-	return []byte(ls.String()), nil
+	return []byte(`"` + ls.String() + `"`), nil
 }
 
 func (ls LogSplit) IsValid() bool {
-	supportSplitList := []LogSplit{
+	for _, supportSplit := range SupportLogSplitList {
-		LogSplitHour,
+		if supportSplit.Value == ls || supportSplit.Value.String() == ls.String() {
-		LogSplitDay,
-		LogSplitMonth,
-		LogSplitYear,
-	}
-	for _, supportSplit := range supportSplitList {
-		if supportSplit == ls {
 			return true
 		}
 	}
@@ -72,6 +66,32 @@ const (
 	LogSplitYear  LogSplit = "YEAR"
 )
 
+type LogSplitDesc struct {
+	Value LogSplit `json:"value"`
+	Desc  string   `json:"desc"`
+}
+
+var (
+	SupportLogSplitList = []LogSplitDesc{
+		{
+			Value: LogSplitHour,
+			Desc:  "按小时切割",
+		},
+		{
+			Value: LogSplitDay,
+			Desc:  "按天切割",
+		},
+		{
+			Value: LogSplitMonth,
+			Desc:  "按月切割",
+		},
+		{
+			Value: LogSplitYear,
+			Desc:  "按年切割",
+		},
+	}
+)
+
 const (
 	LogPathDefault = "logs"
 )

logger_test.go

@@ -9,11 +9,60 @@ package consts
 
 import (
 	"encoding/json"
-	"fmt"
+	. "github.com/smartystreets/goconvey/convey"
 	"testing"
 )
 
 func TestLogLevel_String(t *testing.T) {
-	byteData, err := json.Marshal(LogLevelDebug)
+	Convey("logger type字符串值", t, func() {
-	fmt.Println(string(byteData), err)
+		byteData, err := json.Marshal(LogLevelDebug)
+		So(err, ShouldBeNil)
+		So(LogLevelDebug.String(), ShouldEqual, "DEBUG")
+		So(string(byteData), ShouldEqual, `"DEBUG"`)
+	})
+	Convey("logger type MarshalJSON", t, func() {
+		str, err := LogLevelDebug.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"DEBUG"`)
+		dataList := []LogLevel{LogLevelDebug}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["DEBUG"]`)
+	})
+}
+
+func TestLogLevel_IsValid(t *testing.T) {
+	Convey("logger type 非法验证", t, func() {
+		So(LogLevel("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("logger type 合法验证", t, func() {
+		So(LogLevelDebug.IsValid(), ShouldBeTrue)
+	})
+}
+
+func TestLogSplit_String(t *testing.T) {
+	Convey("logger split 字符串值", t, func() {
+		byteData, err := json.Marshal(LogSplitHour)
+		So(err, ShouldBeNil)
+		So(LogSplitHour.String(), ShouldEqual, "HOUR")
+		So(string(byteData), ShouldEqual, `"HOUR"`)
+	})
+	Convey("logger split MarshalJSON", t, func() {
+		str, err := LogSplitHour.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"HOUR"`)
+		dataList := []LogSplit{LogSplitHour}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["HOUR"]`)
+	})
+}
+
+func TestLogSplit_IsValid(t *testing.T) {
+	Convey("logger split 非法验证", t, func() {
+		So(LogSplit("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("logger split 合法验证", t, func() {
+		So(LogSplit("HOUR").IsValid(), ShouldBeTrue)
+	})
 }

mime_type.go

@@ -96,6 +96,8 @@ const (
 	MimeTypeImagePng = "image/png"
 	// MimeTypeJson json数据格式
 	MimeTypeJson = "application/json"
+	// MimeTypeTextPlain text/plain
+	MimeTypeTextPlain = "text/plain"
 	// MimeTypeXWWWFormUrlencoded  <form encType=””>中默认的encType，form表单数据被编码为key/value格式发送到服务器（表单默认的提交数据的格式）
 	MimeTypeXWWWFormUrlencoded = "application/x-www-form-urlencoded"
 	// MimeTypeXml xml请求方式

redis.go

@@ -9,11 +9,15 @@ package consts
 
 type RedisCmd string
 
-func (rc *RedisCmd) String() string {
+func (rc RedisCmd) String() string {
-	return string(*rc)
+	return string(rc)
 }
 
-func (rc *RedisCmd) MarshalJSON() ([]byte, error) {
+func (rc RedisCmd) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + rc.String() + `"`), nil
+}
+
+func (rc RedisCmd) MarshalBinary() ([]byte, error) {
 	return []byte(rc.String()), nil
 }
 

redis_test.go

@@ -0,0 +1,38 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 13:29
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+// RedisCmd_String 序列换 RedisCmd
+func TestRedisCmd_String(t *testing.T) {
+	Convey("redis cmd字符串值", t, func() {
+		byteData, err := json.Marshal(RedisCommandSet)
+		So(err, ShouldBeNil)
+		So(RedisCommandSet.String(), ShouldEqual, "SET")
+		So(string(byteData), ShouldEqual, `"SET"`)
+	})
+	Convey("redis cmd MarshalJSON", t, func() {
+		str, err := RedisCommandSet.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"SET"`)
+		dataList := []RedisCmd{RedisCommandSet}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["SET"]`)
+	})
+	Convey("redis cmd MarshalBinary", t, func() {
+		str, err := RedisCommandSet.MarshalBinary()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `SET`)
+	})
+}

request.go

@@ -19,36 +19,12 @@ func (rdl RequestDataLocation) String() string {
 }
 
 func (rdl RequestDataLocation) MarshalJSON() ([]byte, error) {
-	return []byte(rdl.String()), nil
+	return []byte(`"` + rdl.String() + `"`), nil
 }
 
 func (rdl RequestDataLocation) IsValid() bool {
 	for _, item := range RequestDataLocationList {
-		if item.Value == rdl {
+		if item.Value == rdl || item.Value.String() == rdl.String() {
-			return true
-		}
-	}
-	return false
-}
-
-// ResponseDataLocation 响应数据所在位置
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 14:41 2024/11/25
-type ResponseDataLocation string
-
-func (rdl *ResponseDataLocation) String() string {
-	return string(*rdl)
-}
-
-func (rdl *ResponseDataLocation) MarshalJSON() ([]byte, error) {
-	return []byte(rdl.String()), nil
-}
-
-func (rdl *ResponseDataLocation) IsValid() bool {
-	for _, item := range ResponseDataLocationList {
-		if item.Value == *rdl {
 			return true
 		}
 	}
@@ -62,9 +38,34 @@ const (
 	RequestDataLocationQuery        RequestDataLocation = "QUERY"         // query
 	RequestDataLocationUriPath      RequestDataLocation = "URI_PATH"      // uri路由一部分
 	RequestDataLocationStatic       RequestDataLocation = "STATIC"        // 静态配置的参数
+	RequestDataLocationAny          RequestDataLocation = "ANY"           // 任意位置,要求服务支持从各种位置自动读取
 	RequestDataLocationCustomConfig RequestDataLocation = "CUSTOM_CONFIG" // 针对接口的一些自定义配置规则
 )
 
+// ResponseDataLocation 响应数据所在位置
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 14:41 2024/11/25
+type ResponseDataLocation string
+
+func (rdl ResponseDataLocation) String() string {
+	return string(rdl)
+}
+
+func (rdl ResponseDataLocation) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + rdl.String() + `"`), nil
+}
+
+func (rdl ResponseDataLocation) IsValid() bool {
+	for _, item := range ResponseDataLocationList {
+		if item.Value == rdl || item.Value.String() == rdl.String() {
+			return true
+		}
+	}
+	return false
+}
+
 const (
 	ResponseDataLocationHeader    ResponseDataLocation = "HEADER"    // header
 	ResponseDataLocationCookie    ResponseDataLocation = "COOKIE"    // cookie
@@ -90,6 +91,7 @@ var (
 		{Value: RequestDataLocationBody, Description: "请求body"},
 		{Value: RequestDataLocationQuery, Description: "请求query"},
 		{Value: RequestDataLocationUriPath, Description: "请求uri_path"},
+		{Value: RequestDataLocationAny, Description: "任意位置,要求服务本身支持"},
 		{Value: RequestDataLocationStatic, Description: "静态参数配置"},
 		{Value: RequestDataLocationCustomConfig, Description: "自定义接口处理规则"},
 	}

request_test.go

@@ -0,0 +1,68 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 14:37
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestRequestDataLocation_String(t *testing.T) {
+	Convey("request data location字符串值", t, func() {
+		byteData, err := json.Marshal(RequestDataLocationBody)
+		So(err, ShouldBeNil)
+		So(RequestDataLocationBody.String(), ShouldEqual, "BODY")
+		So(string(byteData), ShouldEqual, `"BODY"`)
+	})
+	Convey("request data location MarshalJSON", t, func() {
+		str, err := RequestDataLocationBody.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"BODY"`)
+		dataList := []RequestDataLocation{RequestDataLocationBody}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["BODY"]`)
+	})
+}
+
+func TestRequestDataLocation_IsValid(t *testing.T) {
+	Convey("request data location 非法验证", t, func() {
+		So(RequestDataLocation("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("request data location 合法验证", t, func() {
+		So(RequestDataLocation("BODY").IsValid(), ShouldBeTrue)
+	})
+}
+
+func TestResponseDataLocation_String(t *testing.T) {
+	Convey("response data location字符串值", t, func() {
+		byteData, err := json.Marshal(ResponseDataLocationBody)
+		So(err, ShouldBeNil)
+		So(RequestDataLocationBody.String(), ShouldEqual, "BODY")
+		So(string(byteData), ShouldEqual, `"BODY"`)
+	})
+	Convey("response data location MarshalJSON", t, func() {
+		str, err := ResponseDataLocationBody.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"BODY"`)
+		dataList := []ResponseDataLocation{ResponseDataLocationBody}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["BODY"]`)
+	})
+}
+
+func TestResponseDataLocation_IsValid(t *testing.T) {
+	Convey("response data location 非法验证", t, func() {
+		So(ResponseDataLocation("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("response data location 合法验证", t, func() {
+		So(ResponseDataLocation("BODY").IsValid(), ShouldBeTrue)
+	})
+}

scheme.go

@@ -9,15 +9,15 @@ package consts
 
 type HttpScheme string
 
-func (hs *HttpScheme) String() string {
+func (hs HttpScheme) String() string {
-	return string(*hs)
+	return string(hs)
 }
 
-func (hs *HttpScheme) MarshalJSON() ([]byte, error) {
+func (hs HttpScheme) MarshalJSON() ([]byte, error) {
-	return []byte(hs.String()), nil
+	return []byte(`"` + hs.String() + `"`), nil
 }
 
-const (
+var (
 	SchemeHTTP  HttpScheme = "http"
 	SchemeHTTPS HttpScheme = "https"
 	SchemeWs    HttpScheme = "ws"

scheme_test.go

@@ -0,0 +1,32 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 15:47
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestHttpScheme_String(t *testing.T) {
+	Convey("scheme 字符串值", t, func() {
+		byteData, err := json.Marshal(SchemeHTTPS)
+		So(err, ShouldBeNil)
+		So(SchemeHTTPS.String(), ShouldEqual, "https")
+		So(string(byteData), ShouldEqual, `"https"`)
+	})
+	Convey("scheme MarshalJSON", t, func() {
+		str, err := SchemeHTTPS.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"https"`)
+		dataList := []HttpScheme{SchemeHTTPS}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["https"]`)
+	})
+}

swagger.go

@@ -24,7 +24,7 @@ const (
 )
 
 const (
-	SwaggerDocVersion2 = "2.0.0"
+	SwaggerDocVersion2 = "2.0"
 	SwaggerDocVersion3 = "3.0.0"
 )
 

validator.go

@@ -11,25 +11,22 @@ package consts
 
 type ValidatorRule string // 验证规则
 
-func (vr *ValidatorRule) String() string {
+func (vr ValidatorRule) String() string {
-	if nil == vr {
+	return string(vr)
-		return ""
-	}
-	return string(*vr)
 }
 
-func (vr *ValidatorRule) MarshalJSON() ([]byte, error) {
+func (vr ValidatorRule) MarshalJSON() ([]byte, error) {
-	return []byte(vr.String()), nil
+	return []byte(`"` + vr.String() + `"`), nil
 }
 
 // IsValid 验证规则是否有效
-func (vr *ValidatorRule) IsValid() bool {
+func (vr ValidatorRule) IsValid() bool {
-	_, exist := ValidatorRuleSupportDataTypeTable[*vr]
+	_, exist := ValidatorRuleSupportDataTypeTable[vr]
 	if !exist {
 		return false
 	}
-	rule := ValidatorRuleSupportDataTypeTable[*vr].ValidatorRule
+	rule := ValidatorRuleSupportDataTypeTable[vr].ValidatorRule
-	if vr.String() != (&rule).String() {
+	if vr.String() != rule.String() {
 		return false
 	}
 	return exist
@@ -40,8 +37,8 @@ func (vr *ValidatorRule) IsValid() bool {
 // Author : go_developer@163.com<白茶清欢>
 //
 // Date : 16:10 2025/1/22
-func (vr *ValidatorRule) Config() ValidatorRuleConfig {
+func (vr ValidatorRule) Config() ValidatorRuleConfig {
-	return ValidatorRuleSupportDataTypeTable[*vr]
+	return ValidatorRuleSupportDataTypeTable[vr]
 }
 
 // IsSupportDataType 是否支持指定的数据类型
@@ -49,7 +46,7 @@ func (vr *ValidatorRule) Config() ValidatorRuleConfig {
 // Author : go_developer@163.com<白茶清欢>
 //
 // Date : 16:11 2025/1/22
-func (vr *ValidatorRule) IsSupportDataType(dataType DataType) bool {
+func (vr ValidatorRule) IsSupportDataType(dataType DataType) bool {
 	dataTypeList := vr.Config().SupportDataTypeList
 	if len(dataTypeList) == 0 {
 		// 未配置则认为支持
@@ -291,6 +288,12 @@ var ValidatorRuleSupportDataTypeTable = map[ValidatorRule]ValidatorRuleConfig{
 		SupportDataTypeList: nil, // 所有类型均支持
 		WithoutParam:        true,
 	},
+	ValidatorRuleCommonOmitempty: {
+		ValidatorRule:       ValidatorRuleCommonOmitempty,
+		Description:         "为空时不进行其他校验",
+		SupportDataTypeList: nil, // 所有类型均支持
+		WithoutParam:        true,
+	},
 	ValidatorRuleCommonLen: {
 		ValidatorRule:       ValidatorRuleCommonLen,
 		Description:         "数据长度",
@@ -519,6 +522,7 @@ var (
 	ValidatorRuleCommonFilepath           ValidatorRule = "filepath"             // 文件路径
 	ValidatorRuleCommonImage              ValidatorRule = "image"                // 图像
 	ValidatorRuleCommonIsDefault          ValidatorRule = "isdefault"            // 是否默认值
+	ValidatorRuleCommonOmitempty          ValidatorRule = "omitempty"            // 为空忽略,比如，某些字段可以不传或者传空, 但是一旦传了则必须是制定枚举值, omitempty,oneof=a b
 	ValidatorRuleCommonLen                ValidatorRule = "len"                  // 长度 len={{uint_value}}
 	ValidatorRuleCommonMax                ValidatorRule = "max"                  // 最大值 max={{int_value}}
 	ValidatorRuleCommonMin                ValidatorRule = "min"                  // 最小值 min={{int_value}}

validator_test.go

@@ -0,0 +1,64 @@
+// Package consts ...
+//
+// Description : consts ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2025-04-20 17:37
+package consts
+
+import (
+	"encoding/json"
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestValidatorRule_String(t *testing.T) {
+	Convey("validate rule 字符串值", t, func() {
+		byteData, err := json.Marshal(ValidateRuleGt)
+		So(err, ShouldBeNil)
+		So(ValidateRuleGt.String(), ShouldEqual, "gt")
+		So(string(byteData), ShouldEqual, `"gt"`)
+	})
+	Convey("validate rule MarshalJSON", t, func() {
+		str, err := ValidateRuleGt.MarshalJSON()
+		So(err, ShouldBeNil)
+		So(string(str), ShouldEqual, `"gt"`)
+		dataList := []ValidatorRule{ValidateRuleGt}
+		jsonData, err := json.Marshal(dataList)
+		So(err, ShouldBeNil)
+		So(string(jsonData), ShouldEqual, `["gt"]`)
+	})
+}
+
+func TestValidatorRule_IsValid(t *testing.T) {
+	Convey("validator rule 不存在", t, func() {
+		So(ValidatorRule("Invalid").IsValid(), ShouldBeFalse)
+	})
+	Convey("validator rule 配置值错误", t, func() {
+		ValidatorRuleSupportDataTypeTable[ValidatorRule("Invalid")] = ValidatorRuleConfig{}
+		So(ValidatorRule("Invalid").IsValid(), ShouldBeFalse)
+		So(ValidatorRule("gt").IsValid(), ShouldBeTrue)
+	})
+	Convey("validator rule 配置值", t, func() {
+		So(ValidatorRuleGtcsfield.Config().MinParamCnt, ShouldEqual, 1)
+	})
+}
+
+func TestValidatorRule_IsSupportDataType(t *testing.T) {
+	Convey("validator rule 是否支持指定数据类型", t, func() {
+		So(ValidatorRuleGtcsfield.IsSupportDataType(DataTypeUint), ShouldBeTrue)
+		So(ValidatorRuleGtcsfield.IsSupportDataType(DataTypeString), ShouldBeFalse)
+	})
+	Convey("validator rule 未指定类型默认支持", t, func() {
+		So(ValidatorRuleCommonOmitempty.IsSupportDataType(DataTypeString), ShouldBeTrue)
+	})
+}
+
+func TestRegisterCustomValidatorRule(t *testing.T) {
+	Convey("注册自定义验证规则", t, func() {
+		RegisterCustomValidatorRule(ValidatorRule("Invalid"), ValidatorRuleConfig{})
+		_, exist := ValidatorRuleSupportDataTypeTable[ValidatorRule("Invalid")]
+		So(exist, ShouldBeTrue)
+	})
+}