go-base/config/config.go

package config

import (
	"sync"

	"git.x2erp.com/qdy/go-base/config/subconfigs"
	"git.x2erp.com/qdy/go-base/logger"
)

// IConfig 主配置接口（更新支持多数据库）
type IConfig interface {
	// 多数据库支持
	GetDatabase() *subconfigs.DatabaseConfig                  // 获取默认数据库（向后兼容）
	GetDatabases() *subconfigs.DatabasesConfig                // 获取所有数据库配置
	GetDatabaseConfig(name string) *subconfigs.DatabaseConfig // 按名称获取数据库配置

	// 其他配置（保持不变）
	GetRedis() *subconfigs.RedisConfig
	GetDoris() *subconfigs.DorisConfig
	GetRabbitMQ() *subconfigs.RabbitMQConfig
	GetAuth() *subconfigs.AuthConfig
	GetService() *subconfigs.ServiceConfig
	GetHTTP() *subconfigs.HTTPConfig
	GetMicro() *subconfigs.MicroConfig
	GetLog() *subconfigs.LogConfig
	GetInitError() error

	// 配置检查（更新）
	IsDatabaseConfigured() bool
	IsDatabaseConfiguredByName(name string) bool
	IsDorisConfigured() bool
	IsRedisConfigured() bool

	SetServiceName(name string)
	SetServiceVersion(version string)
	SetEnv(name string)

	GetServiceVersion() string
	GetEnv() string
}

// Config 主配置结构体 - 访问门面
type Config struct {
	initError      error  // 初始化错误
	ServiceVersion string //当前启动微服务版本
	env            string //当前启动微服务环境dev test prod
}

// ========== 数据库相关方法（更新） ==========

// GetDatabases 获取所有数据库配置
func (c *Config) GetDatabases() *subconfigs.DatabasesConfig {
	if config := subconfigs.GetRegisteredConfig("databases"); config != nil {
		if dbs, ok := config.(*subconfigs.DatabasesConfig); ok {
			return dbs
		}
	}
	return nil
}

// GetDatabase 获取默认数据库配置（向后兼容）
func (c *Config) GetDatabase() *subconfigs.DatabaseConfig {
	dbs := c.GetDatabases()
	if dbs == nil {
		logger.Errorf("获取默认数据库连接配置发生错误：配置为空！")
		return nil
	}
	return dbs.GetDefaultDatabase()
}

// GetDatabaseConfig 按名称获取数据库配置
func (c *Config) GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
	dbs := c.GetDatabases()
	if dbs == nil {
		return nil
	}
	return dbs.GetDatabase(name)
}

// IsDatabaseConfigured 检查默认数据库是否配置
func (c *Config) IsDatabaseConfigured() bool {
	dbs := c.GetDatabases()
	if dbs == nil {
		return false
	}
	return dbs.IsConfigured()
}

// IsDatabaseConfiguredByName 检查指定名称的数据库是否配置
func (c *Config) IsDatabaseConfiguredByName(name string) bool {
	dbs := c.GetDatabases()
	if dbs == nil {
		return false
	}
	return dbs.IsConfigured()
}

// ========== 其他配置方法（保持不变） ==========

func (c *Config) GetRedis() *subconfigs.RedisConfig {
	if config := subconfigs.GetRegisteredConfig("redis"); config != nil {
		return config.(*subconfigs.RedisConfig)
	}
	return nil
}

func (c *Config) GetDoris() *subconfigs.DorisConfig {
	if config := subconfigs.GetRegisteredConfig("doris"); config != nil {
		return config.(*subconfigs.DorisConfig)
	}
	return nil
}

func (c *Config) GetRabbitMQ() *subconfigs.RabbitMQConfig {
	if config := subconfigs.GetRegisteredConfig("rabbitmq"); config != nil {
		return config.(*subconfigs.RabbitMQConfig)
	}
	return nil
}

func (c *Config) GetAuth() *subconfigs.AuthConfig {
	if config := subconfigs.GetRegisteredConfig("auth"); config != nil {
		return config.(*subconfigs.AuthConfig)
	}
	return nil
}

// ========== 微服务相关方法（更新） ==========

