add ghttp server start hooks

net/ghttp/example_lifecycle_hooks_test.go

@@ -0,0 +1,127 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp_test
+
+import (
+	"fmt"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
+)
+
+// ExampleServer_SetBeforeStart demonstrates how to use the SetBeforeStart hook.
+// This hook is executed before the server starts listening.
+func ExampleServer_SetBeforeStart() {
+	s := g.Server()
+	s.BindHandler("/", func(r *ghttp.Request) {
+		r.Response.Write("Hello World")
+	})
+
+	// Set a hook that executes before the server starts
+	s.SetBeforeStart(func(s *ghttp.Server) error {
+		fmt.Println("Server is preparing to start...")
+		// Perform initialization tasks here, such as:
+		// - Loading configuration
+		// - Connecting to databases
+		// - Initializing caches
+		// - Validating required resources
+		return nil
+	})
+
+	// If any before-start hook returns an error, the server will not start
+	s.SetBeforeStart(func(s *ghttp.Server) error {
+		// Return error to prevent server from starting
+		// return fmt.Errorf("initialization failed")
+		return nil
+	})
+
+	// Start the server
+	// s.Run()
+}
+
+// ExampleServer_SetAfterStart demonstrates how to use the SetAfterStart hook.
+// This hook is executed after the server has successfully started listening.
+func ExampleServer_SetAfterStart() {
+	s := g.Server()
+	s.BindHandler("/", func(r *ghttp.Request) {
+		r.Response.Write("Hello World")
+	})
+
+	// Set a hook that executes after the server starts
+	s.SetAfterStart(func(s *ghttp.Server) error {
+		port := s.GetListenedPort()
+		fmt.Printf("Server started successfully on port %d\n", port)
+		// Perform post-startup tasks here, such as:
+		// - Registering with service discovery
+		// - Starting background jobs
+		// - Sending startup notifications
+		// - Logging server information
+		return nil
+	})
+
+	// Multiple after-start hooks can be registered
+	s.SetAfterStart(func(s *ghttp.Server) error {
+		fmt.Println("Performing additional startup tasks...")
+		return nil
+	})
+
+	// If an after-start hook returns an error, it will be logged
+	// but the server will continue running
+	s.SetAfterStart(func(s *ghttp.Server) error {
+		// This error will be logged but won't stop the server
+		// return fmt.Errorf("non-critical error")
+		return nil
+	})
+
+	// Start the server
+	// s.Run()
+}
+
+// Example_lifecycleHooks demonstrates a complete example
+// using both before-start and after-start hooks together.
+func Example_lifecycleHooks() {
+	s := g.Server()
+	s.SetAddr(":8080")
+
+	// Register routes
+	s.BindHandler("/health", func(r *ghttp.Request) {
+		r.Response.WriteJson(g.Map{
+			"status": "healthy",
+		})
+	})
+
+	// Before-start hook: validate configuration
+	s.SetBeforeStart(func(s *ghttp.Server) error {
+		fmt.Println("1. Validating server configuration...")
+		// Validate required configuration here
+		return nil
+	})
+
+	// Before-start hook: initialize resources
+	s.SetBeforeStart(func(s *ghttp.Server) error {
+		fmt.Println("2. Initializing database connections...")
+		// Initialize database connections here
+		return nil
+	})
+
+	// After-start hook: register with service discovery
+	s.SetAfterStart(func(s *ghttp.Server) error {
+		port := s.GetListenedPort()
+		fmt.Printf("3. Registering service on port %d with discovery...\n", port)
+		// Register with service discovery here
+		return nil
+	})
+
+	// After-start hook: log startup information
+	s.SetAfterStart(func(s *ghttp.Server) error {
+		fmt.Println("4. Server is ready to accept requests")
+		return nil
+	})
+
+	// Start the server
+	// s.Run()
+}

net/ghttp/ghttp.go

@@ -47,6 +47,8 @@ type (
 		serviceMu        sync.Mutex                // Concurrent safety for operations of attribute service.
 		service          gsvc.Service              // The service for Registry.
 		registrar        gsvc.Registrar            // Registrar for service register.
+		beforeStartHooks []ServerHookFunc          // Lifecycle hooks executed before server starts.
+		afterStartHooks  []ServerHookFunc          // Lifecycle hooks executed after server starts.
 	}
 
 	// Router object.
@@ -76,6 +78,9 @@ type (
 	// HandlerFunc is request handler function.
 	HandlerFunc = func(r *Request)
 
+	// ServerHookFunc is the hook function for server lifecycle events.
+	ServerHookFunc = func(s *Server) error
+
 	// handlerFuncInfo contains the HandlerFunc address and its reflection type.
 	handlerFuncInfo struct {
 		Func            HandlerFunc      // Handler function address.

net/ghttp/ghttp_server.go

@@ -126,6 +126,11 @@ func GetServer(name ...any) *Server {
 func (s *Server) Start() error {
 	var ctx = gctx.GetInitCtx()
 
+	// Execute before-start hooks.
+	if err := s.executeBeforeStartHooks(); err != nil {
+		return gerror.Wrap(err, `before-start hook failed`)
+	}
+
 	// Swagger UI.
 	if s.config.SwaggerPath != "" {
 		swaggerui.Init()
@@ -266,6 +271,9 @@ func (s *Server) Start() error {
 	s.doServiceRegister()
 	s.doRouterMapDump()
 
+	// Execute after-start hooks once the server has started successfully.
+	s.executeAfterStartHooks()
+
 	return nil
 }
 

net/ghttp/ghttp_server_lifecycle_hooks.go

@@ -0,0 +1,62 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package ghttp
+
+import "github.com/gogf/gf/v2/os/gctx"
+
+// SetBeforeStart sets the hook function that is called before the server starts.
+// Multiple hooks can be registered and they will be executed in the order they were registered.
+// If any hook returns an error, the server will not start and the error will be returned.
+//
+// Example:
+//
+//	s := ghttp.GetServer()
+//	s.SetBeforeStart(func(s *ghttp.Server) error {
+//	    fmt.Println("Server is about to start")
+//	    return nil
+//	})
+func (s *Server) SetBeforeStart(hook ServerHookFunc) {
+	s.beforeStartHooks = append(s.beforeStartHooks, hook)
+}
+
+// SetAfterStart sets the hook function that is called after the server starts successfully.
+// Multiple hooks can be registered and they will be executed in the order they were registered.
+// The hooks are executed after all server listeners have been created and started.
+// If any hook returns an error, the error will be logged but the server will continue running.
+//
+// Example:
+//
+//	s := ghttp.GetServer()
+//	s.SetAfterStart(func(s *ghttp.Server) error {
+//	    fmt.Println("Server started successfully")
+//	    return nil
+//	})
+func (s *Server) SetAfterStart(hook ServerHookFunc) {
+	s.afterStartHooks = append(s.afterStartHooks, hook)
+}
+
+// executeBeforeStartHooks executes all registered before-start hooks.
+// It returns an error if any hook fails, which will prevent the server from starting.
+func (s *Server) executeBeforeStartHooks() error {
+	for _, hook := range s.beforeStartHooks {
+		if err := hook(s); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// executeAfterStartHooks executes all registered after-start hooks.
+// Errors from hooks are logged but do not stop the server.
+func (s *Server) executeAfterStartHooks() {
+	var ctx = gctx.GetInitCtx()
+	for _, hook := range s.afterStartHooks {
+		if err := hook(s); err != nil {
+			s.Logger().Errorf(ctx, `after-start hook error: %+v`, err)
+		}
+	}
+}