增加自动获取所有配置文件方法，这样可以注册到数据库

config/config.go

 import (
 	"sync"
 
+	"git.x2erp.com/qdy/go-base/config/core"
 	"git.x2erp.com/qdy/go-base/config/subconfigs"
 )
 
 
 // GetDatabaseConfig 按名称获取数据库配置
 func (c *Config) GetDatabaseConfig() *subconfigs.DatabaseConfig {
-	if config := subconfigs.GetRegisteredConfig("database"); config != nil {
+	if config := core.GetRegisteredConfig("database"); config != nil {
 		return config.(*subconfigs.DatabaseConfig)
 	}
 	return nil
 // GetDbsConfig 按名称获取数据库配置
 func (c *Config) GetDbsConfig(name string) (*subconfigs.DatabaseConfig, bool) {
 	// 获取 dbs 配置
-	dbsConfig := subconfigs.GetRegisteredConfig("dbs")
+	dbsConfig := core.GetRegisteredConfig("dbs")
 	if dbsConfig == nil {
 		return nil, false
 	}
 
 	// 将 DbConfig 转换为 DatabaseConfig
 	return &subconfigs.DatabaseConfig{
-		BaseConfig: subconfigs.BaseConfig{},
+		BaseConfig: core.BaseConfig{},
 		DbConfig:   *dbConfig,
 	}, true
 }
 
 func (c *Config) GetRedisConfig() *subconfigs.RedisConfig {
-	if config := subconfigs.GetRegisteredConfig("redis"); config != nil {
+	if config := core.GetRegisteredConfig("redis"); config != nil {
 		return config.(*subconfigs.RedisConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetConsulConfig() *subconfigs.ConsulConfig {
-	if config := subconfigs.GetRegisteredConfig("consul"); config != nil {
+	if config := core.GetRegisteredConfig("consul"); config != nil {
 		return config.(*subconfigs.ConsulConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetMongoDBConfig() *subconfigs.MongoDBConfig {
-	if config := subconfigs.GetRegisteredConfig("mongodb"); config != nil {
+	if config := core.GetRegisteredConfig("mongodb"); config != nil {
 		return config.(*subconfigs.MongoDBConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetDorisConfig() *subconfigs.DorisConfig {
-	if config := subconfigs.GetRegisteredConfig("doris"); config != nil {
+	if config := core.GetRegisteredConfig("doris"); config != nil {
 		return config.(*subconfigs.DorisConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetRabbitMQConfig() *subconfigs.RabbitMQConfig {
-	if config := subconfigs.GetRegisteredConfig("rabbitmq"); config != nil {
+	if config := core.GetRegisteredConfig("rabbitmq"); config != nil {
 		return config.(*subconfigs.RabbitMQConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetServiceConfig() *subconfigs.ServiceConfig {
-	if config := subconfigs.GetRegisteredConfig("service"); config != nil {
+	if config := core.GetRegisteredConfig("service"); config != nil {
 		return config.(*subconfigs.ServiceConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetMcpServiceConfig() *subconfigs.McpServiceConfig {
-	if config := subconfigs.GetRegisteredConfig("mcpservice"); config != nil {
+	if config := core.GetRegisteredConfig("mcpservice"); config != nil {
 		return config.(*subconfigs.McpServiceConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetHTTPConfig() *subconfigs.HTTPConfig {
-	if config := subconfigs.GetRegisteredConfig("http"); config != nil {
+	if config := core.GetRegisteredConfig("http"); config != nil {
 		return config.(*subconfigs.HTTPConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetMicroConfig() *subconfigs.MicroConfig {
-	if config := subconfigs.GetRegisteredConfig("micro"); config != nil {
+	if config := core.GetRegisteredConfig("micro"); config != nil {
 		return config.(*subconfigs.MicroConfig)
 	}
 	return nil
 }
 
 func (c *Config) GetLogConfig() *subconfigs.LogConfig {
-	if config := subconfigs.GetRegisteredConfig("log"); config != nil {
+	if config := core.GetRegisteredConfig("log"); config != nil {
 		return config.(*subconfigs.LogConfig)
 	}
 	return nil

config/subconfigs/base.go → config/core/core_base_config.go

-package subconfigs
+package core
 
 import (
 	"gopkg.in/yaml.v2"

config/core/core_metadata_config.go

+package core
+
+import (
+	"reflect"
+	"strings"
+)
+
+// ConfigMeta 配置元信息
+type ConfigMeta struct {
+	Name   string               `json:"name"`   // 配置名称，如 "consul"
+	Desc   string               `json:"desc"`   // 配置描述
+	Fields map[string]FieldMeta `json:"fields"` // 字段信息
+}
+
+// FieldMeta 字段元信息
+type FieldMeta struct {
+	Type    string `json:"type"`    // 字段类型，如 "string"
+	YamlTag string `json:"yamlTag"` // YAML标签，如 "address"
+	Desc    string `json:"desc"`    // 字段描述
+}
+
+// GetAllConfigsMeta 获取所有配置的元信息
+func GetAllConfigsMeta() map[string]*ConfigMeta {
+	// 获取所有配置实例
+	allConfigs := GetAllConfigs()
+	result := make(map[string]*ConfigMeta, len(allConfigs))
+
+	// 遍历所有配置
+	for name, config := range allConfigs {
+		meta := getConfigMeta(name, config)
+		result[name] = meta
+	}
+
+	return result
+}
+
+// GetConfigMeta 获取单个配置的元信息
+func GetConfigMeta(name string) (*ConfigMeta, error) {
+	config := GetConfig(name)
+	if config == nil {
+		return nil, nil
+	}
+
+	return getConfigMeta(name, config), nil
+}
+
+// getConfigMeta 内部方法：获取配置元信息
+func getConfigMeta(name string, config ConfigLoader) *ConfigMeta {
+	meta := &ConfigMeta{
+		Name:   name,
+		Desc:   config.Description(),
+		Fields: make(map[string]FieldMeta),
+	}
+
+	// 使用反射获取类型信息
+	t := reflect.TypeOf(config)
+
+	// 如果是指针类型，获取其指向的类型
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+
+	// 遍历所有字段
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		yamlTag := field.Tag.Get("yaml")
+
+		// 跳过BaseConfig这种匿名字段（除非是inline）
+		if field.Anonymous && !strings.Contains(yamlTag, "inline") {
+			continue
+		}
+
+		// 处理inline字段
+		if strings.Contains(yamlTag, "inline") {
+			// 获取字段类型
+			fieldType := field.Type
+
+			// 如果是map类型，提取map值的结构体信息
+			if fieldType.Kind() == reflect.Map {
+				// 获取map的值类型
+				valueType := fieldType.Elem()
+
+				// 如果是指针类型，获取指向的类型
+				if valueType.Kind() == reflect.Ptr {
+					valueType = valueType.Elem()
+				}
+
+				// 如果值类型是结构体，提取其字段
+				if valueType.Kind() == reflect.Struct {
+					// 创建FieldMeta
+					fieldMeta := FieldMeta{
+						Type:    field.Type.String(),
+						YamlTag: yamlTag,
+						Desc:    field.Tag.Get("desc"),
+					}
+
+					// 提取结构体字段
+					valueFields := make(map[string]FieldMeta)
+					extractStructFields(valueType, valueFields)
+
+					// 这里可以添加一个子字段信息，或者直接合并到主字段
+					// 为了简单，我们直接合并
+					for name, fm := range valueFields {
+						meta.Fields[name] = fm
+					}
+
+					// 同时保留map字段本身
+					meta.Fields[field.Name] = fieldMeta
+				} else {
+					// 不是结构体类型，只显示map本身
+					meta.Fields[field.Name] = FieldMeta{
+						Type:    field.Type.String(),
+						YamlTag: yamlTag,
+						Desc:    field.Tag.Get("desc"),
+					}
+				}
+			} else if fieldType.Kind() == reflect.Struct ||
+				(fieldType.Kind() == reflect.Ptr && fieldType.Elem().Kind() == reflect.Struct) {
+				// 对于结构体类型（或指向结构体的指针），递归提取内联结构体的字段
+				if fieldType.Kind() == reflect.Ptr {
+					fieldType = fieldType.Elem()
+				}
+				extractInlineFields(fieldType, meta.Fields)
+			} else {
+				// 其他类型
+				meta.Fields[field.Name] = FieldMeta{
+					Type:    field.Type.String(),
+					YamlTag: yamlTag,
+					Desc:    field.Tag.Get("desc"),
+				}
+			}
+			continue
+		}
+
+		// 处理普通字段
+		meta.Fields[field.Name] = FieldMeta{
+			Type:    field.Type.String(),
+			YamlTag: yamlTag,
+			Desc:    field.Tag.Get("desc"),
+		}
+	}
+
+	return meta
+}
+
+// extractInlineFields 提取内联结构体的字段
+func extractInlineFields(t reflect.Type, fields map[string]FieldMeta) {
+	// 遍历结构体的字段
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+
+		// 跳过匿名字段
+		if field.Anonymous {
+			continue
+		}
+
+		fields[field.Name] = FieldMeta{
+			Type:    field.Type.String(),
+			YamlTag: field.Tag.Get("yaml"),
+			Desc:    field.Tag.Get("desc"),
+		}
+	}
+}
+
+// extractStructFields 提取结构体字段
+func extractStructFields(t reflect.Type, fields map[string]FieldMeta) {
+	// 遍历结构体的字段
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+
+		// 跳过匿名字段
+		if field.Anonymous {
+			continue
+		}
+
+		fields[field.Name] = FieldMeta{
+			Type:    field.Type.String(),
+			YamlTag: field.Tag.Get("yaml"),
+			Desc:    field.Tag.Get("desc"),
+		}
+	}
+}

config/subconfigs/register_config.go → config/core/core_register_config.go

-package subconfigs
+package core
 
 // ConfigLoader 配置加载接口
 type ConfigLoader interface {
 	SetDefaults()
 	Load(data map[string]interface{}) error
+	Description() string // 新增：返回配置描述
 	//Validate() error
 }
 

config/loader.go

 	"os"
 	"path/filepath"
 
-	"git.x2erp.com/qdy/go-base/config/subconfigs"
+	"git.x2erp.com/qdy/go-base/config/core"
 	"gopkg.in/yaml.v2"
 )
 
 // 新增方法，供外部调用（比如从数据库加载后使用）
 func LoadConfigFromMap(rawConfig map[string]interface{}) {
 	// 1. 设置所有注册配置的默认值
-	for _, config := range subconfigs.GetAllConfigs() {
+	for _, config := range core.GetAllConfigs() {
 		config.SetDefaults()
 	}
 
 	// 2. 循环注册表，为每个配置加载数据
-	for name, config := range subconfigs.GetAllConfigs() {
+	for name, config := range core.GetAllConfigs() {
 		if configData, ok := rawConfig[name].(map[interface{}]interface{}); ok {
 			// 转换为 map[string]interface{}
 			strMap := convertMap(configData)

config/subconfigs/consul_config.go

 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+)
 
 // Config Consul客户端配置
 type ConsulConfig struct {
-	BaseConfig
-	Address string `yaml:"address"` // Consul服务器地址，如："localhost:8500"
-	Token   string `yaml:"token"`   // ACL token（可选）
-	Scheme  string `yaml:"scheme"`  // "http" 或 "https"
+	core.BaseConfig
+	Address string `yaml:"address" desc:"Consul服务器地址，如：localhost:8500"`
+	Token   string `yaml:"token" desc:"ACL token（可选）"`
+	Scheme  string `yaml:"scheme" desc:"http 或 https"`
+}
+
+// consul.go
+func (c *ConsulConfig) Description() string {
+	return "Consul客户端配置，用于服务发现和配置管理"
 }
 
 func NewConsulConfig() *ConsulConfig {
 }
 
 func (c *ConsulConfig) SetDefaults() {
-	//c.Address = "localhost:8500"
 	c.Scheme = "http"
 }
 
 
 // 自动注册
 func init() {
-	Register("consul", &ConsulConfig{})
+	core.Register("consul", &ConsulConfig{})
 }

config/subconfigs/database_common.go

 
 // DbConfig 单个数据库配置（共享结构）
 type DbConfig struct {
-	Type            string `yaml:"type"`
-	Host            string `yaml:"host"`
-	Port            int    `yaml:"port"`
-	Username        string `yaml:"username"`
-	Password        string `yaml:"password"`
-	Database        string `yaml:"database"`
-	MaxOpenConns    int    `yaml:"max_open_conns"`
-	MaxIdleConns    int    `yaml:"max_idle_conns"`
-	ConnMaxLifetime int    `yaml:"conn_max_lifetime"`
+	Type            string `yaml:"type" desc:"数据库类型，如：mysql、postgresql"`
+	Host            string `yaml:"host" desc:"数据库主机地址"`
+	Port            int    `yaml:"port" desc:"数据库端口"`
+	Username        string `yaml:"username" desc:"数据库用户名"`
+	Password        string `yaml:"password" desc:"数据库密码"`
+	Database        string `yaml:"database" desc:"数据库名称"`
+	MaxOpenConns    int    `yaml:"max_open_conns" desc:"最大打开连接数"`
+	MaxIdleConns    int    `yaml:"max_idle_conns" desc:"最大空闲连接数"`
+	ConnMaxLifetime int    `yaml:"conn_max_lifetime" desc:"连接最大生命周期（秒）"`
 }
 
 // SetDbDefaults 设置数据库配置默认值

config/subconfigs/database_config.go

 package subconfigs
 
+import "git.x2erp.com/qdy/go-base/config/core"
+
 // DatabaseConfig 单个数据库配置
 type DatabaseConfig struct {
-	BaseConfig
-	DbConfig `yaml:",inline"` // 嵌入共享的 DbConfig
+	core.BaseConfig
+	DbConfig `yaml:",inline" desc:"数据库连接配置"`
+}
+
+// consul.go
+func (c *DatabaseConfig) Description() string {
+	return "数据库连接配置"
 }
 
 func (c *DatabaseConfig) SetDefaults() {
 }
 
 func init() {
-	Register("database", &DatabaseConfig{})
+	core.Register("database", &DatabaseConfig{})
 }

config/subconfigs/dbs_config.go

 import (
 	"fmt"
 	"log"
+
+	"git.x2erp.com/qdy/go-base/config/core"
 )
 
 // DbsConfig 多数据库配置
 type DbsConfig struct {
-	BaseConfig
+	core.BaseConfig
 	Databases map[string]*DbConfig `yaml:",inline"`
 }
 
+func (c *DbsConfig) Description() string {
+	return "多个数据库连接配置"
+}
+
 func (c *DbsConfig) SetDefaults() {
 	for _, db := range c.Databases {
 		SetDbDefaults(db)
 }
 
 func init() {
-	Register("dbs", &DbsConfig{})
+	core.Register("dbs", &DbsConfig{})
 }

config/subconfigs/doris_config.go

 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+)
 
-// DorisConfig Doris配置
 type DorisConfig struct {
-	BaseConfig
-	FEHost            string `yaml:"fe_host"`
-	FEPort            int    `yaml:"fe_port"`
-	FEUsername        string `yaml:"fe_username"`
-	FEPassword        string `yaml:"fe_password"`
-	MySQLHost         string `yaml:"mysql_host"`
-	MySQLPort         int    `yaml:"mysql_port"`
-	MaxOpenConns      int    `yaml:"max_open_conns"`
-	MaxIdleConns      int    `yaml:"max_idle_conns"`
-	ConnMaxLifetime   int    `yaml:"conn_max_lifetime"`
-	StreamLoadTimeout int    `yaml:"stream_load_timeout"`
-	BatchSize         int    `yaml:"batch_size"`
+	core.BaseConfig
+	FEHost            string `yaml:"fe_host" desc:"Doris FE节点主机地址"`
+	FEPort            int    `yaml:"fe_port" desc:"Doris FE节点端口"`
+	FEUsername        string `yaml:"fe_username" desc:"Doris FE节点用户名"`
+	FEPassword        string `yaml:"fe_password" desc:"Doris FE节点密码"`
+	MySQLHost         string `yaml:"mysql_host" desc:"MySQL兼容接口主机地址"`
+	MySQLPort         int    `yaml:"mysql_port" desc:"MySQL兼容接口端口"`
+	MaxOpenConns      int    `yaml:"max_open_conns" desc:"最大打开连接数"`
+	MaxIdleConns      int    `yaml:"max_idle_conns" desc:"最大空闲连接数"`
+	ConnMaxLifetime   int    `yaml:"conn_max_lifetime" desc:"连接最大生命周期（秒）"`
+	StreamLoadTimeout int    `yaml:"stream_load_timeout" desc:"Stream Load超时时间（秒）"`
+	BatchSize         int    `yaml:"batch_size" desc:"批量操作大小"`
+}
+
+func (c *DorisConfig) Description() string {
+	return "Doris数据库连接配置"
 }
 
 func NewDorisConfig() *DorisConfig {
 
 // 自动注册
 func init() {
-	Register("doris", &DorisConfig{})
+	core.Register("doris", &DorisConfig{})
 }

config/subconfigs/http_config.go

 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+)
 
 // HTTPConfig HTTP客户端配置
 type HTTPConfig struct {
-	BaseConfig
-	Timeout             int  `yaml:"timeout"`
-	MaxIdleConns        int  `yaml:"max_idle_conns"`
-	MaxIdleConnsPerHost int  `yaml:"max_idle_conns_per_host"`
-	IdleConnTimeout     int  `yaml:"idle_conn_timeout"`
-	MaxConnsPerHost     int  `yaml:"max_conns_per_host"`
-	DisableCompression  bool `yaml:"disable_compression"`
-	DisableKeepAlives   bool `yaml:"disable_keep_alives"`
+	core.BaseConfig
+	Timeout             int  `yaml:"timeout" desc:"请求超时时间（秒）"`
+	MaxIdleConns        int  `yaml:"max_idle_conns" desc:"最大空闲连接数"`
+	MaxIdleConnsPerHost int  `yaml:"max_idle_conns_per_host" desc:"每个主机的最大空闲连接数"`
+	IdleConnTimeout     int  `yaml:"idle_conn_timeout" desc:"空闲连接超时时间（秒）"`
+	MaxConnsPerHost     int  `yaml:"max_conns_per_host" desc:"每个主机的最大连接数"`
+	DisableCompression  bool `yaml:"disable_compression" desc:"是否禁用压缩"`
+	DisableKeepAlives   bool `yaml:"disable_keep_alives" desc:"是否禁用长连接"`
+}
+
+func (c *HTTPConfig) Description() string {
+	return "调用其他api的http服务配置"
 }
 
 func NewHTTPConfig() *HTTPConfig {
 
 // 自动注册
 func init() {
-	Register("http", &HTTPConfig{})
+	core.Register("http", &HTTPConfig{})
 }

config/subconfigs/log_config.go

 import (
 	"fmt"
 	"strings"
+
+	"git.x2erp.com/qdy/go-base/config/core"
 )
 
 // LogConfig 日志配置
 type LogConfig struct {
-	BaseConfig
-	Level  string `yaml:"level" json:"level"`   // 日志级别
-	Output string `yaml:"output" json:"output"` // 输出目标：console,file,es
+	core.BaseConfig
+	Level  string `yaml:"level" json:"level" desc:"日志级别：debug, info, warn, error"`
+	Output string `yaml:"output" json:"output" desc:"输出目标：console,file,es"`
 	//JSONFormat bool   `yaml:"json_format" json:"json_format"` // 是否JSON格式
 
 	// 文件输出配置
-	FilePath   string `yaml:"file_path" json:"file_path"`
-	MaxSize    int    `yaml:"max_size" json:"max_size"`
-	MaxBackups int    `yaml:"max_backups" json:"max_backups"`
-	MaxAge     int    `yaml:"max_age" json:"max_age"`
-	Compress   bool   `yaml:"compress" json:"compress"`
+	FilePath   string `yaml:"file_path" json:"file_path" desc:"日志文件路径"`
+	MaxSize    int    `yaml:"max_size" json:"max_size" desc:"单个日志文件最大大小（MB）"`
+	MaxBackups int    `yaml:"max_backups" json:"max_backups" desc:"最大保留日志文件数"`
+	MaxAge     int    `yaml:"max_age" json:"max_age" desc:"日志文件最大保留天数"`
+	Compress   bool   `yaml:"compress" json:"compress" desc:"是否压缩旧日志文件"`
 
 	// ES输出配置（当Output包含"es"时生效）
-	ESPath     string `yaml:"es_path" json:"es_path"`         // ES地址
-	ESUsername string `yaml:"es_username" json:"es_username"` // 用户名（可选）
-	ESPassword string `yaml:"es_password" json:"es_password"` // 密码（可选）
+	ESPath     string `yaml:"es_path" json:"es_path" desc:"Elasticsearch地址"`
+	ESUsername string `yaml:"es_username" json:"es_username" desc:"Elasticsearch用户名（可选）"`
+	ESPassword string `yaml:"es_password" json:"es_password" desc:"Elasticsearch密码（可选）"`
 	//ESAPIKey   string `yaml:"es_api_key" json:"es_api_key"`     // API Key（可选）
 	//ESBuffer   int    `yaml:"es_buffer" json:"es_buffer"`       // 缓冲大小，默认10000
 	//ESMaxRetry int    `yaml:"es_max_retry" json:"es_max_retry"` // 最大重试，默认3
 }
 
+func (c *LogConfig) Description() string {
+	return "日志系统配置，支持控制台、文件、Elasticsearch等多种输出方式"
+}
+
 // NewLogConfig 创建日志配置实例
 func NewLogConfig() *LogConfig {
 	return &LogConfig{}
 
 // 自动注册
 func init() {
-	Register("log", &LogConfig{})
+	core.Register("log", &LogConfig{})
 }

config/subconfigs/mcp_config.go

 import (
 	"fmt"
 	"log"
+
+	"git.x2erp.com/qdy/go-base/config/core"
 )
 
 // ServiceConfig 数据库配置
 type McpServiceConfig struct {
-	BaseConfig
-	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"`
+	core.BaseConfig
+	Port         int    `yaml:"port" desc:"服务监听端口"`
+	ServiceName  string `yaml:"service_name" desc:"服务名称"`
+	InstanceName string `yaml:"instance_name" desc:"服务实例名称"`
+	ReadTimeout  int    `yaml:"read_timeout" desc:"读取超时时间（秒）"`
+	WriteTimeout int    `yaml:"write_timeout" desc:"写入超时时间（秒）"`
+	IdleTimeout  int    `yaml:"idle_timeout" desc:"空闲连接超时时间（秒）"`
+}
+
+func (c *McpServiceConfig) Description() string {
+	return "MCP（Model Context Protocol）服务配置"
 }
 
 // SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 
 // 自动注册
 func init() {
-	Register("mcpservice", &McpServiceConfig{})
+	core.Register("mcpservice", &McpServiceConfig{})
 }

config/subconfigs/micro_config.go

 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+)
 
 // MicroConfig Go Micro微服务配置
 type MicroConfig struct {
-	BaseConfig
-	RegistryAddress string `yaml:"registry_address"`
-	RegistryType    string `yaml:"registry_type"`
-	RegistryTimeout int    `yaml:"registry_timeout"`
-	LBStrategy      string `yaml:"lb_strategy"`
-	LBCacheTTL      int    `yaml:"lb_cache_ttl"`
-	LBRetries       int    `yaml:"lb_retries"`
-	ClientTimeout   int    `yaml:"client_timeout"`
-	ClientPoolSize  int    `yaml:"client_pool_size"`
-	MaxRetries      int    `yaml:"max_retries"`
-	CircuitEnabled  bool   `yaml:"circuit_enabled"`
-	CircuitTimeout  int    `yaml:"circuit_timeout"`
-	ErrorThreshold  int    `yaml:"error_threshold"`
-	SleepWindow     int    `yaml:"sleep_window"`
-	HealthPath      string `yaml:"health_path"`
-	HealthInterval  int    `yaml:"health_interval"`
-	HealthTimeout   int    `yaml:"health_timeout"`
-	LogLevel        string `yaml:"log_level"`
-	EnableDebug     bool   `yaml:"enable_debug"`
-	MetricsEnabled  bool   `yaml:"metrics_enabled"`
-	MetricsAddress  string `yaml:"metrics_address"`
-	TracerEnabled   bool   `yaml:"tracer_enabled"`
-	TracerAddress   string `yaml:"tracer_address"`
+	core.BaseConfig
+	RegistryAddress string `yaml:"registry_address" desc:"服务注册中心地址"`
+	RegistryType    string `yaml:"registry_type" desc:"注册中心类型：consul, etcd, mdns"`
+	RegistryTimeout int    `yaml:"registry_timeout" desc:"注册中心超时时间（秒）"`
+	LBStrategy      string `yaml:"lb_strategy" desc:"负载均衡策略：roundrobin, random, leastconn"`
+	LBCacheTTL      int    `yaml:"lb_cache_ttl" desc:"负载均衡缓存TTL（秒）"`
+	LBRetries       int    `yaml:"lb_retries" desc:"负载均衡重试次数"`
+	ClientTimeout   int    `yaml:"client_timeout" desc:"客户端调用超时时间（秒）"`
+	ClientPoolSize  int    `yaml:"client_pool_size" desc:"客户端连接池大小"`
+	MaxRetries      int    `yaml:"max_retries" desc:"最大重试次数"`
+	CircuitEnabled  bool   `yaml:"circuit_enabled" desc:"是否启用熔断器"`
+	CircuitTimeout  int    `yaml:"circuit_timeout" desc:"熔断器超时时间（秒）"`
+	ErrorThreshold  int    `yaml:"error_threshold" desc:"错误阈值（触发熔断的错误次数）"`
+	SleepWindow     int    `yaml:"sleep_window" desc:"熔断恢复时间窗口（秒）"`
+	HealthPath      string `yaml:"health_path" desc:"健康检查路径"`
+	HealthInterval  int    `yaml:"health_interval" desc:"健康检查间隔（秒）"`
+	HealthTimeout   int    `yaml:"health_timeout" desc:"健康检查超时时间（秒）"`
+	LogLevel        string `yaml:"log_level" desc:"日志级别：debug, info, warn, error"`
+	EnableDebug     bool   `yaml:"enable_debug" desc:"是否启用调试模式"`
+	MetricsEnabled  bool   `yaml:"metrics_enabled" desc:"是否启用指标收集"`
+	MetricsAddress  string `yaml:"metrics_address" desc:"指标服务地址"`
+	TracerEnabled   bool   `yaml:"tracer_enabled" desc:"是否启用链路追踪"`
+	TracerAddress   string `yaml:"tracer_address" desc:"链路追踪服务地址"`
 }
 
+func (c *MicroConfig) Description() string {
+	return "Go Micro微服务框架配置，包含服务发现、负载均衡、熔断器等组件"
+}
 func NewMicroConfig() *MicroConfig {
 	return &MicroConfig{}
 }
 
 // 自动注册
 func init() {
-	Register("micro", &MicroConfig{})
+	core.Register("micro", &MicroConfig{})
 }

config/subconfigs/mongodb_config.go

 import (
 	"fmt"
 	"time"
+
+	"git.x2erp.com/qdy/go-base/config/core"
 )
 
 // MongoDBConfig MongoDB客户端配置
 type MongoDBConfig struct {
-	BaseConfig
-	URI         string `yaml:"uri"`         // MongoDB连接URI，如："mongodb://localhost:27017"
-	Database    string `yaml:"database"`    // 默认数据库名
-	Username    string `yaml:"username"`    // 用户名（可选）
-	Password    string `yaml:"password"`    // 密码（可选）
-	AuthSource  string `yaml:"authSource"`  // 认证数据库，默认："admin"
-	MaxPoolSize uint64 `yaml:"maxPoolSize"` // 最大连接池大小
-	MinPoolSize uint64 `yaml:"minPoolSize"` // 最小连接池大小
-	SSL         bool   `yaml:"ssl"`         // 是否使用SSL连接
-	Timeout     int    `yaml:"timeout"`     // 连接超时时间，单位：秒
+	core.BaseConfig
+	URI         string `yaml:"uri" desc:"MongoDB连接URI，如：mongodb://localhost:27017"`
+	Database    string `yaml:"database" desc:"默认数据库名称"`
+	Username    string `yaml:"username" desc:"用户名（可选）"`
+	Password    string `yaml:"password" desc:"密码（可选）"`
+	AuthSource  string `yaml:"authSource" desc:"认证数据库，默认：admin"`
+	MaxPoolSize uint64 `yaml:"maxPoolSize" desc:"最大连接池大小"`
+	MinPoolSize uint64 `yaml:"minPoolSize" desc:"最小连接池大小"`
+	SSL         bool   `yaml:"ssl" desc:"是否使用SSL连接"`
+	Timeout     int    `yaml:"timeout" desc:"连接超时时间（秒）"`
+}
+
+func (c *MongoDBConfig) Description() string {
+	return "MongoDB数据库连接配置"
 }
 
 // NewMongoDBConfig 创建MongoDB配置实例
 
 // 自动注册
 func init() {
-	Register("mongodb", &MongoDBConfig{})
+	core.Register("mongodb", &MongoDBConfig{})
 }

config/subconfigs/rabbitmq_config.go

 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+)
 
 // RabbitMQConfig RabbitMQ配置
 type RabbitMQConfig struct {
-	BaseConfig
-	Host                 string `yaml:"host"`
-	Port                 int    `yaml:"port"`
-	Username             string `yaml:"username"`
-	Password             string `yaml:"password"`
-	Vhost                string `yaml:"vhost"`
-	UseTLS               bool   `yaml:"use_tls"`
-	CACert               string `yaml:"ca_cert"`
-	CertFile             string `yaml:"cert_file"`
-	KeyFile              string `yaml:"key_file"`
-	MaxOpenChannels      int    `yaml:"max_open_channels"`
-	ReconnectDelay       int    `yaml:"reconnect_delay"`
-	MaxReconnectAttempts int    `yaml:"max_reconnect_attempts"`
-	Heartbeat            int    `yaml:"heartbeat"`
-	ChannelSize          int    `yaml:"channel_size"`
-	DefaultExchange      string `yaml:"default_exchange"`
-	DefaultQueue         string `yaml:"default_queue"`
-	AutoAck              bool   `yaml:"auto_ack"`
-	Mandatory            bool   `yaml:"mandatory"`
-	Immediate            bool   `yaml:"immediate"`
-	PrefetchCount        int    `yaml:"prefetch_count"`
-	PrefetchSize         int    `yaml:"prefetch_size"`
-	Global               bool   `yaml:"global"`
-	PublisherConfirms    bool   `yaml:"publisher_confirms"`
-	ConfirmTimeout       int    `yaml:"confirm_timeout"`
+	core.BaseConfig
+	Host                 string `yaml:"host" desc:"RabbitMQ服务器主机地址"`
+	Port                 int    `yaml:"port" desc:"RabbitMQ服务器端口"`
+	Username             string `yaml:"username" desc:"RabbitMQ用户名"`
+	Password             string `yaml:"password" desc:"RabbitMQ密码"`
+	Vhost                string `yaml:"vhost" desc:"RabbitMQ虚拟主机"`
+	UseTLS               bool   `yaml:"use_tls" desc:"是否使用TLS加密连接"`
+	CACert               string `yaml:"ca_cert" desc:"CA证书文件路径"`
+	CertFile             string `yaml:"cert_file" desc:"客户端证书文件路径"`
+	KeyFile              string `yaml:"key_file" desc:"客户端私钥文件路径"`
+	MaxOpenChannels      int    `yaml:"max_open_channels" desc:"最大打开的通道数"`
+	ReconnectDelay       int    `yaml:"reconnect_delay" desc:"重连延迟时间（毫秒）"`
+	MaxReconnectAttempts int    `yaml:"max_reconnect_attempts" desc:"最大重连尝试次数"`
+	Heartbeat            int    `yaml:"heartbeat" desc:"心跳间隔时间（秒）"`
+	ChannelSize          int    `yaml:"channel_size" desc:"通道缓冲区大小"`
+	DefaultExchange      string `yaml:"default_exchange" desc:"默认交换机名称"`
+	DefaultQueue         string `yaml:"default_queue" desc:"默认队列名称"`
+	AutoAck              bool   `yaml:"auto_ack" desc:"是否自动确认消息"`
+	Mandatory            bool   `yaml:"mandatory" desc:"是否强制路由"`
+	Immediate            bool   `yaml:"immediate" desc:"是否立即交付"`
+	PrefetchCount        int    `yaml:"prefetch_count" desc:"预取消息数量"`
+	PrefetchSize         int    `yaml:"prefetch_size" desc:"预取消息大小"`
+	Global               bool   `yaml:"global" desc:"是否为全局预取设置"`
+	PublisherConfirms    bool   `yaml:"publisher_confirms" desc:"是否启用发布者确认"`
+	ConfirmTimeout       int    `yaml:"confirm_timeout" desc:"确认超时时间（秒）"`
+}
+
+func (c *RabbitMQConfig) Description() string {
+	return "RabbitMQ消息队列配置"
 }
 
 func NewRabbitMQConfig() *RabbitMQConfig {
 
 // 自动注册
 func init() {
-	Register("rabbitmq", &RabbitMQConfig{})
+	core.Register("rabbitmq", &RabbitMQConfig{})
 }

config/subconfigs/redis_config.go

 package subconfigs
 
-import "fmt"
+import (
+	"fmt"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+)
 
 // RedisConfig Redis配置
 type RedisConfig struct {
-	BaseConfig
-	Host         string `yaml:"host"`
-	Port         int    `yaml:"port"`
-	Password     string `yaml:"password"`
-	DB           int    `yaml:"db"`
-	PoolSize     int    `yaml:"pool_size"`
-	DialTimeout  int    `yaml:"dial_timeout"`
-	ReadTimeout  int    `yaml:"read_timeout"`
-	WriteTimeout int    `yaml:"write_timeout"`
-	IdleTimeout  int    `yaml:"idle_timeout"`
-	MaxConnAge   int    `yaml:"max_conn_age"`
+	core.BaseConfig
+	Host         string `yaml:"host" desc:"Redis服务器主机地址"`
+	Port         int    `yaml:"port" desc:"Redis服务器端口"`
+	Password     string `yaml:"password" desc:"Redis密码"`
+	DB           int    `yaml:"db" desc:"Redis数据库索引（0-15）"`
+	PoolSize     int    `yaml:"pool_size" desc:"连接池大小"`
+	DialTimeout  int    `yaml:"dial_timeout" desc:"连接超时时间（秒）"`
+	ReadTimeout  int    `yaml:"read_timeout" desc:"读取超时时间（秒）"`
+	WriteTimeout int    `yaml:"write_timeout" desc:"写入超时时间（秒）"`
+	IdleTimeout  int    `yaml:"idle_timeout" desc:"空闲连接超时时间（秒）"`
+	MaxConnAge   int    `yaml:"max_conn_age" desc:"连接最大生命周期（秒）"`
+}
+
+func (c *RedisConfig) Description() string {
+	return "Redis缓存数据库配置"
 }
 
 func NewRedisConfig() *RedisConfig {
 
 // 自动注册
 func init() {
-	Register("redis", &RedisConfig{})
+	core.Register("redis", &RedisConfig{})
 }

config/subconfigs/service_config.go

 import (
 	"fmt"
 	"log"
+
+	"git.x2erp.com/qdy/go-base/config/core"
 )
 
-// ServiceConfig 数据库配置
+// ServiceConfig 服务配置
 type ServiceConfig struct {
-	BaseConfig
-	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
-
-	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"`
+	core.BaseConfig
+	AppName      string `yaml:"app_name" desc:"当前应用名称"`
+	AppVersion   string `yaml:"app_version" desc:"当前应用版本"`
+	AppEnv       string `yaml:"app_env" desc:"环境参数：dev, test, prod"`
+	AppAuthToken string `yaml:"app_auth_token" desc:"静态认证使用的token"`
+
+	Port         int    `yaml:"port" desc:"服务监听端口"`
+	ServiceName  string `yaml:"service_name" desc:"服务名称"`
+	InstanceName string `yaml:"instance_name" desc:"服务实例名称"`
+	ReadTimeout  int    `yaml:"read_timeout" desc:"读取超时时间（秒）"`
+	WriteTimeout int    `yaml:"write_timeout" desc:"写入超时时间（秒）"`
+	IdleTimeout  int    `yaml:"idle_timeout" desc:"空闲连接超时时间（秒）"`
+}
+
+func (c *ServiceConfig) Description() string {
+	return "基础服务配置，包含应用信息、端口和超时设置"
 }
 
 // SetDefaults 设置默认值 - 实现 ConfigLoader 接口
 
 // 自动注册
 func init() {
-	Register("service", &ServiceConfig{})
+	core.Register("service", &ServiceConfig{})
 }

config/test_metadata_test.go

+package config
+
+import (
+	"fmt"
+	"testing"
+
+	"git.x2erp.com/qdy/go-base/config/core"
+	_ "git.x2erp.com/qdy/go-base/config/subconfigs"
+)
+
+func TestGetAllConfigsMeta(t *testing.T) {
+	fmt.Println("=== 调试开始 ===")
+
+	allMeta := core.GetAllConfigsMeta()
+	fmt.Printf("配置数量（直接）: %d\n", len(allMeta))
+
+	for configName, configMeta := range allMeta {
+		fmt.Printf("配置: %s.  %s\n", configName, configMeta.Desc)
+
+		for fieldName, fieldMeta := range configMeta.Fields {
+			fmt.Printf("  字段: %s, 类型: %s, YAML标签: %s, 描述: %s\n",
+				fieldName, fieldMeta.Type, fieldMeta.YamlTag, fieldMeta.Desc)
+		}
+	}
+}