reproto 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

core/reconstructor.py

@@ -12,7 +12,7 @@ Author: AI Assistant
 import re
 from pathlib import Path
 from collections import deque
-from typing import Set, Dict, List, Optional
+from typing import Set, Dict, List, Optional, Tuple
 
 from parsing.java_parser import JavaParser
 from parsing.enum_parser import EnumParser
@@ -20,6 +20,8 @@ from core.info_decoder import InfoDecoder
 from generation.proto_generator import ProtoGenerator
 from models.message_definition import MessageDefinition, EnumDefinition, EnumValueDefinition
 from utils.logger import get_logger
+from utils.file_cache import get_file_cache
+from utils.type_utils import type_mapper, naming_converter
 
 
 class JavaSourceAnalyzer:
@@ -31,6 +33,8 @@ class JavaSourceAnalyzer:
         self._current_class_name = None
         # 初始化JavaParser用于字段类型解析
         self.java_parser = JavaParser()
+        # 使用文件缓存系统优化I/O性能
+        self.file_cache = get_file_cache()
     
     def set_current_class(self, class_name: str):
         """设置当前分析的类"""
@@ -183,41 +187,9 @@ class JavaSourceAnalyzer:
             java_type: Java类型名
             
         Returns:
-            protobuf类型名
+            对应的protobuf类型名
         """
-        if not java_type:
-            return 'string'
-        
-        # 基础类型映射
-        basic_types = {
-            'int': 'int32',
-            'long': 'int64', 
-            'float': 'float',
-            'double': 'double',
-            'boolean': 'bool',
-            'String': 'string',
-            'java.lang.String': 'string',
-            'java.lang.Integer': 'int32',
-            'java.lang.Long': 'int64',
-            'java.lang.Float': 'float',
-            'java.lang.Double': 'double',
-            'java.lang.Boolean': 'bool',
-            'byte[]': 'bytes',
-            'ByteString': 'bytes',
-            'com.google.protobuf.ByteString': 'bytes',
-        }
-        
-        # 检查是否为基础类型
-        if java_type in basic_types:
-            return basic_types[java_type]
-        
-        # 如果是完整的类名，提取简单类名
-        if '.' in java_type:
-            simple_name = java_type.split('.')[-1]
-            return simple_name
-        
-        # 默认返回原类型名
-        return java_type
+        return type_mapper.java_to_proto_type(java_type)
 
     def _get_type_from_setter(self, field_name: str) -> Optional[str]:
         """
@@ -295,19 +267,21 @@ class JavaSourceAnalyzer:
         return None
     
     def _load_class_content(self, class_name: str) -> Optional[str]:
-        """加载类的源码内容"""
+        """加载类的源码内容（使用缓存优化）"""
         try:
             # 标准路径：com.example.Model -> com/example/Model.java
             file_path = class_name.replace('.', '/') + '.java'
             full_path = self.sources_dir / file_path
             
-            if full_path.exists():
-                return full_path.read_text(encoding='utf-8')
+            # 使用缓存系统获取文件内容
+            content = self.file_cache.get_content(full_path)
+            if content:
+                return content
             
             # 备选方案：按简单类名搜索
             simple_name = class_name.split('.')[-1]
             for java_file in self.sources_dir.rglob(f"{simple_name}.java"):
-                return java_file.read_text(encoding='utf-8')
+                return self.file_cache.get_content(java_file)
             
             return None
         except Exception:
@@ -346,6 +320,10 @@ class ProtoReconstructor:
         self.java_source_analyzer = JavaSourceAnalyzer(sources_dir)
         self.info_decoder.java_source_analyzer = self.java_source_analyzer
         
+        # 🚀 性能优化：移除未使用的索引系统，简化代码
+        # 索引系统在实际使用中被基础类型检测绕过，且构建耗时
+        # 改为使用直接的文件路径构造和智能包名推断
+        
         # 任务调度状态
         self.processed_classes: Set[str] = set()  # 已处理的类
         self.pending_classes: deque = deque()     # 待处理的类队列
@@ -383,7 +361,14 @@ class ProtoReconstructor:
         # 4. 生成proto文件
         self._generate_all_proto_files()
         
