支持多微服务

config/config.go

@@ -34,11 +34,16 @@ type IConfig interface {
 	SetServiceName(name string)
 	SetServiceVersion(version string)
 	SetEnv(name string)
+
+	GetServiceVersion() string
+	GetEnv() string
 }
 
 // Config 主配置结构体 - 访问门面
 type Config struct {
-	initError error // 初始化错误
+	initError      error  // 初始化错误
+	ServiceVersion string //当前启动微服务版本
+	env            string //当前启动微服务环境dev test prod
 }
 
 // ========== 数据库相关方法（更新） ==========
@@ -120,13 +125,37 @@ func (c *Config) GetAuth() *subconfigs.AuthConfig {
 	return nil
 }
 
-func (c *Config) GetService() *subconfigs.ServiceConfig {
-	if config := subconfigs.GetRegisteredConfig("service"); config != nil {
-		return config.(*subconfigs.ServiceConfig)
+// ========== 微服务相关方法（更新） ==========
+
+// GetServices 获取所有微服务配置
+func (c *Config) GetServices() *subconfigs.ServicesConfig {
+	if config := subconfigs.GetRegisteredConfig("services"); config != nil {
+		if dbs, ok := config.(*subconfigs.ServicesConfig); ok {
+			return dbs
+		}
 	}
 	return nil
 }
 
+// GetService 获取默认微服务配置（向后兼容）
+func (c *Config) GetService() *subconfigs.ServiceConfig {
+	dbs := c.GetServices()
+	if dbs == nil {
+		logger.Errorf("获取默认微服务配置发生错误：配置为空！")
+		return nil
+	}
+	return dbs.GetDefaultService()
+}
+
+// GetServiceConfig 按名称获取微服务配置
+func (c *Config) GetServiceConfig(name string) *subconfigs.ServiceConfig {
+	dbs := c.GetServices()
+	if dbs == nil {
+		return nil
+	}
+	return dbs.GetService(name)
+}
+
 func (c *Config) GetHTTP() *subconfigs.HTTPConfig {
 	if config := subconfigs.GetRegisteredConfig("http"); config != nil {
 		return config.(*subconfigs.HTTPConfig)
@@ -165,9 +194,7 @@ func (c *Config) IsRedisConfigured() bool {
 
 // 设置方法
 func (c *Config) SetEnv(name string) {
-	if c.GetService().Env == "" {
-		c.GetService().Env = name
-	}
+	c.env = name
 }
 
 func (c *Config) SetServiceName(name string) {
@@ -177,7 +204,17 @@ func (c *Config) SetServiceName(name string) {
 }
 
 func (c *Config) SetServiceVersion(version string) {
-	c.GetService().ServiceVersion = version
+	c.ServiceVersion = version
+}
+
+// GetServiceVersion 获取服务版本
+func (c *Config) GetServiceVersion() string {
+	return c.ServiceVersion
+}
+
+// GetEnv 获取环境
+func (c *Config) GetEnv() string {
+	return c.env
 }
 
 // ========== 包级便捷函数（更新） ==========
@@ -251,6 +288,14 @@ func GetService() *subconfigs.ServiceConfig {
 	return cfgInstance.GetService()
 }
 
+// GetServiceConfig 包级便捷函数 - 按名称获取数微服务配置
+func GetServiceConfig(name string) *subconfigs.ServiceConfig {
+	if cfgInstance == nil {
+		return nil
+	}
+	return cfgInstance.GetServiceConfig(name)
+}
+
 // ========== 单例管理 ==========
 
 var (

config/subconfigs/database_config.go

@@ -28,18 +28,19 @@ type DatabaseConfig struct {
 
 // SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 func (c *DatabasesConfig) SetDefaults() {
-	if c.Databases == nil {
-		c.Databases = make(map[string]*DatabaseConfig)
-		log.Println("⚠️  数据库配置为空，已初始化空的数据库配置")
-		return
-	}
-
-	// 为每个数据库配置设置默认值
-	for _, db := range c.Databases {
-		if db != nil {
-			db.SetDefaults()
-		}
-	}
+	//因为是多集合，外层调这里赋默认值，这个时候对象还没有建立。赋默认值的地方移到其他地方去
+	// if c.Databases == nil {
+	// 	c.Databases = make(map[string]*DatabaseConfig)
+	// 	log.Println("⚠️  数据库配置为空，已初始化空的数据库配置")
+	// 	return
+	// }
+
+	// // 为每个数据库配置设置默认值
+	// for _, db := range c.Databases {
+	// 	if db != nil {
+	// 		db.SetDefaults()
+	// 	}
+	// }
 }
 
 func (c *DatabasesConfig) Load(data map[string]interface{}) error {
@@ -61,8 +62,9 @@ func (c *DatabasesConfig) Load(data map[string]interface{}) error {
 			}
 		}
 
-		// 加载单个数据库配置
 		dbConfig := &DatabaseConfig{}
+		dbConfig.SetDefaults() // 先设置默认值
+		// 加载单个数据库配置
 		if err := dbConfig.Load(stringMap); err != nil {
 			return fmt.Errorf("failed to load database '%s' config: %v", dbName, err)
 		}
@@ -123,9 +125,9 @@ func (c *DatabaseConfig) Validate() error {
 
 // Validate 验证配置（多数据库配置）
 func (c *DatabasesConfig) Validate() error {
-	if c.Databases == nil || len(c.Databases) == 0 {
+	if c.Databases == nil {
 		log.Println("❌ 错误: 未找到任何数据库配置，请检查配置文件中的 'databases' 配置")
-		return fmt.Errorf("no database configurations found")
+		return fmt.Errorf("no databases configurations found")
 	}
 
 	// 必须要有默认数据库

config/subconfigs/service_config.go

@@ -1,49 +1,228 @@
+// subconfigs/service_config.go
 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+	"log"
+)
 
-// ServiceConfig 微服务配置
+type ServicesConfig struct {
+	BaseConfig
+	Services map[string]*ServiceConfig `yaml:"services"`
+}
+
+// DatabaseConfig 数据库配置
 type ServiceConfig struct {
 	BaseConfig
-	ServiceName    string `yaml:"service_name"`
-	ServiceVersion string `yaml:"service_version"`
-	ServiceTag     string `yaml:"service_tags"`
-	Port           int    `yaml:"port"`
-	ReadTimeout    int    `yaml:"read_timeout"`
-	WriteTimeout   int    `yaml:"write_timeout"`
-	IdleTimeout    int    `yaml:"idle_timeout"`
-	TrustedProxies string `yaml:"trusted_proxies"`
-	InstanceName   string `yaml:"instance-name"`
-	Env            string `yaml:"env"`
+	Port         int    `yaml:"port"`
+	ServiceName  string `yaml:"service_name"`
+	InstanceName string `yaml:"instance_name"`
+	ReadTimeout  int    `yaml:"read_timeout"`
+	WriteTimeout int    `yaml:"write_timeout"`
+	IdleTimeout  int    `yaml:"idle_timeout"`
 }
 
-func NewServiceConfig() *ServiceConfig {
-	return &ServiceConfig{}
+// SetDefaults 设置默认值 - 实现 ConfigLoader 接口
+func (c *ServicesConfig) SetDefaults() {
+	//因为是多集合，外层调这里赋默认值，这个时候对象还没有建立。赋默认值的地方移到其他地方去
 }
 
+func (c *ServicesConfig) Load(data map[string]interface{}) error {
+	// 初始化
+	c.Services = make(map[string]*ServiceConfig)
+
+	// 遍历所有配置
+	for dbName, dbData := range data {
+		dbDataMap, ok := dbData.(map[interface{}]interface{})
+		if !ok {
+			return fmt.Errorf("service '%s' config is not a map", dbName)
+		}
+
+		// 转换为 map[string]interface{}
+		stringMap := make(map[string]interface{})
+		for k, v := range dbDataMap {
+			if key, ok := k.(string); ok {
+				stringMap[key] = v
+			}
+		}
+
+		// 创建 ServiceConfig 对象并设置默认值
+		dbConfig := &ServiceConfig{}
+		dbConfig.SetDefaults() // 先设置默认值
+
+		// 加载单个服务配置
+		if err := dbConfig.Load(stringMap); err != nil {
+			return fmt.Errorf("failed to load servuce '%s' config: %v", dbName, err)
+		}
+
+		c.Services[dbName] = dbConfig
+	}
+
+	// 设置默认值和验证
+	//c.SetDefaults()
+	return c.Validate()
+}
+
+// SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 func (c *ServiceConfig) SetDefaults() {
-	c.ServiceName = "myService"
-	c.Port = 8080
-	c.ReadTimeout = 30
-	c.WriteTimeout = 30
-	c.IdleTimeout = 60
+
+	if c.Port == 0 {
+		c.Port = 8080
+	}
+	if c.IdleTimeout == 0 {
+		c.IdleTimeout = 60
+	}
+	if c.ReadTimeout == 0 {
+		c.ReadTimeout = 30
+	}
+	if c.WriteTimeout == 0 {
+		c.WriteTimeout = 30
+	}
 }
 
+// Load 从yaml数据加载 - 实现 ConfigLoader 接口
 func (c *ServiceConfig) Load(data map[string]interface{}) error {
+	// 虽然可能不会被直接调用，但为了接口完整性还是要实现
 	return c.LoadFromYAML(data, c)
 }
 
+// ========== 业务方法 ==========
+
+// Validate 验证配置（数据库配置）
 func (c *ServiceConfig) Validate() error {
-	if c.ServiceName == "" {
-		return fmt.Errorf("service name is required")
-	}
+
 	if c.Port <= 0 || c.Port > 65535 {
-		return fmt.Errorf("invalid port: %d", c.Port)
+		return fmt.Errorf("invalid service port: %d", c.Port)
 	}
+
 	return nil
 }
 
+// Validate 验证配置（多数据库配置）
+func (c *ServicesConfig) Validate() error {
+	if c.Services == nil {
+		log.Println("❌ 错误: 未找到任何微服务配置，请检查配置文件中的 'services' 配置")
+		return fmt.Errorf("no services configurations found")
+	}
+
+	// 必须要有默认数据库
+	if _, exists := c.Services["default"]; !exists {
+		availableDBs := c.GetAllServiceNames()
+		log.Printf("❌ 错误: 默认微服务配置未找到。可用的微服务配置: %v。请在配置文件中添加 'default' 微服务", availableDBs)
+		return fmt.Errorf("default service not found")
+	}
+
+	// 验证每个数据库配置
+	for name, db := range c.Services {
+		if db == nil {
+			log.Printf("❌ 错误: 微服务 '%s' 配置为空", name)
+			return fmt.Errorf("service '%s' configuration is nil", name)
+		}
+
+		if err := db.Validate(); err != nil {
+			log.Printf("❌ 错误: 微服务 '%s' 验证失败: %v", name, err)
+			return fmt.Errorf("service '%s' validation failed: %v", name, err)
+		}
+	}
+
+	log.Printf("✅ 微服务配置验证通过，找到 %d 个微服务配置", len(c.Services))
+	return nil
+}
+
+// IsConfigured 判断是否已配置（数据库配置）
+func (c *ServiceConfig) IsConfigured() bool {
+
+	if c.Port <= 0 {
+		log.Println("⚠️  警告: 微服务 Port 未配置或无效")
+		return false
+	}
+
+	return true
+}
+
+// IsConfigured 判断是否已配置（多数据库配置）
+func (c *ServicesConfig) IsConfigured() bool {
+	defaultDB := c.GetDefaultService()
+	if defaultDB == nil {
+		log.Println("❌ 错误: 默认微服务不存在")
+		return false
+	}
+
+	if !defaultDB.IsConfigured() {
+		log.Println("❌ 错误: 默认微服务配置不完整")
+		return false
+	}
+
+	return true
+}
+
+// GetDefaultService 获取默认微服务（必须存在）
+func (c *ServicesConfig) GetDefaultService() *ServiceConfig {
+	if c.Services == nil {
+		log.Println("❌ 错误: 尝试获取默认微服务时，微服务配置为空")
+		return nil
+	}
+
+	if db, exists := c.Services["default"]; exists {
+		return db
+	}
+
+	// 如果没有名为default的，尝试返回第一个（但会记录警告）
+	for name, db := range c.Services {
+		log.Printf("⚠️  警告: 未找到名为 'default' 的微服务，使用第一个微服务 '%s' 作为默认", name)
+		return db
+	}
+
+	log.Println("❌ 错误: 服务模块配置中没有任何配置")
+	return nil
+}
+
+// GetService 按名称获取微服务（为空时记录错误）
+func (c *ServicesConfig) GetService(name string) *ServiceConfig {
+	if c.Services == nil {
+		log.Printf("❌ 错误: 尝试获取微服务 '%s' 时，微服务配置为空", name)
+		return nil
+	}
+
+	db := c.Services[name]
+	if db == nil {
+		availableDBs := c.GetAllServiceNames()
+		log.Printf("❌ 错误: 微服务 '%s' 不存在。可用的微服务: %v", name, availableDBs)
+	}
+
+	return db
+}
+
+// GetAllServiceNames 获取所有数据库名称
+func (c *ServicesConfig) GetAllServiceNames() []string {
+	if c.Services == nil {
+		log.Println("⚠️  警告: 尝试获取微服务配置节点名称时，微服务配置为空")
+		return []string{}
+	}
+
+	names := make([]string, 0, len(c.Services))
+	for name := range c.Services {
+		names = append(names, name)
+	}
+	return names
+}
+
+// GetServiceNamesWithoutDefault 获取除default外的所有微服务配置节点名称
+func (c *ServicesConfig) GetServiceNamesWithoutDefault() []string {
+	if c.Services == nil {
+		return []string{}
+	}
+
+	names := make([]string, 0, len(c.Services)-1)
+	for name := range c.Services {
+		if name != "default" {
+			names = append(names, name)
+		}
+	}
+	return names
+}
+
 // 自动注册
 func init() {
-	Register("service", &ServiceConfig{})
+	Register("services", &ServicesConfig{})
 }

myservice/start_service.go

@@ -1,103 +0,0 @@
-package myservice
-
-import (
-	"fmt"
-	"log"
-	"time"
-
-	"git.x2erp.com/qdy/go-base/config"
-	"github.com/go-micro/plugins/v4/registry/consul"
-	"github.com/urfave/cli/v2"
-	"go-micro.dev/v4/registry"
-	"go-micro.dev/v4/web"
-)
-
-// StartWithRegistry starts microservice with registry (e.g., Consul)
-func StartWithRegistry(cfg config.IConfig) web.Service {
-	// Get service information from config
-	serviceConfig := cfg.GetService()
-	microConfig := cfg.GetMicro()
-
-	// 1. Create Consul registry
-	consulRegistry := consul.NewRegistry(
-		registry.Addrs(microConfig.RegistryAddress),
-	)
-
-	// 2. Create HTTP web service (for external HTTP access)
-	service := web.NewService(
-		web.Name(serviceConfig.ServiceName),
-		web.Version(serviceConfig.ServiceVersion),
-		web.Address(fmt.Sprintf(":%d", serviceConfig.Port)),
-		web.Registry(consulRegistry),
-		web.RegisterTTL(30*time.Second),      // Health check interval
-		web.RegisterInterval(20*time.Second), // Registration interval
-		web.Flags(&cli.StringFlag{
-			Name:  "env",
-			Value: "dev",
-			Usage: "环境参数"}),
-		web.Action(func(c *cli.Context) {
-			cfg.SetEnv(c.String("env"))
-			log.Printf("环境参数: %s\n", serviceConfig.Env)
-		}),
-	)
-
-	// 3. Initialize service
-	service.Init()
-
-	log.Printf("Microservice started (with registry)")
-	log.Printf("   • Service name: %s", serviceConfig.ServiceName)
-	log.Printf("   • Version: %s", serviceConfig.ServiceVersion)
-	log.Printf("   • Port: %d", serviceConfig.Port)
-	log.Printf("   • Registry: %s", microConfig.RegistryAddress)
-	log.Printf("   • IdleTimeout: %d秒", serviceConfig.IdleTimeout)
-	log.Printf("   • ReadTimeout: %d秒", serviceConfig.ReadTimeout)
-	log.Printf("   • WriteTimeout: %d秒", serviceConfig.WriteTimeout)
-
-	// // Run in background
-	// go func() {
-	// 	if err := service.Run(); err != nil {
-	// 		log.Printf("Microservice stopped: %v", err)
-	// 	}
-	// }()
-
-	return service
-}
-
-// StartStandalone starts standalone microservice (not registered to registry)
-func StartStandalone(cfg config.IConfig) web.Service {
-	// Get service information from config
-	serviceConfig := cfg.GetService()
-
-	// Create HTTP web service (standalone operation)
-	service := web.NewService(
-		web.Name(serviceConfig.ServiceName),
-		web.Version(serviceConfig.ServiceVersion),
-		web.Address(fmt.Sprintf(":%d", serviceConfig.Port)),
-		// No Registry specified = standalone service
-	)
-
-	// Initialize service
-	if err := service.Init(); err != nil {
-		log.Fatalf("Service init failed: %v", err)
-	}
-
-	log.Printf("Standalone microservice started")
-	log.Printf("	• Service name: %s", serviceConfig.ServiceName)
-	log.Printf("	• Version: %s", serviceConfig.ServiceVersion)
-	log.Printf("	• Port: %d", serviceConfig.Port)
-	log.Printf("	• Mode: Standalone (no service discovery)")
-
-	// // Run in background
-	// go func() {
-	// 	if err := service.Run(); err != nil {
-	// 		log.Printf("Microservice stopped: %v", err)
-	// 	}
-	// }()
-
-	return service
-}
-
-// Start maintains compatibility with original interface, uses registry version by default
-func Start(cfg config.IConfig) web.Service {
-	return StartWithRegistry(cfg)
-}