Merge pull request #6 from lxzan/dev

Connection Pool Parameter Optimization

Author: lxzan

client_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"net/url"
 	"strconv"
 	"sync/atomic"
 	"testing"
@@ -14,8 +15,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-const testURL = "https://api.github.com"
-
 var _port = int64(10086)
 
 func nextAddr() string {
@@ -159,6 +158,21 @@ func TestRequest_SetQuery(t *testing.T) {
 		resp := Get("http://%s", addr).SetQuery(nil).Send(nil)
 		assert.Error(t, resp.Err())
 	})
+
+	t.Run("", func(t *testing.T) {
+		req := Get("http://%s", addr).SetQuery(url.Values{
+			"name": []string{"xxx"},
+		})
+		assert.Equal(t, req.url, "http://"+addr+"?name=xxx")
+	})
+
+	t.Run("", func(t *testing.T) {
+		type Req struct {
+			Name string `form:"name"`
+		}
+		req := Get("http://%s", addr).SetQuery(Req{Name: "xxx"})
+		assert.Equal(t, req.url, "http://"+addr+"?name=xxx")
+	})
 }
 
 func TestRequest_Send(t *testing.T) {
@@ -215,24 +229,40 @@ func TestMiddleware(t *testing.T) {
 	time.Sleep(100 * time.Millisecond)
 
 	t.Run("before", func(t *testing.T) {
-		opt := WithBefore(func(ctx context.Context, request *http.Request) (context.Context, error) {
+		before := func(ctx context.Context, request *http.Request) (context.Context, error) {
 			return ctx, errors.New("status error")
-		})
-		cli, _ := NewClient(opt)
-		resp := cli.Post("http://%s/404", addr).Send(nil)
-		assert.Error(t, resp.Err())
+		}
+
+		{
+			cli, _ := NewClient(WithBefore(before))
+			resp := cli.Post("http://%s/404", addr).Send(nil)
+			assert.Error(t, resp.Err())
+		}
+
+		{
+			resp := Post("http://%s/404", addr).SetBefore(before).Send(nil)
+			assert.Error(t, resp.Err())
+		}
 	})
 
 	t.Run("after", func(t *testing.T) {
-		opt := WithAfter(func(ctx context.Context, response *http.Response) (context.Context, error) {
+		after := func(ctx context.Context, response *http.Response) (context.Context, error) {
 			if response.StatusCode != http.StatusOK {
 				return ctx, errors.New("status error")
 			}
 			return ctx, nil
-		})
-		cli, _ := NewClient(opt)
-		resp := cli.Post("http://%s/404", addr).Send(nil)
-		assert.Error(t, resp.Err())
+		}
+
+		{
+			cli, _ := NewClient(WithAfter(after))
+			resp := cli.Post("http://%s/404", addr).Send(nil)
+			assert.Error(t, resp.Err())
+		}
+
+		{
+			resp := Post("http://%s/404", addr).SetAfter(after).Send(nil)
+			assert.Error(t, resp.Err())
+		}
 	})
 
 	t.Run("latency", func(t *testing.T) {

config.go

@@ -7,7 +7,11 @@ import (
 	"time"
 )
 
-const defaultTimeout = 30 * time.Second
+const (
+	defaultTimeout             = 30 * time.Second
+	defaultMaxIdleConnsPerHost = 128
+	defaultMaxConnsPerHost     = 128
+)
 
 type (
 	BeforeFunc func(ctx context.Context, request *http.Request) (context.Context, error)
@@ -19,6 +23,10 @@ var (
 
 	defaultClient, _ = NewClient(WithHTTPClient(&http.Client{
 		Timeout: defaultTimeout,
+		Transport: &http.Transport{
+			MaxIdleConnsPerHost: defaultMaxIdleConnsPerHost,
+			MaxConnsPerHost:     defaultMaxConnsPerHost,
+		},
 	}))
 
 	defaultBeforeFunc BeforeFunc = func(ctx context.Context, request *http.Request) (context.Context, error) {
@@ -83,7 +91,11 @@ func withInitialize() Option {
 
 		if c.HTTPClient == nil {
 			c.HTTPClient = &http.Client{
-				Timeout: 30 * time.Second,
+				Timeout: defaultTimeout,
+				Transport: &http.Transport{
+					MaxIdleConnsPerHost: defaultMaxIdleConnsPerHost,
+					MaxConnsPerHost:     defaultMaxConnsPerHost,
+				},
 			}
 		}
 	}

request.go

@@ -2,8 +2,6 @@ package hasaki
 
 import (
 	"context"
-	"fmt"
-	"io"
 	"net/http"
 	neturl "net/url"
 
@@ -50,6 +48,20 @@ func Delete(url string, args ...any) *Request {
 	return defaultClient.Delete(url, args...)
 }
 
+// SetBefore 设置请求前中间件
+// Setting up pre-request middleware
+func (c *Request) SetBefore(f BeforeFunc) *Request {
+	c.before = f
+	return c
+}
+
+// SetAfter 设置请求后中间件
+// Setting up post-request middleware
+func (c *Request) SetAfter(f AfterFunc) *Request {
+	c.after = f
+	return c
+}
+
 // SetEncoder 设置编码器
 // Set request body encoder
 func (c *Request) SetEncoder(encoder Encoder) *Request {
@@ -87,22 +99,22 @@ func (c *Request) SetQuery(query any) *Request {
 		return c
 	}
 
-	str := fmt.Sprintf("%s://%s%s", URL.Scheme, URL.Host, URL.Path)
 	switch v := query.(type) {
 	case string:
 		if len(v) > 0 {
-			str += "?" + v
+			URL.RawQuery = v
 		}
+	case neturl.Values:
+		URL.RawQuery = v.Encode()
 	default:
-		str += "?"
 		values, err := form.NewEncoder().Encode(query)
 		if err != nil {
 			c.err = errors.WithStack(err)
 			return c
 		}
-		str += values.Encode()
+		URL.RawQuery = values.Encode()
 	}
-	c.url = str
+	c.url = URL.String()
 	return c
 }
 
@@ -115,13 +127,10 @@ func (c *Request) Send(body any) *Response {
 		return response
 	}
 
-	reader, ok := body.(io.Reader)
-	if !ok {
-		reader, c.err = c.encoder.Encode(body)
-		if c.err != nil {
-			response.err = c.err
-			return response
-		}
+	reader, err := c.encoder.Encode(body)
+	if err != nil {
+		response.err = err
+		return response
 	}
 
 	req, err1 := http.NewRequestWithContext(c.ctx, c.method, c.url, reader)
@@ -130,16 +139,18 @@ func (c *Request) Send(body any) *Response {
 		return response
 	}
 
+	if c.method == http.MethodGet && body == nil {
+		c.headers.Del("Content-Type")
+	}
+	req.Header = c.headers
+
 	// 执行请求前中间件
 	response.ctx, response.err = c.before(c.ctx, req)
 	if response.err != nil {
 		return response
 	}
 
-	if c.method == http.MethodGet && body == nil {
-		c.headers.Del("Content-Type")
-	}
-	req.Header = c.headers
+	// 发起请求
 	resp, err2 := c.client.Do(req)
 	if err2 != nil {
 		response.err = errors.WithStack(err2)