-        # 5. 返回统计信息
+        # 5. 输出性能统计信息
+        from utils.file_cache import get_file_cache
+        file_cache = get_file_cache()
+        file_cache.print_stats()
+        
+        # 🚀 性能优化：索引系统已移除，无需统计
+        
+        # 6. 返回统计信息
         # 报告未知类型统计
         self._report_unknown_types()
         
@@ -616,7 +601,7 @@ class ProtoReconstructor:
     
     def _should_skip_class(self, class_name: str) -> bool:
         """
-        判断是否应该跳过某个类
+        判断是否应该跳过某个类的处理
         
         Args:
             class_name: 类名
@@ -624,27 +609,15 @@ class ProtoReconstructor:
         Returns:
             是否应该跳过
         """
-        # 跳过已经处理过的类
+        # 已处理过的类
         if class_name in self.processed_classes:
             return True
-            
-        # 跳过基础类型（包括Java基础类型和常见的系统类型）
-        basic_types = {
-            # Java基础类型
-            'int', 'long', 'float', 'double', 'boolean', 'byte', 'short', 'char',
-            'String', 'Object', 'Integer', 'Long', 'Float', 'Double', 'Boolean',
-            'Byte', 'Short', 'Character',
-            # Java系统类型
-            'java.lang.String', 'java.lang.Integer', 'java.lang.Long', 
-            'java.lang.Boolean', 'java.lang.Float', 'java.lang.Double',
-            'java.lang.Object', 'java.util.List', 'java.util.Map',
-            'com.google.protobuf.ByteString', 'com.google.protobuf.MessageLite'
-        }
         
-        if class_name in basic_types:
+        # 使用TypeMapper判断基础类型和系统包
+        if type_mapper.is_java_basic_type(class_name) or type_mapper.is_system_package(class_name):
             return True
             
-        # 跳过明显的系统类型和内部类型
+        # 跳过明显不是protobuf类的包
         if self._is_system_or_internal_type(class_name):
             return True
             
@@ -747,12 +720,7 @@ class ProtoReconstructor:
             return None
             
         # 检查是否为基础类型
-        basic_proto_types = {
-            'string', 'int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64',
-            'fixed32', 'fixed64', 'sfixed32', 'sfixed64', 'bool', 'float', 'double', 'bytes'
-        }
-        
-        if type_name in basic_proto_types:
+        if type_mapper.is_basic_proto_type(type_name):
             return None
             
         # 如果已经是完整类名，直接返回
@@ -777,7 +745,7 @@ class ProtoReconstructor:
     
     def _find_java_file(self, class_name: str) -> Optional[Path]:
         """
-        根据类名查找对应的Java文件
+        根据类名查找对应的Java文件（优化版本）
         
         Args:
             class_name: 完整的Java类名
@@ -785,6 +753,7 @@ class ProtoReconstructor:
         Returns:
             Java文件路径，如果找不到则返回None
         """
+        # 🚀 优化1：直接根据包名和类名构造文件路径（你的建议）
         # 标准路径：com.example.Model -> com/example/Model.java
         file_path = class_name.replace('.', '/') + '.java'
         full_path = self.sources_dir / file_path
@@ -792,31 +761,43 @@ class ProtoReconstructor:
         if full_path.exists():
             return full_path
         
-        # 处理内部类：支持多层嵌套
-        # com.example.Models$Inner$Deep -> com/example/Models$Inner$Deep.java
+        # 🚀 优化2：处理内部类，但避免全目录扫描
         if '$' in class_name:
-            # 找到最后一个.的位置，分离包名和类名部分
+            # 内部类处理：com.example.Models$Inner -> com/example/Models.java
             last_dot_index = class_name.rfind('.')
             if last_dot_index != -1:
-                package_path = class_name[:last_dot_index].replace('.', '/')  # 包路径
-                class_part = class_name[last_dot_index + 1:]  # 类名部分（可能包含多个$）
-                inner_class_file_path = f"{package_path}/{class_part}.java"
-                inner_class_full_path = self.sources_dir / inner_class_file_path
+                package_path = class_name[:last_dot_index].replace('.', '/')
+                class_part = class_name[last_dot_index + 1:]
                 
