optimize code

body.go

@@ -22,21 +22,19 @@ const (
 	paramsType
 )
 
-func (obj *RequestOption) newBody(val any, valType bodyType, dataMap map[string][]string) error {
+func (obj *RequestOption) newBody(val any, valType bodyType, dataMap map[string][]string) (io.Reader, error) {
 	if reader, ok := val.(io.Reader); ok {
 		obj.once = true
-		obj.body = reader
-		return nil
+		return reader, nil
 	}
 	switch value := val.(type) {
 	case *gson.Client:
 		if !value.IsObject() {
-			return errors.New("body-type error")
+			return nil, errors.New("body-type error")
 		}
 		switch valType {
 		case jsonType, textType, rawType:
-			obj.body = bytes.NewReader(value.Bytes())
-			return nil
+			return bytes.NewReader(value.Bytes()), nil
 		case dataType:
 			tempVal := url.Values{}
 			for kk, vv := range value.Map() {
@@ -48,8 +46,7 @@ func (obj *RequestOption) newBody(val any, valType bodyType, dataMap map[string]
 					tempVal.Add(kk, vv.String())
 				}
 			}
-			obj.body = bytes.NewReader(tools.StringToBytes(tempVal.Encode()))
-			return nil
+			return bytes.NewReader(tools.StringToBytes(tempVal.Encode())), nil
 		case formType, paramsType:
 			for kk, vv := range value.Map() {
 				kkvv := []string{}
@@ -62,32 +59,30 @@ func (obj *RequestOption) newBody(val any, valType bodyType, dataMap map[string]
 				}
 				dataMap[kk] = kkvv
 			}
-			return nil
+			return nil, nil
 		default:
-			return fmt.Errorf("unknow content-type：%d", valType)
+			return nil, fmt.Errorf("unknow content-type：%d", valType)
 		}
 	case string:
 		switch valType {
 		case jsonType, textType, dataType, rawType:
-			obj.body = bytes.NewReader(tools.StringToBytes(value))
-			return nil
+			return bytes.NewReader(tools.StringToBytes(value)), nil
 		case formType, paramsType:
 		default:
-			return fmt.Errorf("unknow content-type：%d", valType)
+			return nil, fmt.Errorf("unknow content-type：%d", valType)
 		}
 	case []byte:
 		switch valType {
 		case jsonType, textType, dataType, rawType:
-			obj.body = bytes.NewReader(value)
-			return nil
+			return bytes.NewReader(value), nil
 		case formType, paramsType:
 		default:
-			return fmt.Errorf("unknow content-type：%d", valType)
+			return nil, fmt.Errorf("unknow content-type：%d", valType)
 		}
 	}
 	result, err := gson.Decode(val)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	return obj.newBody(result, valType, dataMap)
 }

cookies.go

@@ -116,10 +116,9 @@ func any2Cookies(val any) (Cookies, error) {
 		return cookies, nil
 	}
 }
-func (obj *RequestOption) initCookies() (err error) {
+func (obj *RequestOption) initCookies() (Cookies, error) {
 	if obj.Cookies == nil {
-		return nil
+		return nil, nil
 	}
-	obj.Cookies, err = ReadCookies(obj.Cookies)
-	return err
+	return ReadCookies(obj.Cookies)
 }

headers.go

@@ -27,17 +27,16 @@ func defaultHeaders() http.Header {
 		"Sec-Ch-Ua-Platform": []string{`"Windows"`},
 	}
 }
