支持多微服务和多数据库测试通过

bootstraps/bootstrap.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"git.x2erp.com/qdy/go-base/config"
+	"git.x2erp.com/qdy/go-base/config/subconfigs"
 	"git.x2erp.com/qdy/go-base/logger"
 )
 
@@ -19,32 +20,43 @@ type ShutdownHandler interface {
 	OnShutdown()
 }
 
+// WebService Web服务实例
+type WebService struct {
+	serviceName     string
+	serviceConfig   *subconfigs.ServiceConfig
+	HttpServer      *http.Server
+	Router          *http.ServeMux
+	quit            chan os.Signal
+	shutdownHandler ShutdownHandler
+}
+
 // Bootstrapper 服务启动器
 type Bootstrapper struct {
-	serviceName    string
-	serviceVersion string
-	Cfg            config.IConfig
-	HttpServer     *http.Server
-	Router         *http.ServeMux
-	quit           chan os.Signal
+	appName    string
+	appVersion string
+	Cfg        config.IConfig
+	services   map[string]*WebService // 存储多个服务实例
+	quit       chan os.Signal
 }
 
-// New 创建启动器
-func New(name, version string) *Bootstrapper {
+// NewBootstrapper 创建启动器
+func NewBootstrapper(name, version string) *Bootstrapper {
 	b := &Bootstrapper{
-		serviceName:    name,
-		serviceVersion: version,
-		quit:           make(chan os.Signal, 1),
-		Router:         http.NewServeMux(), // 直接创建路由器
+		appName:    name,
+		appVersion: version,
+		quit:       make(chan os.Signal, 1),
+		services:   make(map[string]*WebService),
 	}
 
+	b.init()
+
 	return b
 }
 
 // Init 初始化配置和日志
-func (b *Bootstrapper) Init() *Bootstrapper {
+func (b *Bootstrapper) init() *Bootstrapper {
 	// 1. 初始化启动日志
-	if err := logger.InitBootLog(b.serviceName); err != nil {
+	if err := logger.InitBootLog(b.appName); err != nil {
 		log.Fatal("无法初始化启动日志: ", err)
 	}
 
@@ -54,92 +66,200 @@ func (b *Bootstrapper) Init() *Bootstrapper {
 	if err != nil {
 		log.Fatalf("加载配置失败: %v", err)
 	}
-	cfg.SetServiceName(b.serviceName)
-	cfg.SetServiceVersion(b.serviceVersion)
+	cfg.SetAppName(b.appName)
+	cfg.SetAppVersion(b.appVersion)
 	b.Cfg = cfg
 
 	// 3. 初始化运行时日志
-	logger.InitRuntimeLogger(b.serviceName, b.serviceVersion, b.Cfg.GetLog())
+	logger.InitRuntimeLogger(b.appName, b.appVersion, b.Cfg.GetLog())
 	log.Println("配置和日志初始化完成")
 
 	return b
 }
 
-// StartService 启动HTTP服务
-func (b *Bootstrapper) StartService() *Bootstrapper {
-	serviceCfg := b.Cfg.GetService()
+// CreateService 创建Web服务实例
+func (b *Bootstrapper) CreateService(serviceName string) *WebService {
+	serviceCfg := b.Cfg.GetServiceConfig(serviceName)
+
+	// 检查是否已存在同名服务
+	if _, exists := b.services[serviceName]; exists {
+		logger.Debug("服务 %s 已存在，将返回现有实例", serviceName)
+		return b.services[serviceName]
+	}
+
+	// 创建新的服务实例
+	ws := &WebService{
+		serviceName:   serviceName,
+		serviceConfig: serviceCfg,
+		Router:        http.NewServeMux(),
+		quit:          make(chan os.Signal, 1),
+	}
 
 	// 创建HTTP服务器
-	b.HttpServer = &http.Server{
+	ws.HttpServer = &http.Server{
 		Addr:         fmt.Sprintf(":%d", serviceCfg.Port),
-		Handler:      b.Router, // 直接使用Router
+		Handler:      ws.Router,
 		ReadTimeout:  15 * time.Second,
 		WriteTimeout: 15 * time.Second,
 		IdleTimeout:  60 * time.Second,
 	}
 
-	log.Printf("正在启动服务: %s v%s", b.serviceName, b.serviceVersion)
+	// 存储服务实例
+	b.services[serviceName] = ws
+
+	logger.Debug("已创建服务实例: %s (端口: %d)", serviceCfg.ServiceName, serviceCfg.Port)
+
+	return ws
+}
+
+// GetAllServices 获取所有服务实例
+func (b *Bootstrapper) GetAllServices() map[string]*WebService {
+	return b.services
+}
+
+// StartService 启动指定服务
+func (b *Bootstrapper) StartService(serviceName string) *Bootstrapper {
+
+	service := b.CreateService(serviceName)
+
+	serviceCfg := service.serviceConfig
+	log.Printf("正在启动服务: %s ", serviceCfg.ServiceName)
 	log.Printf("模式: 独立运行 (net/http)")
 	log.Printf("服务端口: :%d", serviceCfg.Port)
 
 	return b
 }
 
-// Run 运行服务
-func (b *Bootstrapper) Run(handler ShutdownHandler) {
-	log.Printf("服务 %s 开始运行...", b.serviceName)
+// Run 运行所有服务
+func (b *Bootstrapper) Run(shutdownHandler ShutdownHandler) {
+	if len(b.services) == 0 {
+		log.Fatal("没有要运行的服务，请先创建服务实例")
+	}
+
+	log.Printf("开始运行 %d 个服务...", len(b.services))
 
-	// 设置信号监听 - 在这里设置，而不是在New中
+	// 设置全局信号监听
 	signal.Notify(b.quit, syscall.SIGINT, syscall.SIGTERM)
 
-	// 启动HTTP服务器
+	// 启动所有服务
+	for serviceName, service := range b.services {
+		go func(name string, ws *WebService) {
+			log.Printf("启动服务 %s 在 %s", name, ws.HttpServer.Addr)
+			if err := ws.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+				log.Fatalf("服务 %s 运行失败: %v", name, err)
+			}
+		}(serviceName, service)
+	}
+
+	// 等待中断信号
+	b.waitForShutdown(shutdownHandler)
+}
+
+// RunSingle 运行单个服务
+func (b *Bootstrapper) RunSingle(serviceName string, shutdownHandler ShutdownHandler) {
+	service := b.CreateService(serviceName)
+
+	log.Printf("服务 %s 开始运行...", service.serviceConfig.ServiceName)
+
+	// 设置服务级别的信号监听
+	signal.Notify(service.quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// 启动服务
 	go func() {
-		log.Printf("服务器启动在 %s", b.HttpServer.Addr)
-		if err := b.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		log.Printf("服务器启动在 %s", service.HttpServer.Addr)
+		if err := service.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 			log.Fatalf("服务运行失败: %v", err)
 		}
 	}()
 
 	// 等待中断信号
-	b.waitForShutdown(handler)
+	b.waitForServiceShutdown(service, shutdownHandler)
 }
 
 // RunTLS 运行HTTPS服务
-func (b *Bootstrapper) RunTLS(certFile, keyFile string, handler ShutdownHandler) {
-	log.Printf("服务 %s 开始运行(HTTPS)...", b.serviceName)
+func (b *Bootstrapper) RunTLS(serviceName, certFile, keyFile string, shutdownHandler ShutdownHandler) {
+	service := b.CreateService(serviceName)
 
-	// 设置信号监听
-	signal.Notify(b.quit, syscall.SIGINT, syscall.SIGTERM)
+	log.Printf("服务 %s 开始运行(HTTPS)...", service.serviceConfig.ServiceName)
+
+	// 设置服务级别的信号监听
+	signal.Notify(service.quit, syscall.SIGINT, syscall.SIGTERM)
 
 	// 启动HTTPS服务器
 	go func() {
-		log.Printf("HTTPS服务器启动在 %s", b.HttpServer.Addr)
-		if err := b.HttpServer.ListenAndServeTLS(certFile, keyFile); err != nil && err != http.ErrServerClosed {
+		log.Printf("HTTPS服务器启动在 %s", service.HttpServer.Addr)
+		if err := service.HttpServer.ListenAndServeTLS(certFile, keyFile); err != nil && err != http.ErrServerClosed {
 			log.Fatalf("服务运行失败: %v", err)
 		}
 	}()
 
 	// 等待中断信号
-	b.waitForShutdown(handler)
+	b.waitForServiceShutdown(service, shutdownHandler)
 }
 
-// waitForShutdown 等待关闭信号
+// waitForShutdown 等待关闭信号（关闭所有服务）
 func (b *Bootstrapper) waitForShutdown(handler ShutdownHandler) {
-	log.Println("按 Ctrl+C 停止服务")
+	log.Println("按 Ctrl+C 停止所有服务")
 
 	// 等待信号
 	<-b.quit
-	log.Println("接收到终止信号，正在优雅关闭服务...")
+	log.Println("接收到终止信号，正在优雅关闭所有服务...")
+
+	// 创建关闭上下文，给30秒完成当前请求
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// 关闭所有服务
+	shutdownComplete := make(chan bool, len(b.services))
+
+	for serviceName, service := range b.services {
+		go func(name string, ws *WebService) {
+			log.Printf("正在关闭服务: %s", name)
+			if err := ws.HttpServer.Shutdown(ctx); err != nil {
+				log.Printf("服务 %s 关闭失败: %v", name, err)
+			} else {
+				log.Printf("服务 %s 已关闭", name)
+			}
+			shutdownComplete <- true
+		}(serviceName, service)
+	}
+
+	// 等待所有服务关闭完成
+	for i := 0; i < len(b.services); i++ {
+		<-shutdownComplete
+	}
+
+	// 执行关闭处理
+	if handler != nil {
+		handler.OnShutdown()
+	}
+
+	// 停止日志写入
+	logger.StopESWriter()
+	log.Println("所有服务优雅关闭完成")
+
+	// 等待一小段时间确保日志写入完成
+	time.Sleep(100 * time.Millisecond)
+	os.Exit(0)
+}
+
+// waitForServiceShutdown 等待单个服务关闭
+func (b *Bootstrapper) waitForServiceShutdown(service *WebService, handler ShutdownHandler) {
+	log.Printf("按 Ctrl+C 停止服务 %s", service.serviceName)
+
+	// 等待信号
+	<-service.quit
+	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", service.serviceName)
 
 	// 创建关闭上下文，给30秒完成当前请求
 	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
 	defer cancel()
 
 	// 停止接收新请求，完成当前请求
-	if err := b.HttpServer.Shutdown(ctx); err != nil {
-		log.Printf("服务关闭失败: %v", err)
+	if err := service.HttpServer.Shutdown(ctx); err != nil {
+		log.Printf("服务 %s 关闭失败: %v", service.serviceName, err)
 	} else {
-		log.Println("HTTP服务器已关闭")
+		log.Printf("服务 %s 已关闭", service.serviceName)
 	}
 
 	// 执行关闭处理
@@ -149,7 +269,7 @@ func (b *Bootstrapper) waitForShutdown(handler ShutdownHandler) {
 
 	// 停止日志写入
 	logger.StopESWriter()
-	log.Println("服务优雅关闭完成")
+	log.Printf("服务 %s 优雅关闭完成", service.serviceName)
 
 	// 等待一小段时间确保日志写入完成
 	time.Sleep(100 * time.Millisecond)
@@ -161,19 +281,107 @@ func (b *Bootstrapper) GetConfig() config.IConfig {
 	return b.Cfg
 }
 
-// GetRouter 获取路由器
-func (b *Bootstrapper) GetRouter() *http.ServeMux {
-	return b.Router
+// GetRouter 获取指定服务的路由器
+func (b *Bootstrapper) GetRouter(serviceName string) *http.ServeMux {
+	service := b.CreateService(serviceName)
+	return service.Router
 }
 
-// 兼容性方法
+// GetRouterDefault 获取第一个服务的路由器（兼容性方法）
+func (b *Bootstrapper) GetRouterDefault() *http.ServeMux {
+	for _, service := range b.services {
+		return service.Router
+	}
+	// 如果没有服务，创建默认路由器（向后兼容）
+	return http.NewServeMux()
+}
 
-// GetWebService 获取Web服务（兼容性方法）
-func (b *Bootstrapper) GetWebService() interface{} {
-	return b.Router
+// Handle 注册路由处理器到指定服务
+func (b *Bootstrapper) Handle(serviceName, pattern string, handler http.Handler) bool {
+	if service, exists := b.services[serviceName]; exists {
+		service.Router.Handle(pattern, handler)
+		return true
+	}
+	log.Printf("错误: 服务 %s 不存在", serviceName)
+	return false
 }
 
-// Handle 注册路由处理器（兼容性方法）
-func (b *Bootstrapper) Handle(pattern string, handler http.Handler) {
-	b.Router.Handle(pattern, handler)
+// SetShutdownHandler 为服务设置关闭处理器
+func (b *Bootstrapper) SetShutdownHandler(serviceName string, handler ShutdownHandler) bool {
+	if service, exists := b.services[serviceName]; exists {
+		service.shutdownHandler = handler
+		return true
+	}
+	return false
+}
+
+// ========== WebService 的方法 ==========
+
+// GetServiceName 获取服务名称
+func (ws *WebService) GetServiceName() string {
+	return ws.serviceName
+}
+
+// GetServiceConfig 获取服务配置
+func (ws *WebService) GetServiceConfig() *subconfigs.ServiceConfig {
+	return ws.serviceConfig
+}
+
+// GetRouter 获取服务的路由器
+func (ws *WebService) GetRouter() *http.ServeMux {
+	return ws.Router
+}
+
+// Handle 注册路由处理器
+func (ws *WebService) Handle(pattern string, handler http.Handler) {
+	ws.Router.Handle(pattern, handler)
+}
+
+// SetShutdownHandler 设置关闭处理器
+func (ws *WebService) SetShutdownHandler(handler ShutdownHandler) {
+	ws.shutdownHandler = handler
+}
+
+// Run 运行单个服务
+func (ws *WebService) Run(shutdownHandler ShutdownHandler) {
+	log.Printf("服务 %s 开始运行...", ws.serviceConfig.ServiceName)
+
+	// 设置信号监听
+	signal.Notify(ws.quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// 启动服务
+	go func() {
+		log.Printf("服务器启动在 %s", ws.HttpServer.Addr)
+		if err := ws.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("服务 %s 运行失败: %v", ws.serviceName, err)
+		}
+	}()
+
+	// 等待中断信号
+	log.Printf("按 Ctrl+C 停止服务 %s", ws.serviceName)
+	<-ws.quit
+
+	log.Printf("接收到终止信号，正在优雅关闭服务 %s...", ws.serviceName)
+
+	// 创建关闭上下文
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	// 关闭服务
+	if err := ws.HttpServer.Shutdown(ctx); err != nil {
+		log.Printf("服务 %s 关闭失败: %v", ws.serviceName, err)
+	} else {
+		log.Printf("服务 %s 已关闭", ws.serviceName)
+	}
+
+	// 执行关闭处理
+	if shutdownHandler != nil {
+		shutdownHandler.OnShutdown()
+	} else if ws.shutdownHandler != nil {
+		ws.shutdownHandler.OnShutdown()
+	}
+
+	log.Printf("服务 %s 优雅关闭完成", ws.serviceName)
+	time.Sleep(100 * time.Millisecond)
+	os.Exit(0)
 }

config/config.go

@@ -14,12 +14,16 @@ type IConfig interface {
 	GetDatabases() *subconfigs.DatabasesConfig                // 获取所有数据库配置
 	GetDatabaseConfig(name string) *subconfigs.DatabaseConfig // 按名称获取数据库配置
 
+	//多服务支持
+	GetService() *subconfigs.ServiceConfig                  //获取默认微服务配置
+	GetServices() *subconfigs.ServicesConfig                //获所有定义的微服务配置
+	GetServiceConfig(name string) *subconfigs.ServiceConfig //获取微服务配置
+
 	// 其他配置（保持不变）
 	GetRedis() *subconfigs.RedisConfig
 	GetDoris() *subconfigs.DorisConfig
 	GetRabbitMQ() *subconfigs.RabbitMQConfig
-	GetAuth() *subconfigs.AuthConfig
-	GetService() *subconfigs.ServiceConfig
+
 	GetHTTP() *subconfigs.HTTPConfig
 	GetMicro() *subconfigs.MicroConfig
 	GetLog() *subconfigs.LogConfig
@@ -31,19 +35,19 @@ type IConfig interface {
 	IsDorisConfigured() bool
 	IsRedisConfigured() bool
 
-	SetServiceName(name string)
-	SetServiceVersion(version string)
-	SetEnv(name string)
+	SetAppName(name string)
+	SetAppVersion(version string)
+	SetAppEnv(name string)
 
-	GetServiceVersion() string
-	GetEnv() string
+	GetAppName() string
+	GetAppVersion() string
+	GetAppEnv() string
+	GetAppAuthToken() string
 }
 
 // Config 主配置结构体 - 访问门面
 type Config struct {
-	initError      error  // 初始化错误
-	ServiceVersion string //当前启动微服务版本
-	env            string //当前启动微服务环境dev test prod
+	initError error // 初始化错误
 }
 
 // ========== 数据库相关方法（更新） ==========
@@ -118,13 +122,6 @@ func (c *Config) GetRabbitMQ() *subconfigs.RabbitMQConfig {
 	return nil
 }
 
-func (c *Config) GetAuth() *subconfigs.AuthConfig {
-	if config := subconfigs.GetRegisteredConfig("auth"); config != nil {
-		return config.(*subconfigs.AuthConfig)
-	}
-	return nil
-}
-
 // ========== 微服务相关方法（更新） ==========
 
 // GetServices 获取所有微服务配置
@@ -193,28 +190,41 @@ func (c *Config) IsRedisConfigured() bool {
 }
 
 // 设置方法
-func (c *Config) SetEnv(name string) {
-	c.env = name
+func (c *Config) SetAppEnv(name string) {
+	if c.GetAppEnv() == "" {
+		c.GetServices().AppEnv = name
+	}
 }
 
-func (c *Config) SetServiceName(name string) {
-	if c.GetService().ServiceName == "" {
-		c.GetService().ServiceName = name
+func (c *Config) SetAppName(name string) {
+	if c.GetAppName() == "" {
+		c.GetServices().AppName = name
 	}
 }
+func (c *Config) SetAppVersion(name string) {
+	if c.GetAppVersion() == "" {
+		c.GetServices().AppVersion = name
+	}
+}
+
+// GetAppVersion 获取服务版本
+func (c *Config) GetAppVersion() string {
+	return c.GetServices().AppVersion
+}
 
-func (c *Config) SetServiceVersion(version string) {
-	c.ServiceVersion = version
+// GetAppEnv 获取环境
+func (c *Config) GetAppEnv() string {
+	return c.GetServices().AppEnv
 }
 
-// GetServiceVersion 获取服务版本
-func (c *Config) GetServiceVersion() string {
-	return c.ServiceVersion
+// GetAppName 获取当前应用名称
+func (c *Config) GetAppName() string {
+	return c.GetServices().AppName
 }
 
-// GetEnv 获取环境
-func (c *Config) GetEnv() string {
-	return c.env
+// GetAppAuthToken 得到当前配置文件里的token
+func (c *Config) GetAppAuthToken() string {
+	return c.GetServices().AppAuthToken
 }
 
 // ========== 包级便捷函数（更新） ==========
@@ -274,13 +284,6 @@ func GetMicro() *subconfigs.MicroConfig {
 	return cfgInstance.GetMicro()
 }
 
-func GetAuth() *subconfigs.AuthConfig {
-	if cfgInstance == nil {
-		return &subconfigs.AuthConfig{}
-	}
-	return cfgInstance.GetAuth()
-}
-
 func GetService() *subconfigs.ServiceConfig {
 	if cfgInstance == nil {
 		return &subconfigs.ServiceConfig{}

config/subconfigs/auth_config.go

@@ -1,28 +0,0 @@
-package subconfigs
-
-// AuthConfig 认证配置
-type AuthConfig struct {
-	BaseConfig
-	Token string `yaml:"token"`
-}
-
-func NewAuthConfig() *AuthConfig {
-	return &AuthConfig{}
-}
-
-func (c *AuthConfig) SetDefaults() {
-	// 默认不设置token
-}
-
-func (c *AuthConfig) Load(data map[string]interface{}) error {
-	return c.LoadFromYAML(data, c)
-}
-
-func (c *AuthConfig) Validate() error {
-	// token 可以为空，有些环境不需要认证
-	return nil
-}
-
-func (c *AuthConfig) IsConfigured() bool {
-	return c.Token != ""
-}

config/subconfigs/service_config.go

@@ -8,7 +8,11 @@ import (
 
 type ServicesConfig struct {
 	BaseConfig
-	Services map[string]*ServiceConfig `yaml:"services"`
+	AppName      string                    `yaml:"app_name"`       //当前应用名称
+	AppVersion   string                    `yaml:"app_version"`    //当前应用版本
+	AppEnv       string                    `yaml:"app_env"`        //环境参数 dev test prod
+	AppAuthToken string                    `yaml:"app_auth_token"` //使用静态认证的时候使用的token
+	Services     map[string]*ServiceConfig `yaml:"services"`       //多个服务配置项
 }
 
 // DatabaseConfig 数据库配置
@@ -24,6 +28,9 @@ type ServiceConfig struct {
 
 // SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 func (c *ServicesConfig) SetDefaults() {
+	if c.AppEnv == "" {
+		c.AppEnv = "dev"
+	}
 	//因为是多集合，外层调这里赋默认值，这个时候对象还没有建立。赋默认值的地方移到其他地方去
 }
 

test.go

@@ -24,8 +24,8 @@ func main() {
 		fmt.Printf("Database: %s\n", dbConfig.Database)
 	}
 
-	authConfig := cfg.GetAuth()
-	fmt.Printf("token: %s\n", authConfig.Token)
+	//authConfig := cfg.GetAuth()
+	//fmt.Printf("token: %s\n", authConfig.Token)
 
 	serviceConfig := cfg.GetService()
 	fmt.Printf("ReadTimeout: %d秒\n", serviceConfig.ReadTimeout)