-                if inner_class_full_path.exists():
-                    return inner_class_full_path
-        
-        # 备选方案：按简单类名搜索
-        simple_name = class_name.split('.')[-1]
-        # 对于内部类，简单名称可能包含多个$符号
-        if '$' in simple_name:
-            # 对于内部类，直接使用包含$的完整文件名搜索
-            for java_file in self.sources_dir.rglob(f"{simple_name}.java"):
-                return java_file
-        else:
-            # 对于普通类，使用原来的逻辑
-            for java_file in self.sources_dir.rglob(f"{simple_name}.java"):
-                return java_file
+                # 提取外部类名（$之前的部分）
+                outer_class = class_part.split('$')[0]
+                outer_class_file_path = f"{package_path}/{outer_class}.java"
+                outer_class_full_path = self.sources_dir / outer_class_file_path
+                
+                if outer_class_full_path.exists():
+                    return outer_class_full_path
+        
+        # 🚀 优化3：简化文件查找逻辑，移除索引依赖
+        
+        # 🚀 优化4：最后的备选方案 - 限制搜索范围
+        # 只在当前包及其父包中搜索，避免全目录扫描
+        package_parts = class_name.split('.')[:-1]  # 获取包名部分
+        simple_name = class_name.split('.')[-1].split('$')[0]  # 提取简单类名
+        
+        # 构造搜索路径列表，限制搜索范围
+        search_paths = []
+        for i in range(len(package_parts), 0, -1):
+            package_path = '/'.join(package_parts[:i])
+            search_paths.append(self.sources_dir / package_path)
+        
+        # 在限定范围内搜索
+        for search_path in search_paths:
+            if search_path.exists():
+                for java_file in search_path.rglob(f"{simple_name}.java"):
+                    # 验证找到的文件是否匹配
+                    relative_path = java_file.relative_to(self.sources_dir)
+                    if relative_path.stem == simple_name:
+                        return java_file
         
         return None
     
@@ -840,7 +821,7 @@ class ProtoReconstructor:
                 return candidate
         
         return None
-    
+
     def _generate_candidate_packages(self, current_package: str) -> List[str]:
         """
         动态生成候选包名列表
@@ -913,7 +894,7 @@ class ProtoReconstructor:
 
     def _find_best_matching_class(self, type_name: str, current_package: str, current_class: str = None) -> Optional[str]:
         """
-        查找最佳匹配的类（用于处理推断失败的情况）
+        查找最佳匹配的类（高性能版本）
         
         Args:
             type_name: 类型名（如 IdData）
@@ -923,19 +904,33 @@ class ProtoReconstructor:
         Returns:
             最佳匹配的完整类名
         """
-        # 首先尝试从当前类的Java源码中获取实际类型
-        if current_class:
-            actual_type = self._extract_actual_field_type(current_class, type_name)
-            if actual_type:
-                self.logger.info(f"    🔍 源码分析: {type_name} -> {actual_type}")
-                return actual_type
-        
-        # 预检查：如果是基础字段名，可能不需要创建单独的类
+        # 🚀 性能优化：优先进行基础类型检测，避免不必要的文件IO
         if self._is_basic_field_type(type_name, current_class):
-            self.logger.info(f"    🔍 基础字段类型检测: {type_name} -> 跳过类匹配")
+            self.logger.debug(f"    🔍 基础字段类型检测: {type_name} -> 跳过类匹配")
             return None
         
-        # 如果源码分析失败，回退到模糊匹配
+        # 🚀 性能优化：直接使用智能包名推断，避免索引开销
+        # 1. 首先尝试推断完整类名
+        inferred_name = self._infer_full_class_name(type_name, current_package)
+        if inferred_name:
+            self.logger.info(f"    🔍 包名推断: {type_name} -> {inferred_name}")
+            return inferred_name
+        
+        # 2. 如果推断失败，使用限制范围的目录搜索
+        self.logger.debug(f"    🔍 启用目录搜索: {type_name}")
+        return self._fallback_directory_search(type_name, current_package)
+    
+    def _fallback_directory_search(self, type_name: str, current_package: str) -> Optional[str]:
+        """
+        回退的目录扫描方法（当索引匹配失败时使用）
+        
+        Args:
+            type_name: 类型名
+            current_package: 当前包名
+            
+        Returns:
+            匹配的类名或None
+        """
         matching_classes = []
         
         # 在源码目录中搜索
@@ -961,12 +956,12 @@ class ProtoReconstructor:
         matching_classes.sort(key=lambda x: x[1], reverse=True)
         best_match = matching_classes[0][0]
         
-        self.logger.info(f"    🔍 智能匹配: {type_name} -> {best_match}")
+        self.logger.info(f"    🔍 目录扫描匹配: {type_name} -> {best_match}")
         return best_match
 
     def _is_basic_field_type(self, type_name: str, current_class: str = None) -> bool:
         """