-func (obj *RequestOption) initHeaders() error {
+func (obj *RequestOption) initHeaders() (http.Header, error) {
 	if obj.Headers == nil {
-		return nil
+		return nil, nil
 	}
 	switch headers := obj.Headers.(type) {
 	case http.Header:
-		obj.Headers = headers.Clone()
-		return nil
+		return headers.Clone(), nil
 	case *gson.Client:
 		if !headers.IsObject() {
-			return errors.New("new headers error")
+			return nil, errors.New("new headers error")
 		}
 		head := http.Header{}
 		for kk, vv := range headers.Map() {
@@ -49,12 +48,11 @@ func (obj *RequestOption) initHeaders() error {
 				head.Add(kk, vv.String())
 			}
 		}
-		obj.Headers = head
-		return nil
+		return head, nil
 	default:
 		jsonData, err := gson.Decode(headers)
 		if err != nil {
-			return err
+			return nil, err
 		}
 		obj.Headers = jsonData
 		return obj.initHeaders()

option.go

@@ -67,9 +67,9 @@ type RequestOption struct {
 	WsOption    websocket.Option //websocket option
 	DisProxy    bool             //force disable proxy
 
-	converUrl string
-	body      io.Reader
-	once      bool
+	// converUrl string
+	// body      io.Reader
+	once bool
 }
 type File struct {
 	Key string
@@ -102,87 +102,72 @@ func (obj *RequestOption) fileWrite(writer *multipart.Writer) (err error) {
 	}
 	return err
 }
-func (obj *RequestOption) initBody() (err error) {
-	if obj.body != nil {
-		return nil
-	} else if obj.Body != nil {
-		if err = obj.newBody(obj.Body, rawType, nil); err != nil {
-			return err
-		}
+func (obj *RequestOption) initBody() (body io.Reader, err error) {
+	if obj.Body != nil {
+		return obj.newBody(obj.Body, rawType, nil)
 	} else if obj.Form != nil {
 		dataMap := map[string][]string{}
-		if err = obj.newBody(obj.Form, formType, dataMap); err != nil {
-			return err
+		if body, err = obj.newBody(obj.Form, formType, dataMap); err != nil {
+			return
 		}
 		tempBody := bytes.NewBuffer(nil)
 		writer := multipart.NewWriter(tempBody)
 		for key, vals := range dataMap {
 			for _, val := range vals {
 				if err = writer.WriteField(key, val); err != nil {
-					return err
+					return
 				}
 			}
 		}
-		if err = obj.fileWrite(writer); err != nil {
-			return err
-		}
-		obj.body = tempBody
+		return tempBody, obj.fileWrite(writer)
 	} else if obj.Files != nil {
 		tempBody := bytes.NewBuffer(nil)
 		writer := multipart.NewWriter(tempBody)
-		if err = obj.fileWrite(writer); err != nil {
-			return err
-		}
-		obj.body = tempBody
+		return tempBody, obj.fileWrite(writer)
 	} else if obj.Data != nil {
-		if err = obj.newBody(obj.Data, dataType, nil); err != nil {
-			return err
+		if body, err = obj.newBody(obj.Data, dataType, nil); err != nil {
+			return
 		}
 		if obj.ContentType == "" {
 			obj.ContentType = "application/x-www-form-urlencoded"
 		}
 	} else if obj.Json != nil {
-		if err = obj.newBody(obj.Json, jsonType, nil); err != nil {
-			return err
+		if body, err = obj.newBody(obj.Json, jsonType, nil); err != nil {
+			return
 		}
 		if obj.ContentType == "" {
 			obj.ContentType = "application/json"
 		}
 	} else if obj.Text != nil {
-		if err = obj.newBody(obj.Text, textType, nil); err != nil {
-			return err
+		if body, err = obj.newBody(obj.Text, textType, nil); err != nil {
+			return
 		}
 		if obj.ContentType == "" {
 			obj.ContentType = "text/plain"
 		}
 	}
-	return nil
+	return
 }
-func (obj *RequestOption) optionInit() error {
-	obj.converUrl = obj.Url.String()
-	var err error
-	if err = obj.initBody(); err != nil {
-		return err
+func (obj *RequestOption) initUrl() (string, error) {
+	if obj.Params == nil {
+		return obj.Url.String(), nil
 	}
-	if obj.Params != nil {
-		dataMap := map[string][]string{}
-		if err = obj.newBody(obj.Params, paramsType, dataMap); err != nil {
-			return err
+	dataMap := map[string][]string{}
+	if _, err := obj.newBody(obj.Params, paramsType, dataMap); err != nil {
+		return "", err
+	}
+	if len(dataMap) == 0 {
+		return obj.Url.String(), nil
+	}
+	pu := cloneUrl(obj.Url)
+	puValues := pu.Query()
+	for kk, vvs := range dataMap {
+		for _, vv := range vvs {
+			puValues.Add(kk, vv)
 		}
-		pu := cloneUrl(obj.Url)
-		puValues := pu.Query()
-		for kk, vvs := range dataMap {
-			for _, vv := range vvs {
-				puValues.Add(kk, vv)
-			}
-		}
-		pu.RawQuery = puValues.Encode()
-		obj.converUrl = pu.String()
 	}
-	if err = obj.initHeaders(); err != nil {
-		return err
-	}
-	return obj.initCookies()
+	pu.RawQuery = puValues.Encode()
+	return pu.String(), nil
 }
 func (obj *Client) newRequestOption(option RequestOption) RequestOption {
 	if option.TryNum < 0 {

requests.go

@@ -224,17 +224,13 @@ func (obj *Client) request(preCtx context.Context, option *RequestOption) (respo
 			return
 		}
 	}
-	if err = option.optionInit(); err != nil {
-		err = tools.WrapError(err, "option init error")
-		return
-	}
 	response.bar = option.Bar
 	response.disUnzip = option.DisUnZip
 	response.disDecode = option.DisDecode
 	response.stream = option.Stream
 
 	method := strings.ToUpper(option.Method)
-	href := option.converUrl
+
 	var reqs *http.Request
 	//init ctxData
 	ctxData := new(reqCtxData)
@@ -297,21 +293,34 @@ func (obj *Client) request(preCtx context.Context, option *RequestOption) (respo
 	} else {
 		response.ctx, response.cnl = context.WithCancel(context.WithValue(preCtx, keyPrincipalID, ctxData))
 	}
+	//init url
+	href, err := option.initUrl()
+	if err != nil {
+		err = tools.WrapError(err, "url init error")
+		return
+	}
+	//init body
+	body, err := option.initBody()
+	if err != nil {
+		return response, tools.WrapError(err, errors.New("tempRequest init body error"), err)
+	}
 	//create request
-	if option.body != nil {
-		reqs, err = http.NewRequestWithContext(response.ctx, method, href, option.body)
+	if body != nil {
+		reqs, err = http.NewRequestWithContext(response.ctx, method, href, body)
 	} else {
 		reqs, err = http.NewRequestWithContext(response.ctx, method, href, nil)
 	}
 	if err != nil {
 		return response, tools.WrapError(errFatal, errors.New("tempRequest 构造request失败"), err)
 	}
-	//add headers
-	var headOk bool
-	if option.Headers != nil {
-		if reqs.Header, headOk = option.Headers.(http.Header); !headOk {
-			return response, tools.WrapError(errFatal, "request headers 转换错误")
-		}
+
+	//init headers
+	headers, err := option.initHeaders()
+	if err != nil {
+		return response, tools.WrapError(err, errors.New("tempRequest init headers error"), err)
+	}
+	if headers != nil {
+		reqs.Header = headers
 	} else {
 		reqs.Header = defaultHeaders()
 	}
@@ -360,16 +369,17 @@ func (obj *Client) request(preCtx context.Context, option *RequestOption) (respo
 		reqs.Host = reqs.URL.Host
 	}
 
-	//add cookies
-	if option.Cookies != nil {
-		cooks, cookOk := option.Cookies.(Cookies)
-		if !cookOk {
-			return response, tools.WrapError(errFatal, "request cookies transport error")
-		}
-		for _, vv := range cooks {
+	//init cookies
+	cookies, err := option.initCookies()
+	if err != nil {
+		return response, tools.WrapError(err, errors.New("tempRequest init cookies error"), err)
+	}
+	if cookies != nil {
+		for _, vv := range cookies {
 			reqs.AddCookie(vv)
 		}
 	}
+	//send req
 	if response.response, err = obj.getClient(option).Do(reqs); err != nil {
 		err = tools.WrapError(err, "roundTripper error")
 		return