feat: add Listen method and optimize performance

context.go

@@ -2,6 +2,7 @@ package fiber
 
 import (
 	"context"
+	"sync"
 	"time"
 
 	"github.com/gofiber/fiber/v2"
@@ -31,25 +32,38 @@ func Background() http.Context {
 	return NewContext(httpCtx)
 }
 
+var contextPool = sync.Pool{New: func() any {
+	return &Context{}
+}}
+
 type Context struct {
 	instance *fiber.Ctx
 	request  http.ContextRequest
+	response http.ContextResponse
 }
 
-func NewContext(ctx *fiber.Ctx) http.Context {
-	return &Context{instance: ctx}
+func NewContext(c *fiber.Ctx) *Context {
+	ctx := contextPool.Get().(*Context)
+	ctx.instance = c
+	return ctx
 }
 
 func (c *Context) Request() http.ContextRequest {
 	if c.request == nil {
-		c.request = NewContextRequest(c, LogFacade, ValidationFacade)
+		request := NewContextRequest(c, LogFacade, ValidationFacade)
+		c.request = request
 	}
 
 	return c.request
 }
 
 func (c *Context) Response() http.ContextResponse {
-	return NewContextResponse(c.instance, &ResponseOrigin{Ctx: c.instance})
+	if c.response == nil {
+		response := NewContextResponse(c.instance, &ResponseOrigin{Ctx: c.instance})
+		c.response = response
+	}
+
+	return c.response
 }
 
 func (c *Context) WithValue(key any, value any) {

context_request.go

@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 
 	"github.com/gofiber/fiber/v2"
 	"github.com/gofiber/fiber/v2/utils"
@@ -25,6 +26,13 @@ import (
 	"github.com/valyala/fasthttp/fasthttpadaptor"
 )
 
+var contextRequestPool = sync.Pool{New: func() any {
+	return &ContextRequest{
+		log:        LogFacade,
+		validation: ValidationFacade,
+	}
+}}
+
 type ContextRequest struct {
 	ctx        *Context
 	instance   *fiber.Ctx
@@ -34,12 +42,16 @@ type ContextRequest struct {
 }
 
 func NewContextRequest(ctx *Context, log log.Log, validation contractsvalidate.Validation) contractshttp.ContextRequest {
+	request := contextRequestPool.Get().(*ContextRequest)
 	httpBody, err := getHttpBody(ctx)
 	if err != nil {
-		LogFacade.Error(fmt.Sprintf("%+v", err))
+		log.Error(fmt.Sprintf("%+v", errors.Unwrap(err)))
 	}
-
-	return &ContextRequest{ctx: ctx, instance: ctx.instance, httpBody: httpBody, log: log, validation: validation}
+	request.ctx = ctx
+	request.instance = ctx.instance
+	request.httpBody = httpBody
+	request.validation = validation
+	return request
 }
 
 func (r *ContextRequest) AbortWithStatus(code int) {

context_response.go

@@ -14,13 +14,20 @@ import (
 	"github.com/valyala/fasthttp"
 )
 
+var contextResponsePool = sync.Pool{New: func() any {
+	return &ContextResponse{}
+}}
+
 type ContextResponse struct {
 	instance *fiber.Ctx
 	origin   contractshttp.ResponseOrigin
 }
 
-func NewContextResponse(instance *fiber.Ctx, origin contractshttp.ResponseOrigin) *ContextResponse {
-	return &ContextResponse{instance, origin}
+func NewContextResponse(instance *fiber.Ctx, origin contractshttp.ResponseOrigin) contractshttp.ContextResponse {
+	response := contextResponsePool.Get().(*ContextResponse)
+	response.instance = instance
+	response.origin = origin
+	return response
 }
 
 func (r *ContextResponse) Cookie(cookie contractshttp.Cookie) contractshttp.ContextResponse {

route.go

@@ -2,8 +2,10 @@ package fiber
 
 import (
 	"context"
+	"crypto/tls"
 	"errors"
 	"fmt"
+	"net"
 	"net/http"
 	"reflect"
 	"runtime"
@@ -128,6 +130,33 @@ func (r *Route) GlobalMiddleware(middlewares ...httpcontract.Middleware) {
 	r.setMiddlewares(fiberHandlers)
 }
 
+// Listen listen server
+// Listen 监听服务器
+func (r *Route) Listen(l net.Listener) error {
+	return r.instance.Listener(l)
+}
+
+// ListenTLS listen TLS server
+// ListenTLS 监听 TLS 服务器
+func (r *Route) ListenTLS(l net.Listener, certFile, keyFile string) error {
+	cert, err := tls.LoadX509KeyPair(certFile, keyFile)
+	if err != nil {
+		return err
+	}
+
+	tlsHandler := &fiber.TLSHandler{}
+	tlsConfig := &tls.Config{
+		MinVersion: tls.VersionTLS12,
+		Certificates: []tls.Certificate{
+			cert,
+		},
+		GetCertificate: tlsHandler.GetClientInfo,
+	}
+
+	r.instance.SetTLSHandler(tlsHandler)
+	return r.Listen(tls.NewListener(l, tlsConfig))
+}
+
 // Run run server
 // Run 运行服务器
 func (r *Route) Run(host ...string) error {

route_test.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"mime/multipart"
+	"net"
 	"net/http"
 	"sync"
 	"sync/atomic"
@@ -45,6 +46,129 @@ func TestFallback(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, "not found", string(body))
 }
+func TestListen(t *testing.T) {
+	var (
+		err        error
+		mockConfig *configmocks.Config
+		route      *Route
+	)
+
+	tests := []struct {
+		name        string
+		setup       func(host string, port string) error
+		host        string
+		port        string
+		expectError error
+	}{
+		{
+			name: "success listen",
+			setup: func(host string, port string) error {
+				go func() {
+					l, err := net.Listen("tcp", host)
+					assert.Nil(t, err)
+					assert.Nil(t, route.Listen(l))
+				}()
+				time.Sleep(1 * time.Second)
+
+				return errors.New("error")
+			},
+			host: "127.0.0.1:3100",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			mockConfig = configmocks.NewConfig(t)
+			mockConfig.EXPECT().GetBool("http.drivers.fiber.prefork", false).Return(false).Once()
+			mockConfig.EXPECT().GetInt("http.drivers.fiber.body_limit", 4096).Return(4096).Once()
+			mockConfig.EXPECT().GetInt("http.drivers.fiber.header_limit", 4096).Return(4096).Once()
+
+			route, err = NewRoute(mockConfig, nil)
+			assert.Nil(t, err)
+			route.Get("/", func(ctx contractshttp.Context) contractshttp.Response {
+				return ctx.Response().Json(200, contractshttp.Json{
+					"Hello": "Goravel",
+				})
+			})
+			if err := test.setup(test.host, test.port); err == nil {
+				time.Sleep(1 * time.Second)
+				hostUrl := "http://" + test.host
+				if test.port != "" {
+					hostUrl = hostUrl + ":" + test.port
+				}
+				resp, err := http.Get(hostUrl)
+				assert.Nil(t, err)
+				defer resp.Body.Close()
+
+				body, err := io.ReadAll(resp.Body)
+				assert.Nil(t, err)
+				assert.Equal(t, "{\"Hello\":\"Goravel\"}", string(body))
+			}
+			mockConfig.AssertExpectations(t)
+		})
+	}
+}
+
+func TestListenTLS(t *testing.T) {
+	var (
+		err        error
+		mockConfig *configmocks.Config
+		route      *Route
+	)
+
+	tests := []struct {
+		name        string
+		setup       func(host string) error
+		host        string
+		expectError error
+	}{
+		{
+			name: "success listen",
+			setup: func(host string) error {
+				go func() {
+					l, err := net.Listen("tcp", host)
+					assert.Nil(t, err)
+					assert.Nil(t, route.ListenTLS(l, "test_ca.crt", "test_ca.key"))
+				}()
+
+				return nil
+			},
+			host: "127.0.0.1:3101",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			mockConfig = configmocks.NewConfig(t)
+			mockConfig.EXPECT().GetBool("http.drivers.fiber.prefork", false).Return(false).Once()
+			mockConfig.EXPECT().GetInt("http.drivers.fiber.body_limit", 4096).Return(4096).Once()
+			mockConfig.EXPECT().GetInt("http.drivers.fiber.header_limit", 4096).Return(4096).Once()
+			ConfigFacade = mockConfig
+
+			route, err = NewRoute(mockConfig, nil)
+			assert.Nil(t, err)
+			route.Get("/", func(ctx contractshttp.Context) contractshttp.Response {
+				return ctx.Response().Json(200, contractshttp.Json{
+					"Hello": "Goravel",
+				})
+			})
+			if err := test.setup(test.host); err == nil {
+				time.Sleep(1 * time.Second)
+				tr := &http.Transport{
+					TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+				}
+				client := &http.Client{Transport: tr}
+				resp, err := client.Get("https://" + test.host)
+				assert.Nil(t, err)
+				defer resp.Body.Close()
+
+				body, err := io.ReadAll(resp.Body)
+				assert.Nil(t, err)
+				assert.Equal(t, "{\"Hello\":\"Goravel\"}", string(body))
+			}
+		})
+	}
+}
 
 func TestRun(t *testing.T) {
 	var (

utils.go

@@ -22,17 +22,35 @@ func middlewaresToFiberHandlers(middlewares []httpcontract.Middleware) []fiber.H
 }
 
 func handlerToFiberHandler(handler httpcontract.HandlerFunc) fiber.Handler {
-	return func(ctx *fiber.Ctx) error {
-		if response := handler(NewContext(ctx)); response != nil {
+	return func(c *fiber.Ctx) error {
+		context := NewContext(c)
+		defer func() {
+			contextRequestPool.Put(context.request)
+			contextResponsePool.Put(context.response)
+			context.request = nil
+			context.response = nil
+			contextPool.Put(context)
+		}()
+
+		if response := handler(context); response != nil {
 			return response.Render()
 		}
 		return nil
 	}
 }
 
 func middlewareToFiberHandler(middleware httpcontract.Middleware) fiber.Handler {
-	return func(ctx *fiber.Ctx) error {
-		middleware(NewContext(ctx))
+	return func(c *fiber.Ctx) error {
+		context := NewContext(c)
+		defer func() {
+			contextRequestPool.Put(context.request)
+			contextResponsePool.Put(context.response)
+			context.request = nil
+			context.response = nil
+			contextPool.Put(context)
+		}()
+
+		middleware(context)
 		return nil
 	}
 }