-        检查是否为基础字段类型，避免为简单字段创建不必要的类
+        快速检查是否为基础字段类型（高性能版本）
         
         Args:
             type_name: 类型名
@@ -975,61 +970,11 @@ class ProtoReconstructor:
         Returns:
             是否为基础字段类型
         """
-        # 首先检查是否为Java基础类型
-        basic_java_types = {
-            'int', 'long', 'float', 'double', 'boolean', 'byte', 'short', 'char',
-            'String', 'Object', 'Integer', 'Long', 'Float', 'Double', 'Boolean',
-            'Byte', 'Short', 'Character'
-        }
-        
-        if type_name in basic_java_types:
-            return True
-        
-        # 常见的基础字段名模式
-        basic_patterns = [
-            'tags',      # tags_ 字段通常是 repeated string
-            'ids',       # ids_ 字段通常是 repeated string 或 repeated int64
-            'values',    # values_ 字段通常是基础类型数组
-            'names',     # names_ 字段通常是 repeated string
-            'urls',      # urls_ 字段通常是 repeated string
-            'emails',    # emails_ 字段通常是 repeated string
-        ]
-        
-        type_lower = type_name.lower()
-        
-        # 检查是否匹配基础模式
-        if type_lower in basic_patterns:
-            return True
-        
-        # 如果有当前类，尝试从Java源码中验证
-        if current_class:
-            try:
-                java_file = self._find_java_file(current_class)
-                if java_file:
-                    content = java_file.read_text(encoding='utf-8')
-                    
-                    # 查找对应的字段声明，检查是否为基础类型
-                    field_name_pattern = type_lower.rstrip('s') + 's?_'  # tags -> tags?_
-                    import re
-                    
-                    # 查找字段声明：private List<String> tags_; 或 private Internal.ProtobufList<String> tags_;
-                    patterns = [
-                        rf'private\s+(?:Internal\.)?ProtobufList<String>\s+{field_name_pattern}',
-                        rf'private\s+List<String>\s+{field_name_pattern}',
-                        rf'private\s+(?:Internal\.)?ProtobufList<Integer>\s+{field_name_pattern}',
-                        rf'private\s+List<Integer>\s+{field_name_pattern}',
-                        rf'private\s+(?:Internal\.)?ProtobufList<Long>\s+{field_name_pattern}',
-                        rf'private\s+List<Long>\s+{field_name_pattern}',
-                    ]
-                    
-                    for pattern in patterns:
-                        if re.search(pattern, content, re.IGNORECASE):
-                            return True
-                            
-            except Exception as e:
-                self.logger.debug(f"    检查基础字段类型时出错: {e}")
+        # 🚀 性能优化：使用缓存的类型检查器，避免重复计算
+        from utils.type_utils import TypeMapper
         
-        return False
+        # 直接使用统一的基础类型检查，无需额外逻辑
+        return TypeMapper.is_java_basic_type(type_name)
 
     def _is_valid_package_for_matching(self, candidate_package: str, current_package: str) -> bool:
         """
@@ -1100,7 +1045,7 @@ class ProtoReconstructor:
 
     def _extract_actual_field_type(self, class_name: str, inferred_type: str) -> Optional[str]:
         """
-        从Java源码中提取字段的实际类型
+        从Java源码中提取字段的实际类型（优化版本）
         
         Args:
             class_name: 当前类的完整名称
@@ -1109,57 +1054,36 @@ class ProtoReconstructor:
         Returns:
             实际的完整类型名
         """
-        # 首先检查是否为基础类型，如果是则直接跳过
-        basic_types = {
-            'int', 'long', 'float', 'double', 'boolean', 'byte', 'short', 'char',
-            'String', 'Object', 'Integer', 'Long', 'Float', 'Double', 'Boolean',
-            'Byte', 'Short', 'Character'
-        }
+        # 🚀 优化：使用统一的类型检查器
+        from utils.type_utils import TypeMapper
         
