feat(gs): add RunWith and RunAsync method

Author: lvan100

doc/examples/miniapi/main.go

@@ -17,9 +17,11 @@
 package main
 
 import (
+	"context"
 	"net/http"
 
 	"github.com/go-spring/spring-core/gs"
+	"github.com/go-spring/spring-core/util/syslog"
 )
 
 func main() {
@@ -34,7 +36,10 @@ func main() {
 	// - Property Binding: Binds external configs (YAML, ENV) into structs.
 	// - Dependency Injection: Wires beans automatically.
 	// - Dynamic Refresh: Updates configs at runtime without restart.
-	gs.Run()
+	gs.RunWith(func(ctx context.Context) error {
+		syslog.Infof("app started")
+		return nil
+	})
 }
 
 //~ curl http://127.0.0.1:9090/echo

doc/examples/noweb/main.go

@@ -18,11 +18,19 @@ package main
 
 import (
 	"github.com/go-spring/spring-core/gs"
+	"github.com/go-spring/spring-core/util/syslog"
 )
 
 func main() {
 	// Disable the built-in HTTP service.
-	gs.Web(false).Run()
+	stop, err := gs.Web(false).RunAsync()
+	if err != nil {
+		syslog.Errorf("app run failed: %s", err.Error())
+	}
+	defer stop()
+
+	syslog.Infof("app started")
+	select {}
 }
 
 // ~ telnet 127.0.0.1 9090

gs/gs.go

@@ -215,6 +215,11 @@ func Web(enable bool) *AppStarter {
 
 // Run runs the app and waits for an interrupt signal to exit.
 func (s *AppStarter) Run() {
+	s.RunWith(nil)
+}
+
+// RunWith runs the app with a given function and waits for an interrupt signal to exit.
+func (s *AppStarter) RunWith(fn func(ctx context.Context) error) {
 	var err error
 	defer func() {
 		if err != nil {
@@ -226,14 +231,32 @@ func (s *AppStarter) Run() {
 		return
 	}
 	B = nil
-	err = gs_app.GS.Run()
+	err = gs_app.GS.RunWith(fn)
+}
+
+// RunAsync runs the app asynchronously and returns a function to stop the app.
+func (s *AppStarter) RunAsync() (func(), error) {
+	if err := gs_app.GS.Start(); err != nil {
+		return nil, err
+	}
+	return func() { gs_app.GS.Stop() }, nil
 }
 
 // Run runs the app and waits for an interrupt signal to exit.
 func Run() {
 	new(AppStarter).Run()
 }
 
+// RunWith runs the app with a given function and waits for an interrupt signal to exit.
+func RunWith(fn func(ctx context.Context) error) {
+	new(AppStarter).RunWith(fn)
+}
+
+// RunAsync runs the app asynchronously and returns a function to stop the app.
+func RunAsync() (func(), error) {
+	return new(AppStarter).RunAsync()
+}
+
 // Exiting returns a boolean indicating whether the application is exiting.
 func Exiting() bool {
 	return gs_app.GS.Exiting()

gs/internal/gs_app/app.go

@@ -74,12 +74,24 @@ func NewApp() *App {
 // (e.g., SIGINT, SIGTERM). Upon receiving a signal, it initiates
 // a graceful shutdown.
 func (app *App) Run() error {
-	app.C.Object(app)
+	return app.RunWith(nil)
+}
 
+// RunWith starts the application and listens for termination signals
+// (e.g., SIGINT, SIGTERM). Upon receiving a signal, it initiates
+// a graceful shutdown.
+func (app *App) RunWith(fn func(ctx context.Context) error) error {
 	if err := app.Start(); err != nil {
 		return err
 	}
 
+	// runs the user-defined function
+	if fn != nil {
+		if err := fn(app.ctx); err != nil {
+			return err
+		}
+	}
+
 	// listens for OS termination signals
 	go func() {
 		ch := make(chan os.Signal, 1)
@@ -99,9 +111,10 @@ func (app *App) Run() error {
 // loading, IoC container refreshing, dependency injection, and runs
 // runners, jobs and servers.
 func (app *App) Start() error {
-	var p conf.Properties
+	app.C.Object(app)
 
 	// loads the layered app properties
+	var p conf.Properties
 	{
 		var err error
 		if p, err = app.P.Refresh(); err != nil {