update

httpcli/httpcli.go

@@ -53,6 +53,16 @@ type Client struct {
 	client *http.Client
 }
 
+// eg
+// NewClient(&http.Client{
+// 		Transport: &http.Transport{
+// 			MaxIdleConnsPerHost: 10,
+// 			MaxIdleConns:        20,               // 最大空闲连接数
+// 			IdleConnTimeout:     90 * time.Second, // 空闲连接超时时间
+// 			DisableCompression:  true,             // 禁用压缩（按需）
+// 		},
+// 	}),
+
 func NewClient(cli *http.Client) *Client {
 	return &Client{
 		client: cli,
@@ -137,6 +147,10 @@ func (x *Request) SetRetry(count uint) *Request {
 	x.retryCount = count
 	return x
 }
+func (x *Request) SetMethod(method string) *Request {
+	x.method = method
+	return x
+}
 func (x *Request) OmitLog() *Request {
 	x.omitLog = true
 	return x
@@ -423,6 +437,9 @@ func (x *Request) ReadRspBody() ([]byte, error) {
 
 // BindJSON parses the response's body as JSON
 func (x *Request) BindJSON(v interface{}) *Request {
+	if v == nil {
+		return x
+	}
 	if x.err != nil {
 		return x
 	}

utils/mapUtils/mapUtils.go

+package mapUtils
+
+import (
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/spf13/cast"
+)
+
+func MapToStruct(m map[string]interface{}, s interface{}) error {
+	data, err := json.Marshal(m)
+	if err != nil {
+		return fmt.Errorf("marshal error: %v", err)
+	}
+
+	if err := json.Unmarshal(data, s); err != nil {
+		return fmt.Errorf("unmarshal error: %v", err)
+	}
+	return nil
+}
+
+func MapToStructByReflect(m map[string]interface{}, s interface{}) error {
+	rv := reflect.ValueOf(s)
+	if rv.Kind() != reflect.Ptr || rv.IsNil() {
+		return fmt.Errorf("target must be non-nil pointer")
+	}
+	rv = rv.Elem()
+	rt := rv.Type()
+	for i := 0; i < rt.NumField(); i++ {
+		field := rt.Field(i)
+		jsonTag := field.Tag.Get("json")
+		if jsonTag == "" || jsonTag == "-" {
+			continue
+		}
+		jsonKey := strings.Split(jsonTag, ",")[0]
+		if val, ok := m[jsonKey]; ok {
+			fieldValue := rv.Field(i)
+			if fieldValue.CanSet() {
+				fieldValue.Set(reflect.ValueOf(val))
+			}
+		}
+	}
+	return nil
+}
+
+func StructToMapWithJsonTag(obj interface{}) map[string]interface{} {
+	v := reflect.ValueOf(obj)
+	if v.Kind() == reflect.Ptr {
+		v = v.Elem()
+	}
+	result := make(map[string]interface{})
+	t := v.Type()
+	for i := 0; i < v.NumField(); i++ {
+		field := t.Field(i)
+		jsonTag := field.Tag.Get("json")
+		if jsonTag == "" {
+			jsonTag = field.Name
+		} else {
+			jsonTag = strings.Split(jsonTag, ",")[0]
+		}
+		result[jsonTag] = v.Field(i).Interface()
+	}
+	return result
+}
+
+func ParseToMap(input string) map[string]string {
+	result := make(map[string]string)
+	pairs := strings.Split(input, "&")
+	for _, pair := range pairs {
+		kv := strings.SplitN(pair, "=", 2)
+		if len(kv) == 2 {
+			result[kv[0]] = kv[1]
+		}
+	}
+	return result
+}
+
+func GetString(keyName string, container map[string]any) string {
+	if v, ok := container[keyName]; ok {
+		if v, ok := v.(string); ok {
+			return v
+		}
+	}
+	return ""
+}
+
+func GetInt(keyName string, container map[string]any) int {
+	if v, ok := container[keyName]; ok {
+		return cast.ToInt(v)
+	}
+	return 0
+}
+
+func GetStringOr(container map[string]any, keys ...string) string {
+	if len(keys) == 0 {
+		return ""
+	}
+	for _, k := range keys {
+		if v, ok := container[k]; ok {
+			if v, ok := v.(string); ok {
+				if v != "" {
+					return v
+				}
+			}
+		}
+	}
+	return ""
+}
+
+func GetMap(keyName string, container map[string]any) map[string]any {
+	if v, ok := container[keyName]; ok {
+		if v, ok := v.(map[string]any); ok {
+			return v
+		}
+	}
+	return nil
+}
+
+func SetIfEmpty(keyName string, val any, container map[string]any) {
+	if _, ok := container[keyName]; !ok {
+		container[keyName] = val
+	}
+}