-        if inferred_type in basic_types:
+        if TypeMapper.is_java_basic_type(inferred_type):
             self.logger.debug(f"    跳过基础类型: {inferred_type}")
             return None
         
+        # 🚀 性能优化：简化源码分析，避免复杂的正则表达式匹配
+        # 对于大多数情况，索引系统已经能够提供足够准确的匹配
+        # 这里只做最基本的检查，避免耗时的文件IO和正则匹配
+        
         try:
-            java_file = self._find_java_file(class_name)
-            if not java_file:
-                return None
-                
-            # 读取Java源码
-            content = java_file.read_text(encoding='utf-8')
+            # 使用索引系统进行快速查找，避免文件IO
+            from utils.type_index import get_type_index
+            type_index = get_type_index(self.sources_dir)
             
-            # 查找字段声明模式：private SomeType fieldName_;
-            # 我们要找的是以inferred_type结尾的类型声明
-            import re
+            # 构造可能的完整类名
+            package_name = '.'.join(class_name.split('.')[:-1])
+            possible_full_name = f"{package_name}.{inferred_type}"
             
-            # 匹配模式：private (.*IdData) .*_;
-            pattern = rf'private\s+(\w*{re.escape(inferred_type)})\s+\w+_;'
-            matches = re.findall(pattern, content)
-            
-            if matches:
-                # 取第一个匹配的类型
-                actual_type_simple = matches[0]
-                
-                # 再次检查匹配的类型是否为基础类型
-                if actual_type_simple in basic_types:
-                    self.logger.debug(f"    匹配到基础类型，跳过: {actual_type_simple}")
-                    return None
-                
-                # 检查是否有import语句
-                import_pattern = rf'import\s+([^;]*\.{re.escape(actual_type_simple)});'
-                import_matches = re.findall(import_pattern, content)
-                
-                if import_matches:
-                    return import_matches[0]  # 返回完整的包名.类名
-                else:
-                    # 如果没有import，假设在同一个包中
-                    package_name = '.'.join(class_name.split('.')[:-1])
-                    return f"{package_name}.{actual_type_simple}"
+            # 使用索引快速检查
+            result = type_index.find_best_match(inferred_type, package_name)
+            if result:
+                self.logger.debug(f"    索引快速匹配: {inferred_type} -> {result}")
+                return result
             
             return None
             
         except Exception as e:
-            self.logger.error(f"    ⚠️  源码分析失败: {e}")
+            self.logger.debug(f"    ⚠️  快速类型匹配失败: {e}")
             return None
     
     def _create_enum_definition(self, class_name: str, enum_values: List[tuple]) -> EnumDefinition:
@@ -1292,7 +1216,7 @@ class ProtoReconstructor:
     @staticmethod
     def _to_snake_case(camel_str: str) -> str:
         """
-        将CamelCase转换为snake_case
+        将CamelCase转换为snake_case（使用统一的命名转换器）
         
         Args:
             camel_str: 驼峰命名字符串
@@ -1300,8 +1224,6 @@ class ProtoReconstructor:
         Returns:
             蛇形命名字符串
         """
-        # 处理连续大写字母：XMLParser -> XML_Parser
-        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str)
-        # 处理小写字母后跟大写字母：userId -> user_Id
-        s2 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
-        return s2.lower() 
+        # 🚀 优化：使用统一的命名转换器，避免重复实现
+        from utils.type_utils import NamingConverter
+        return NamingConverter.to_snake_case(camel_str) 

generation/proto_generator.py

@@ -11,6 +11,7 @@ Author: AI Assistant
 import re
 from typing import Dict, Set, List, Union
 from models.message_definition import MessageDefinition, FieldDefinition, EnumDefinition, EnumValueDefinition
+from utils.type_utils import type_mapper, naming_converter, field_name_processor
 
 
 class ProtoGenerator:
@@ -158,12 +159,13 @@ class ProtoGenerator:
         """
         lines = [f'message {message_def.name} {{']
         
-        # 生成oneof字段
+        # 生成oneof字段（oneof字段内部也按tag排序）
         for oneof in message_def.oneofs:
             lines.extend(self._generate_oneof_definition(oneof))
         
-        # 生成常规字段
-        for field in message_def.fields:
+        # 生成常规字段（按tag排序）
+        sorted_fields = sorted(message_def.fields, key=lambda field: field.tag)
+        for field in sorted_fields:
             lines.append(self._generate_field_definition(field))
         
         lines.append('}')
@@ -181,19 +183,24 @@ class ProtoGenerator:
         """
         lines = [f'enum {enum_def.name} {{']
         