// 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)
	}
	return nil
}

func (c *Config) GetMicro() *subconfigs.MicroConfig {
	if config := subconfigs.GetRegisteredConfig("micro"); config != nil {
		return config.(*subconfigs.MicroConfig)
	}
	return nil
}

func (c *Config) GetLog() *subconfigs.LogConfig {
	if config := subconfigs.GetRegisteredConfig("log"); config != nil {
		return config.(*subconfigs.LogConfig)
	}
	return nil
}

func (c *Config) GetInitError() error {
	return c.initError
}

// 实现 IConfig 接口的其他方法
func (c *Config) IsDorisConfigured() bool {
	doris := c.GetDoris()
	return doris != nil && doris.IsConfigured()
}

func (c *Config) IsRedisConfigured() bool {
	redis := c.GetRedis()
	return redis != nil && redis.IsConfigured()
}

// 设置方法
func (c *Config) SetEnv(name string) {
	c.env = name
}

func (c *Config) SetServiceName(name string) {
	if c.GetService().ServiceName == "" {
		c.GetService().ServiceName = name
	}
}

func (c *Config) SetServiceVersion(version string) {
	c.ServiceVersion = version
}

// GetServiceVersion 获取服务版本
func (c *Config) GetServiceVersion() string {
	return c.ServiceVersion
}

// GetEnv 获取环境
func (c *Config) GetEnv() string {
	return c.env
}

// ========== 包级便捷函数（更新） ==========

// GetDatabases 包级便捷函数 - 获取所有数据库配置
func GetDatabases() *subconfigs.DatabasesConfig {
	if cfgInstance == nil {
		return nil
	}
	return cfgInstance.GetDatabases()
}

// GetDatabase 包级便捷函数 - 获取默认数据库配置（向后兼容）
func GetDatabase() *subconfigs.DatabaseConfig {
	if cfgInstance == nil {
		return &subconfigs.DatabaseConfig{}
	}
	return cfgInstance.GetDatabase()
}

// GetDatabaseConfig 包级便捷函数 - 按名称获取数据库配置
func GetDatabaseConfig(name string) *subconfigs.DatabaseConfig {
	if cfgInstance == nil {
		return nil
	}
	return cfgInstance.GetDatabaseConfig(name)
}

// GetRedis 包级便捷函数 - 获取Redis配置
func GetRedis() *subconfigs.RedisConfig {
	if cfgInstance == nil {
		return &subconfigs.RedisConfig{}
	}
	return cfgInstance.GetRedis()
}

// GetHTTP 包级便捷函数 - 获取HTTP配置
func GetHTTP() *subconfigs.HTTPConfig {
	if cfgInstance == nil {
		return &subconfigs.HTTPConfig{}
	}
	return cfgInstance.GetHTTP()
}

// GetLog 包级便捷函数 - 获取日志配置
func GetLog() *subconfigs.LogConfig {
	if cfgInstance == nil {
		return &subconfigs.LogConfig{}
	}
	return cfgInstance.GetLog()
}

func GetMicro() *subconfigs.MicroConfig {
	if cfgInstance == nil {
		return &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{}
	}
	return cfgInstance.GetService()
}

// GetServiceConfig 包级便捷函数 - 按名称获取数微服务配置
func GetServiceConfig(name string) *subconfigs.ServiceConfig {
	if cfgInstance == nil {
		return nil
	}
	return cfgInstance.GetServiceConfig(name)
}

// ========== 单例管理 ==========

var (
	cfgInstance *Config
	once        sync.Once
)

// GetConfig 获取主配置（单例模式）
func GetConfig() (IConfig, error) {
	once.Do(func() {
		cfgInstance = &Config{}
		cfgInstance.initError = LoadConfig() // 加载配置到注册表
	})
	return cfgInstance, cfgInstance.initError
}

// GetInitError 包级函数 - 兼容现有代码调用
func GetInitError() error {
	return cfgInstance.GetInitError()
}

// GetConfigWithError 新方法 - 同时获取配置和错误
func GetConfigWithError() (IConfig, error) {
	cfg, err := GetConfig()
	return cfg, err
}