springbootAI 1.8.4__tar.gz → 1.8.6__tar.gz

{springbootai-1.8.4/springbootAI.egg-info → springbootai-1.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: springbootAI
-Version: 1.8.4
+Version: 1.8.6
 Summary: Python版Spring Boot框架，集成PyMyBatis ORM
 Author-email: YuConggen <1516933915@qq.com>
 License-Expression: MIT

{springbootai-1.8.4 → springbootai-1.8.6}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 [project]
 # 发行名 springbootAI（PyPI 包名，pip install springbootAI）；导入包名仍为 spring
 name = "springbootAI"
-version = "1.8.4"
+version = "1.8.6"
 description = "Python版Spring Boot框架，集成PyMyBatis ORM"
 readme = "README.md"
 license = "MIT"

{springbootai-1.8.4 → springbootai-1.8.6}/spring/__init__.py

@@ -5,7 +5,7 @@ from .config import *
 from .utils import *
 from .main import create_app, run, SpringApplication, run_cli
 
-__version__ = "1.8.4"
+__version__ = "1.8.6"
 __author__ = "yuconggen"
 __license__ = "MIT"
 

{springbootai-1.8.4 → springbootai-1.8.6}/spring/cloud/discovery.py

@@ -32,20 +32,9 @@ class NacosDiscoveryClient:
     
     def __init__(self, server_addr: str = "localhost:8848", namespace: str = "", group: str = "DEFAULT_GROUP", username: str = "", password: str = ""):
         if hasattr(self, '_initialized'):
-            if (
-                self.server_addr != server_addr
-                or self.namespace != namespace
-                or self.group != group
-                or self.username != username
-                or self.password != password
-            ):
-                self.server_addr = server_addr
-                self.namespace = namespace
-                self.group = group
-                self.username = username
-                self.password = password
-                self._client = None
-                self._ready = False
+            # 已初始化：委托给 configure() 做原地更新，保持单一更新路径
+            self.configure(server_addr=server_addr, namespace=namespace,
+                           group=group, username=username, password=password)
             return
         self.server_addr = server_addr
         self.namespace = namespace
@@ -58,6 +47,44 @@ class NacosDiscoveryClient:
         self._ip: str = "127.0.0.1"
         self._port: int = 8080
         self._initialized = True
+
+    def configure(self, server_addr: Optional[str] = None, namespace: Optional[str] = None,
+                  group: Optional[str] = None, username: Optional[str] = None,
+                  password: Optional[str] = None) -> None:
+        """重新配置单例的 Nacos 连接参数（读取配置后调用）。
+
+        ``NacosDiscoveryClient`` 为单例，``__init__`` 的 ``_initialized`` 守卫会
+        阻止后续 ``__init__`` 更新参数。``init_discovery`` 读取 ``application.yml``
+        的 ``discovery.*`` 后，必须通过本方法重新配置，否则连接参数停留在默认值。
+
+        参数变化时重置已建立的客户端连接，强制下次 ``connect()`` 重建。
+
+        Args:
+            server_addr: Nacos 服务地址，None 表示保留原值
+            namespace: 命名空间，None 表示保留原值
+            group: 分组，None 表示保留原值
+            username: 用户名，None 表示保留原值
+            password: 密码，None 表示保留原值
+        """
+        changed = False
+        if server_addr is not None and self.server_addr != server_addr:
+            self.server_addr = server_addr
+            changed = True
+        if namespace is not None and self.namespace != namespace:
+            self.namespace = namespace
+            changed = True
+        if group is not None and self.group != group:
+            self.group = group
+            changed = True
+        if username is not None and self.username != username:
+            self.username = username
+            changed = True
+        if password is not None and self.password != password:
+            self.password = password
+            changed = True
+        if changed:
+            self._client = None
+            self._ready = False
     
     def connect(self) -> None:
         """连接Nacos"""
@@ -347,13 +374,16 @@ nacos_client = NacosDiscoveryClient()
 def init_discovery(config: dict) -> None:
     """
     初始化服务注册发现
-    
+
+    通过 ``configure`` 重新配置单例 ``NacosDiscoveryClient``，使 ``discovery.*``
+    配置生效。直接 ``NacosDiscoveryClient(...)`` 因单例 ``_initialized`` 守卫不会
+    更新参数。
+
     Args:
         config: 配置字典，包含server_addr, namespace, group等
     """
-    # Reconfigure the singleton in place so modules that imported the client
-    # keep observing the active connection rather than a stale instance.
-    nacos_client.__init__(
+    # 单例原地更新配置，避免 _initialized 守卫导致配置被忽略
+    nacos_client.configure(
         server_addr=config.get('server_addr', 'localhost:8848'),
         namespace=config.get('namespace', ''),
         group=config.get('group', 'DEFAULT_GROUP'),

{springbootai-1.8.4 → springbootai-1.8.6}/spring/config/config_loader.py

@@ -17,15 +17,46 @@ class ConfigurationError(ValueError):
     """应用配置缺失、格式错误或不满足生产安全要求。"""
 
 
+# 匹配非字母数字字符（kebab/camel/snake 分隔符）用于松散匹配规范化
+_NON_ALNUM = re.compile(r'[^0-9a-zA-Z]+')
+
+
+def _normalize_name(name: str) -> str:
+    """规范化命名：去除分隔符并小写，用于 ``get()`` 的松散匹配。
+
+    ``log_dir`` / ``log-dir`` / ``LOG_DIR`` / ``log.dir`` → ``logdir``。
+    与 ``spring.config.binding._normalize`` 保持一致，避免循环导入在此独立定义。
+    """
+    if not isinstance(name, str):
+        return str(name).lower()
+    return _NON_ALNUM.sub('', name).lower()
+
+
+def _to_bool(value: Any, default: bool = False) -> bool:
+    """统一布尔转换：接受 ``true/1/yes/on``（大小写不敏感），其余为 False。
+
+    与 ``spring.config.binding._coerce`` 的布尔规则保持一致，避免
+    ``REDIS_ENABLED=1`` 在 ``@ConfigurationProperties`` 绑定为 True 而在
+    ``_override_with_env`` 中被识别为 False 的行为不一致。
+    """
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    return str(value).strip().lower() in ('true', '1', 'yes', 'on')
+
+
 class ConfigLoader:
     """配置加载器"""
 
     # ApplicationContext updates this after startup so later ``ConfigLoader()``
     # calls resolve the same application.yml instead of depending on CWD.
     _default_base_path: Optional[str] = None
-    
-    # 环境变量替换模式：${ENV_VAR} 或 ${ENV_VAR:default}
+
+    # 环境变量替换模式：${ENV_VAR} 或 ${ENV_VAR:default}（单层，用于 fullmatch 判定）
     _ENV_VAR_PATTERN = re.compile(r'\$\{([^}]+)\}')
+    # 最内层占位符：内容不含 ${，用于迭代解析嵌套占位符 ${A:${B:default}}
+    _INNER_ENV_VAR_PATTERN = re.compile(r'\$\{([^${}]*)\}')
     _VALUE_EXPRESSION_PATTERN = re.compile(r'^\$\{([^}:]+)(?::(.*))?\}$')
     _MISSING = object()
     
@@ -42,47 +73,80 @@ class ConfigLoader:
         self._config: Dict[str, Any] = {}
         self._load_config()
     
+    @staticmethod
+    def _is_single_placeholder(value: str) -> bool:
+        """判断字符串是否为单个完整的占位符（支持嵌套 ``${A:${B:default}}``）。
+
+        用于决定解析后是否做类型推断（``yaml.safe_load``）。
+        用括号深度计数识别单个平衡占位符，避免正则 ``[^}]+`` 无法处理嵌套 ``}``。
+        """
+        value = value.strip()
+        if not (value.startswith('${') and value.endswith('}')):
+            return False
+        depth = 0
+        for i, c in enumerate(value):
+            if c == '{':
+                depth += 1
+            elif c == '}':
+                depth -= 1
+                if depth == 0 and i != len(value) - 1:
+                    return False  # 在结束前就已闭合 → 非单个占位符
+        return depth == 0
+
     def _resolve_env_var(self, value: str) -> Any:
         """
         解析环境变量引用
-        
+
         支持格式：
         - ${ENV_VAR} - 直接读取环境变量
         - ${ENV_VAR:default} - 读取环境变量，不存在使用默认值
-        
+        - ${A:${B:default}} - 嵌套占位符（迭代解析最内层）
+
         Args:
             value: 包含环境变量引用的字符串
-        
+
         Returns:
-            解析后的字符串
+            解析后的值（单个占位符时做类型推断）
         """
         if not isinstance(value, str):
             return value
-        
-        exact_placeholder = self._ENV_VAR_PATTERN.fullmatch(value)
+
+        # 判断整个值是否为单个占位符（支持嵌套），用于类型推断
+        exact_placeholder = self._is_single_placeholder(value)
 
         def replace_env(match):
             env_spec = match.group(1)
-            
+
             # 检查是否有默认值
             if ':' in env_spec:
                 env_name, default_value = env_spec.split(':', 1)
             else:
                 env_name = env_spec
                 default_value = None
-            
+
             # 从环境变量获取值
             env_value = os.environ.get(env_name.strip())
-            
+
             # 如果环境变量不存在，使用默认值
             if env_value is None:
                 if default_value is None:
                     raise ConfigurationError(f"必需的环境变量 {env_name.strip()} 未设置")
                 return default_value
-            
+
             return env_value
-        
-        resolved = self._ENV_VAR_PATTERN.sub(replace_env, value)
+
+        # 迭代解析最内层占位符，支持嵌套 ${A:${B:default}}
+        # 每轮用 _INNER_ENV_VAR_PATTERN 替换所有不含 ${ 的最内层占位符，
+        # 直到没有变化或达到最大迭代次数（防止无限循环）
+        resolved = value
+        prev = None
+        iterations = 0
+        while prev != resolved and iterations < 10:
+            prev = resolved
+            resolved = self._INNER_ENV_VAR_PATTERN.sub(replace_env, resolved)
+            iterations += 1
+
+        # 整个值是单个占位符时，做类型推断（如 "8080" → 8080, "true" → True）
         if exact_placeholder:
             parsed = yaml.safe_load(resolved)
             if not isinstance(parsed, (dict, list)):
@@ -108,9 +172,37 @@ class ConfigLoader:
         else:
             return config
     
+    @staticmethod
+    def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+        """深度合并两个配置字典：``override`` 覆盖 ``base``，子字典递归合并。
+
+        对齐 Spring Boot 的 profile 合并语义：profile 特定配置覆盖主配置，
+        但主配置中未涉及的键保留。返回新字典，不修改入参。
+        """
+        if not isinstance(base, dict):
+            base = {}
+        if not isinstance(override, dict):
+            return deepcopy(base)
+        result = deepcopy(base)
+        for key, value in override.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = ConfigLoader._deep_merge(result[key], value)
+            else:
+                result[key] = deepcopy(value)
+        return result
+
+    def _resolve_profile_path(self, profile: str) -> Optional[str]:
+        """解析 ``application-{profile}.yml`` 路径，与主配置同目录。"""
+        if not profile or profile == 'default':
+            return None
+        config_dir = os.path.dirname(os.path.abspath(self.config_path))
+        profile_file = f"application-{profile}.yml"
+        candidate = os.path.join(config_dir, profile_file)
+        return candidate if os.path.exists(candidate) else None
+
     def _load_config(self):
         """加载配置"""
-        # 1. 尝试从YAML文件加载
+        # 1. 尝试从YAML文件加载主配置
         if os.path.exists(self.config_path):
             try:
                 with open(self.config_path, 'r', encoding='utf-8') as f:
@@ -121,14 +213,61 @@ class ConfigLoader:
             except Exception as e:
                 logger.error(f"Failed to load config from {self.config_path}: {e}")
                 raise ConfigurationError(f"无法加载配置文件 {self.config_path}") from e
-        
+
+        # 1.5 加载 profile 特定配置文件并深度合并（application-{profile}.yml 覆盖主配置）
+        #     profile 来自主配置的 spring.profiles.active 或 SPRING_PROFILES_ACTIVE 环境变量。
+        #     在占位符解析之前合并，使 profile 文件中的占位符也能被解析。
+        profile = (
+            os.getenv('SPRING_PROFILES_ACTIVE')
+            or self._config.get('spring', {}).get('profiles', {}).get('active', 'default')
+        )
+        if profile:
+            profile = str(profile).strip()
+        profile_path = self._resolve_profile_path(profile) if profile else None
+        if profile_path:
+            try:
+                with open(profile_path, 'r', encoding='utf-8') as f:
+                    profile_config = yaml.safe_load(f) or {}
+                if isinstance(profile_config, dict):
+                    self._config = self._deep_merge(self._config, profile_config)
+                    logger.info(f"Loaded profile config from {profile_path} (profile={profile})")
+            except Exception as e:
+                logger.warning(f"Failed to load profile config {profile_path}: {e}")
+
         # 2. 解析配置中的环境变量占位符
         self._config = self._resolve_config_recursive(self._config)
-        
+
         # 3. 从环境变量覆盖配置
         self._override_with_env()
+        # 4. 从命令行参数覆盖配置（优先级最高）
+        self._override_with_cli_args()
         self._validate_config()
     
+    @staticmethod
+    def _get_env_any(*names: str, default: Any = None) -> Any:
+        """返回第一个已设置的环境变量值；都未设置则返回 default。
+
+        用于兼容占位符风格与显式 override 风格两套环境变量命名。
+        例如 ``discovery.server_addr`` 同时支持 ``NACOS_SERVER``（占位符风格）
+        和 ``DISCOVERY_SERVER_ADDR``（显式覆盖风格）。
+        """
+        for name in names:
+            value = os.getenv(name)
+            if value is not None:
+                return value
+        return default
+
+    @staticmethod
+    def _get_env_int(name: str, default: int) -> int:
+        """读取整型环境变量，转换失败抛 ``ConfigurationError`` 提示友好错误。"""
+        raw = os.getenv(name)
+        if raw is None:
+            return default
+        try:
+            return int(raw)
+        except (ValueError, TypeError):
+            raise ConfigurationError(f"环境变量 {name} 必须是整数，实际值: {raw!r}")
+
     def _override_with_env(self):
         """使用环境变量覆盖配置"""
         self._config.setdefault('spring', {})
@@ -142,7 +281,7 @@ class ConfigLoader:
         fail_fast_env = os.getenv('STARTUP_FAIL_FAST')
         configured_fail_fast = self._config['startup'].get('fail_fast')
         if fail_fast_env is not None:
-            self._config['startup']['fail_fast'] = fail_fast_env.lower() == 'true'
+            self._config['startup']['fail_fast'] = _to_bool(fail_fast_env)
         elif configured_fail_fast is None:
             self._config['startup'].pop('fail_fast', None)
         else:
@@ -151,71 +290,96 @@ class ConfigLoader:
         # Redis配置
         self._config.setdefault('redis', {})
         self._config['redis']['host'] = os.getenv('REDIS_HOST', self._config['redis'].get('host', 'localhost'))
-        self._config['redis']['port'] = int(os.getenv('REDIS_PORT', str(self._config['redis'].get('port', 6379))))
-        self._config['redis']['db'] = int(os.getenv('REDIS_DB', str(self._config['redis'].get('db', 0))))
+        self._config['redis']['port'] = self._get_env_int('REDIS_PORT', self._config['redis'].get('port', 6379))
+        self._config['redis']['db'] = self._get_env_int('REDIS_DB', self._config['redis'].get('db', 0))
         self._config['redis']['password'] = os.getenv('REDIS_PASSWORD', self._config['redis'].get('password'))
-        self._config['redis']['enabled'] = os.getenv('REDIS_ENABLED', str(self._config['redis'].get('enabled', False))).lower() == 'true'
-        
+        self._config['redis']['enabled'] = _to_bool(
+            os.getenv('REDIS_ENABLED', self._config['redis'].get('enabled', False)), False)
+
         # JWT配置
         self._config.setdefault('jwt', {})
         self._config['jwt']['secret_key'] = os.getenv('JWT_SECRET_KEY', self._config['jwt'].get('secret_key', 'spring-python-secret-key-change-in-production'))
         self._config['jwt']['algorithm'] = os.getenv('JWT_ALGORITHM', self._config['jwt'].get('algorithm', 'HS256'))
-        
+
         # 数据库配置
         self._config.setdefault('database', {})
         self._config['database']['url'] = os.getenv('DB_URL', self._config['database'].get('url', 'sqlite:///./test.db'))
-        self._config['database']['echo'] = os.getenv('DB_ECHO', str(self._config['database'].get('echo', False))).lower() == 'true'
-        self._config['database']['enabled'] = os.getenv('DB_ENABLED', str(self._config['database'].get('enabled', False))).lower() == 'true'
+        self._config['database']['echo'] = _to_bool(
+            os.getenv('DB_ECHO', self._config['database'].get('echo', False)), False)
+        # database.enabled 默认 True（对齐 application.yml 占位符 ${DB_ENABLED:true}）
+        self._config['database']['enabled'] = _to_bool(
+            os.getenv('DB_ENABLED', self._config['database'].get('enabled', True)), True)
         # PyMyBatis原生数据源配置（host/port/driver等）
         self._config['database']['driver'] = os.getenv('DB_DRIVER', self._config['database'].get('driver', 'sqlite'))
         self._config['database']['host'] = os.getenv('DB_HOST', self._config['database'].get('host', 'localhost'))
-        self._config['database']['port'] = int(os.getenv('DB_PORT', str(self._config['database'].get('port', 3306))))
+        self._config['database']['port'] = self._get_env_int('DB_PORT', self._config['database'].get('port', 3306))
         self._config['database']['database'] = os.getenv('DB_NAME', self._config['database'].get('database', 'test'))
         self._config['database']['username'] = os.getenv('DB_USERNAME', self._config['database'].get('username', ''))
         self._config['database']['password'] = os.getenv('DB_PASSWORD', self._config['database'].get('password', ''))
-        
+
         # 服务发现配置
+        # 兼容占位符风格（NACOS_*）与显式覆盖风格（DISCOVERY_*）两套环境变量命名
         self._config.setdefault('discovery', {})
-        self._config['discovery']['server_addr'] = os.getenv('DISCOVERY_SERVER_ADDR', self._config['discovery'].get('server_addr', 'localhost:8848'))
-        self._config['discovery']['namespace'] = os.getenv('DISCOVERY_NAMESPACE', self._config['discovery'].get('namespace', ''))
-        self._config['discovery']['group'] = os.getenv('DISCOVERY_GROUP', self._config['discovery'].get('group', 'DEFAULT_GROUP'))
+        self._config['discovery']['server_addr'] = self._get_env_any(
+            'NACOS_SERVER', 'DISCOVERY_SERVER_ADDR',
+            default=self._config['discovery'].get('server_addr', 'localhost:8848'))
+        self._config['discovery']['namespace'] = self._get_env_any(
+            'NACOS_NAMESPACE', 'DISCOVERY_NAMESPACE',
+            default=self._config['discovery'].get('namespace', ''))
+        self._config['discovery']['group'] = self._get_env_any(
+            'NACOS_GROUP', 'DISCOVERY_GROUP',
+            default=self._config['discovery'].get('group', 'DEFAULT_GROUP'))
         self._config['discovery']['username'] = os.getenv('NACOS_USERNAME', self._config['discovery'].get('username', ''))
         self._config['discovery']['password'] = os.getenv('NACOS_PASSWORD', self._config['discovery'].get('password', ''))
-        self._config['discovery']['enabled'] = os.getenv('DISCOVERY_ENABLED', str(self._config['discovery'].get('enabled', False))).lower() == 'true'
-        
+        self._config['discovery']['enabled'] = _to_bool(
+            os.getenv('DISCOVERY_ENABLED', self._config['discovery'].get('enabled', False)), False)
+
         # Seata配置
+        # 兼容占位符风格（SEATA_SERVER/SEATA_APP_ID/SEATA_TX_GROUP）与显式覆盖风格
         self._config.setdefault('seata', {})
-        self._config['seata']['server_addr'] = os.getenv('SEATA_SERVER_ADDR', self._config['seata'].get('server_addr', 'localhost:8091'))
-        self._config['seata']['application_id'] = os.getenv('SEATA_APPLICATION_ID', self._config['seata'].get('application_id', ''))
-        self._config['seata']['transaction_group'] = os.getenv('SEATA_TRANSACTION_GROUP', self._config['seata'].get('transaction_group', 'my_tx_group'))
-        self._config['seata']['enabled'] = os.getenv('SEATA_ENABLED', str(self._config['seata'].get('enabled', False))).lower() == 'true'
-        
+        self._config['seata']['server_addr'] = self._get_env_any(
+            'SEATA_SERVER', 'SEATA_SERVER_ADDR',
+            default=self._config['seata'].get('server_addr', 'localhost:8091'))
+        self._config['seata']['application_id'] = self._get_env_any(
+            'SEATA_APP_ID', 'SEATA_APPLICATION_ID',
+            default=self._config['seata'].get('application_id', ''))
+        self._config['seata']['transaction_group'] = self._get_env_any(
+            'SEATA_TX_GROUP', 'SEATA_TRANSACTION_GROUP',
+            default=self._config['seata'].get('transaction_group', 'my_tx_group'))
+        self._config['seata']['enabled'] = _to_bool(
+            os.getenv('SEATA_ENABLED', self._config['seata'].get('enabled', False)), False)
+
         # RabbitMQ配置
+        # 兼容占位符风格（RABBITMQ_VHOST）与显式覆盖风格（RABBITMQ_VIRTUAL_HOST）
         self._config.setdefault('rabbitmq', {})
         self._config['rabbitmq']['host'] = os.getenv('RABBITMQ_HOST', self._config['rabbitmq'].get('host', 'localhost'))
-        self._config['rabbitmq']['port'] = int(os.getenv('RABBITMQ_PORT', str(self._config['rabbitmq'].get('port', 5672))))
+        self._config['rabbitmq']['port'] = self._get_env_int('RABBITMQ_PORT', self._config['rabbitmq'].get('port', 5672))
         self._config['rabbitmq']['username'] = os.getenv('RABBITMQ_USERNAME', self._config['rabbitmq'].get('username', 'guest'))
         self._config['rabbitmq']['password'] = os.getenv('RABBITMQ_PASSWORD', self._config['rabbitmq'].get('password', 'guest'))
-        self._config['rabbitmq']['virtual_host'] = os.getenv('RABBITMQ_VIRTUAL_HOST', self._config['rabbitmq'].get('virtual_host', '/'))
-        self._config['rabbitmq']['enabled'] = os.getenv('RABBITMQ_ENABLED', str(self._config['rabbitmq'].get('enabled', False))).lower() == 'true'
-        
+        self._config['rabbitmq']['virtual_host'] = self._get_env_any(
+            'RABBITMQ_VHOST', 'RABBITMQ_VIRTUAL_HOST',
+            default=self._config['rabbitmq'].get('virtual_host', '/'))
+        self._config['rabbitmq']['enabled'] = _to_bool(
+            os.getenv('RABBITMQ_ENABLED', self._config['rabbitmq'].get('enabled', False)), False)
+
         # Prometheus配置
         self._config.setdefault('prometheus', {})
         self._config['prometheus']['namespace'] = os.getenv('PROMETHEUS_NAMESPACE', self._config['prometheus'].get('namespace', 'spring'))
         self._config['prometheus']['subsystem'] = os.getenv('PROMETHEUS_SUBSYSTEM', self._config['prometheus'].get('subsystem', 'python'))
-        self._config['prometheus']['port'] = int(os.getenv('PROMETHEUS_PORT', str(self._config['prometheus'].get('port', 8000))))
-        self._config['prometheus']['enabled'] = os.getenv('PROMETHEUS_ENABLED', str(self._config['prometheus'].get('enabled', False))).lower() == 'true'
-        
+        self._config['prometheus']['port'] = self._get_env_int('PROMETHEUS_PORT', self._config['prometheus'].get('port', 8000))
+        self._config['prometheus']['enabled'] = _to_bool(
+            os.getenv('PROMETHEUS_ENABLED', self._config['prometheus'].get('enabled', False)), False)
+
         # 日志配置
         self._config.setdefault('logging', {})
         self._config['logging']['level'] = os.getenv('LOG_LEVEL', self._config['logging'].get('level', 'INFO'))
         self._config['logging']['log_dir'] = os.getenv('LOG_DIR', self._config['logging'].get('log_dir', 'logs'))
         self._config['logging']['retention'] = os.getenv('LOG_RETENTION', self._config['logging'].get('retention', '30 days'))
         self._config['logging']['rotation'] = os.getenv('LOG_ROTATION', self._config['logging'].get('rotation', '100 MB'))
-        
+
         # 服务器配置
         self._config.setdefault('server', {})
-        self._config['server']['port'] = int(os.getenv('SERVER_PORT', str(self._config['server'].get('port', 8080))))
+        self._config['server']['port'] = self._get_env_int('SERVER_PORT', self._config['server'].get('port', 8080))
         self._config['server']['host'] = os.getenv('SERVER_HOST', self._config['server'].get('host', '0.0.0.0'))
 
         self._config['server'].setdefault('cors', {})
@@ -227,9 +391,52 @@ class ConfigLoader:
             ]
         else:
             cors_config.setdefault('allow_origins', [])
-        cors_config['allow_credentials'] = os.getenv(
-            'CORS_ALLOW_CREDENTIALS', str(cors_config.get('allow_credentials', False))
-        ).lower() == 'true'
+        cors_config['allow_credentials'] = _to_bool(
+            os.getenv('CORS_ALLOW_CREDENTIALS', cors_config.get('allow_credentials', False)), False)
+
+    def _override_with_cli_args(self) -> None:
+        """从命令行参数覆盖配置（优先级最高，对齐 Spring Boot ``--key=value``）。
+
+        支持两种形式：
+        - ``--server.port=9000``
+        - ``--server.port 9000``
+
+        点分隔键递归写入 ``self._config``，值经 ``yaml.safe_load`` 做类型推断
+        （``9000`` → int，``true`` → bool）。在 ``_override_with_env`` 之后调用。
+        """
+        args = sys.argv[1:]
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if not arg.startswith('--'):
+                i += 1
+                continue
+            body = arg[2:]
+            if '=' in body:
+                key, value = body.split('=', 1)
+                self._set_cli_override(key, value)
+                i += 1
+            else:
+                # --key value 形式：仅当下一个 token 非参数时才取值
+                if i + 1 < len(args) and not args[i + 1].startswith('--'):
+                    self._set_cli_override(body, args[i + 1])
+                    i += 2
+                else:
+                    i += 1
+
+    def _set_cli_override(self, dotted_key: str, raw_value: str) -> None:
+        """将点分隔键写入 ``self._config``，值做 yaml 类型推断。"""
+        keys = dotted_key.split('.')
+        node = self._config
+        for k in keys[:-1]:
+            child = node.get(k)
+            if not isinstance(child, dict):
+                child = {}
+                node[k] = child
+            node = child
+        parsed = yaml.safe_load(raw_value)
+        node[keys[-1]] = parsed
+        logger.debug(f"CLI override: {dotted_key}={parsed!r}")
 
     def _validate_config(self) -> None:
         algorithm = str(self._config.get('jwt', {}).get('algorithm', 'HS256')).upper()
@@ -336,26 +543,46 @@ class ConfigLoader:
         """
         return self._config.get('spring', {}).get('profiles', {}).get('active', 'default')
     
+    @staticmethod
+    def _lookup_key(mapping: Any, key: str):
+        """在字典中查找 ``key``：先精确匹配，再松散匹配（大小写/分隔符不敏感）。
+
+        与 ``@ConfigurationProperties`` 松散绑定语义一致，使 ``get('logging.log-dir')``
+        也能命中 YAML 中的 ``log_dir``。返回 ``(value, found)``。
+        """
+        if not isinstance(mapping, dict):
+            return None, False
+        if key in mapping:
+            return mapping[key], True
+        # 松散匹配：规范化（去分隔符+小写）后比较
+        norm = _normalize_name(key)
+        for k, v in mapping.items():
+            if _normalize_name(k) == norm:
+                return v, True
+        return None, False
+
     def get(self, key: str, default: Any = None) -> Any:
         """
         获取配置值
-        
+
+        支持点分隔路径与松散绑定（kebab-case / snake_case / 大小写不敏感）。
+        先精确匹配，未命中再松散匹配，避免 ``log-dir`` 找不到 ``log_dir`` 的问题。
+
         Args:
-            key: 配置键，支持点分隔（如 redis.host）
+            key: 配置键，支持点分隔（如 redis.host / logging.log-dir / Logging.Level）
             default: 默认值
-        
+
         Returns:
             配置值
         """
         keys = key.split('.')
         value = self._config
-        
+
         for k in keys:
-            if isinstance(value, dict) and k in value:
-                value = value[k]
-            else:
+            value, found = self._lookup_key(value, k)
+            if not found:
                 return default
-        
+
         return value
     
     def load_config(self):

{springbootai-1.8.4 → springbootai-1.8.6}/spring/context/application_context.py

@@ -421,6 +421,14 @@ class ApplicationContext:
                 # 处理字段上的@Value注解
                 for name, field in inspect.getmembers(bean_class):
                     if not name.startswith('_'):
+                        # @Value/@NacosValue can be attached to a function as
+                        # metadata alongside route/AOP annotations.  Replacing
+                        # that function on the instance makes the handler
+                        # non-callable and breaks controller registration.
+                        # Constructor/default and class-field injection are
+                        # handled separately by BeanFactory.
+                        if callable(field):
+                            continue
                         annotations = getattr(field, '__spring_annotations__', [])
                         for annotation in annotations:
                             if isinstance(annotation, Value):