-        # 生成枚举值
-        for enum_value in enum_def.values:
+        # 生成枚举值（按value排序）
+        sorted_values = sorted(enum_def.values, key=lambda enum_value: enum_value.value)
+        for enum_value in sorted_values:
             lines.append(f'  {enum_value.name} = {enum_value.value};')
         
         lines.append('}')
         return lines
     
     def _generate_oneof_definition(self, oneof) -> List[str]:
-        """生成oneof字段定义"""
+        """生成oneof字段定义（字段按tag排序）"""
         lines = [f'  oneof {oneof.name} {{']
-        for field in oneof.fields:
+        
+        # 对oneof内部的字段按tag排序
+        sorted_fields = sorted(oneof.fields, key=lambda field: field.tag)
+        for field in sorted_fields:
             field_type = self._resolve_field_type(field)
             lines.append(f'    {field_type} {field.name} = {field.tag};')
+        
         lines.append('  }')
         return lines
     
@@ -404,16 +411,7 @@ class ProtoGenerator:
         Returns:
             基础proto类型，如果不是基础类型则返回None
         """
-        basic_type_mapping = {
-            'string': 'string',
-            'int32': 'int32',
-            'int64': 'int64',
-            'bool': 'bool',
-            'float': 'float',
-            'double': 'double',
-            'bytes': 'bytes',
-        }
-        return basic_type_mapping.get(type_name)
+        return type_mapper.java_to_proto_type(type_name) if type_mapper.is_java_basic_type(type_name) else None
     
     def _generate_enum_type_name(self, field_name: str) -> str:
         """
@@ -425,33 +423,7 @@ class ProtoGenerator:
         Returns:
             枚举类型名（PascalCase）
         """
-        name = field_name.rstrip('_')
-        
-        # 特殊字段名修正
-        field_name_corrections = {
-            'access': 'Access',  # 修正拼写
-        }
-        
-        if name in field_name_corrections:
-            return field_name_corrections[name]
-        
-        # 处理常见的枚举后缀
-        suffix_mappings = {
-            '_type': 'Type',
-            '_status': 'Status',
-            '_code': 'Code'
-        }
-        
-        for suffix, replacement in suffix_mappings.items():
-            if name.endswith(suffix):
-                name = name[:-len(suffix)] + replacement
-                break
-        
-        # 处理复数形式：badges -> badge
-        if name.endswith('s') and len(name) > 1:
-            name = name[:-1]
-        
-        return self._to_pascal_case(name)
+        return field_name_processor.generate_type_name_from_field(field_name, 'enum')
     
     def _generate_message_type_name(self, field_name: str) -> str:
         """
@@ -463,23 +435,7 @@ class ProtoGenerator:
         Returns:
             消息类型名（PascalCase）
         """
-        name = field_name.rstrip('_')
-        
-        # 处理常见的消息后缀
-        suffix_mappings = {
-            '_info': 'Info',
-            '_data': 'Data',
-            '_stats': 'Stats',
-            '_profile': 'Profile',
-            '_config': 'Config'
-        }
-        
-        for suffix, replacement in suffix_mappings.items():
-            if name.endswith(suffix):
-                name = name[:-len(suffix)] + replacement
-                break
-        
-        return self._to_pascal_case(name)
+        return field_name_processor.generate_type_name_from_field(field_name, 'message')
     
     @staticmethod
     def _to_pascal_case(snake_str: str) -> str:
@@ -492,8 +448,7 @@ class ProtoGenerator:
         Returns:
             帕斯卡命名字符串
         """
-        components = snake_str.split('_')
-        return ''.join(word.capitalize() for word in components)
+        return naming_converter.to_pascal_case(snake_str)
     
     @staticmethod
     def _to_snake_case(camel_str: str) -> str:
@@ -506,8 +461,4 @@ class ProtoGenerator:
         Returns:
             蛇形命名字符串
         """
-        # 处理连续大写字母：XMLParser -> XML_Parser
-        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str)
-        # 处理小写字母后跟大写字母：userId -> user_Id
-        s2 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
-        return s2.lower() 
+        return naming_converter.to_snake_case(camel_str)