1. 输入仓库路径，识别所有文件名中以“PO”或者“DTO”结尾的Java类 2. 对于一个Java类中的某个字段，如果类中定义了这个字段的getter和setter（显式定义了的，并非lombok生成那种），并且getter和setter中都调用了”AesUtils“类的静态方法，就可以认为这个字段是”加密“的 3. 输入一个java类文件的路径，检查这个类的所有字段，以及他们对应的getter和setter，分别输出加密和未加密的字段 4. 输入一个字段的名字，判断这个字段是否是”PSI“字段 5. 输入一个仓库路径，排查所有类文件，输出一个csv表格，包含这些列：类全限定类名、字段名、是否是”PSI“字段、是否已”加密“ 使用python实现上述方法。

<think>好的，我现在需要解决用户提出的五个问题，使用Python来实现。首先，我得逐一分析每个需求，然后考虑如何整合这些功能。 首先，第一个问题是从给定的仓库路径中识别所有以“PO”或“DTO”结尾的Java类。这涉及到遍历目录，查找.java文件，并检查类名是否符合后缀要求。可能需要使用os模块来遍历文件，然后用正则表达式匹配类名。第二个问题，判断字段是否加密。条件是字段的getter和setter显式调用了AesUtils的静态方法。这里需要解析Java类，检查每个字段对应的getter和setter方法是否存在，并且方法体中是否有对AesUtils的调用。这可能需要解析AST（抽象语法树），比如使用javalang库或者ANTLR，但考虑到Python中可能没有现成的Java解析器，可能需要用正则表达式或者更简单的方法来近似处理。不过，正则可能不够准确，容易出错。或者，是否有其他方法？比如使用tree-sitter的Python绑定，但需要配置可能比较复杂。或者用户是否允许使用第三方库？比如javalang，这个库可以解析Java代码为AST。但需要安装，用户可能需要注意这一点。第三个问题，输入一个Java类路径，检查所有字段，输出加密和未加密的字段。这需要结合第二个问题的逻辑，对每个字段的getter和setter进行分析。需要先解析类中的字段，然后为每个字段找到对应的getter和setter方法，再检查这些方法中是否调用了AesUtils的方法。 第四个问题，判断字段是否是“PSI”字段。用户没有给出具体定义，可能需要假设：比如字段名以“PSI”结尾，或者符合某种命名规则。比如，可能PSI字段是指字段名符合特定模式，比如包含“PSI”或者以特定方式命名。需要用户进一步澄清，但问题中可能假设根据字段名来判断，比如字段名以“Psi”结尾或者包含“PSI”等。假设这里判断条件是字段名以“PSI”结尾（不区分大小写？或者严格大写？用户可能例子中的定义是字段名包含“PSI”作为部分，例如字段名为“userPSI”）。但问题描述中可能用户有特定的规则，比如字段名是否以“PSI”结尾。例如，判断字段名是否以“PSI”结尾，如果是，则为PSI字段。所以，在代码中，可以检查字段名是否以“PSI”结尾，例如使用字符串的endswith方法，忽略大小写吗？需要明确。比如，用户可能定义字段名是否以大写“PSI”结尾，所以代码中检查字段名是否以“PSI”结尾，不区分大小写的话，可能用lower().endswith('psi')，或者严格匹配。假设问题4中的判断标准是字段名以“PSI”结尾（不区分大小写），但需要用户确认。但根据问题描述，可能用户有特定的规则，比如字段名是否包含“PSI”作为子串，或者以特定方式命名。但根据问题描述中的第4点，输入字段名判断是否是PSI字段，所以可能规则是字段名以“PSI”结尾。例如，字段名为“userPSI”则为PSI字段。所以，代码中可以用field_name.upper().endswith("PSI")来判断。第五个问题，遍历仓库路径下的所有类，生成CSV，包含类名、字段名、是否PSI、是否加密。这需要整合前几个问题的功能，即遍历所有符合条件的Java类（PO/DTO结尾），然后对每个类解析字段，判断每个字段是否是PSI字段，是否加密，然后输出到CSV。现在，如何实现这些功能？ 首先，解析Java类，获取类名、字段、方法（getter/setter）。这需要解析Java代码的结构。在Python中，可以使用javalang库，它可以将Java代码解析成AST。例如，javalang可以提取类声明、字段、方法等。所以，安装javalang是必要的。但需要注意，javalang可能对某些Java语法不支持，或者解析出错的情况。但假设用户使用的是标准语法，可以处理大部分情况。步骤：1.遍历仓库路径，找到所有以PO或DTO结尾的.java文件，并提取它们的全限定类名。全限定类名可能需要根据包声明和类名组合。例如，如果文件中的包是com.example，类名是UserDTO，则全限定名为com.example.UserDTO。 2.对于每个Java类，解析其字段和方法。使用javalang的parser来解析代码，获取类的包名、类名、字段列表、方法列表。3.对于每个字段，找到对应的getter和setter方法。例如，字段名为name，则getter可能是getName()或isName()（对于布尔类型），setter是setName()。需要根据JavaBean的命名规范来匹配。例如，字段的getter方法名是“get”+首字母大写的字段名，或者“is”对于布尔类型。setter是“set” +首字母大写的字段名。4.检查对应的getter和setter方法是否存在，并且在方法体中调用了AesUtils的静态方法。例如，检查方法体中是否有类似AesUtils.encrypt(...)或AesUtils.decrypt(...)的调用。5.判断字段是否是PSI字段，即字段名是否以PSI结尾。 6.收集所有信息，生成CSV文件。 现在，编写代码的大致步骤：首先，处理第一个问题：遍历仓库路径，找到所有PO/DTO结尾的类。这需要：-遍历目录，找到所有.java文件。-解析每个.java文件的类名，判断是否以PO或DTO结尾。 -同时，获取全限定类名（包名+类名）。 然后，对于每个类，解析字段和方法。这里用javalang：解析代码示例： importjavalangfrom javalang.parserimport Parserfrom javalang.tokenizerimport tokenizewithopen(filepath, 'r')as f:code =f.read() tree= javalang.parse.parse(code)package_name= tree.package.name iftree.packageelse ''class_decl =tree.types[0]#假设只有一个类class_name =class_decl.namefields= class_decl.fieldsmethods= class_decl.methods然后，处理每个字段： 对于每个字段，字段可能有多个变量声明，例如：String a, b;所以每个字段声明可能包含多个变量名。所以，需要遍历每个字段声明的变量。例如：for fieldin fields:for declarator infield.declarators:field_name= declarator.name#处理这个字段然后，找到对应的getter和setter方法： 假设字段名为fieldName，则getter方法可能是getFieldName()，setter是setFieldName()。或者，布尔类型可能是isFieldName()。这里需要处理这两种情况。 所以，对于每个字段名，生成可能的getter和setter方法名：可能的getter方法名：getter_candidates =['get' +field_name_capitalized,'is' +field_name_capitalized]（如果是布尔类型） setter方法名：'set'+ field_name_capitalized然后，在类的方法列表中查找是否有这些方法名。 例如：field_name_capitalized= field_name[0].upper()+ field_name[1:]getter_names= {'get'+ field_name_capitalized}if field_type =='boolean':getter_names.add('is' +field_name_capitalized)setter_name ='set' +field_name_capitalized然后，检查是否存在这些方法，并且在这些方法体中是否调用了AesUtils的静态方法。如何检查方法体中是否调用了AesUtils的静态方法？这需要分析方法的体中的方法调用。例如，在javalang的AST中，方法调用会被表示为MethodInvocation节点，其中qualifier是AesUtils，member是方法名。例如，在方法体中，遍历所有的MethodInvocation节点，检查是否有qualifier为'AesUtils'的调用。所以，对于每个方法（getter和setter），遍历其方法体中的节点，收集所有方法调用，判断是否有调用AesUtils的情况。 这可能需要递归遍历方法体的AST。例如，定义一个函数来检查方法体中是否有调用AesUtils的静态方法： defmethod_calls_aes_utils(method_node):for path, nodein method_node.filter(javalang.tree.MethodInvocation):ifnode.qualifier =='AesUtils':returnTruereturnFalse但需要注意，qualifier可能是一个复杂的表达式，比如如果是静态导入的话，可能没有qualifier。或者，可能通过importstatic的方式直接调用方法。这时候，qualifier可能不存在。所以，这种方法可能不够全面。或者，检查方法调用的全名是否是AesUtils.xxx，或者在静态导入的情况下，直接调用方法，但此时在AST中可能无法直接识别。这可能需要更复杂的处理。 假设用户代码中是显式调用AesUtils的方法，比如AesUtils.encrypt()，那么qualifier会是'AesUtils'。这种情况下，上述方法是有效的。如果存在静态导入，比如importstatic com.utils.AesUtils.encrypt;，那么在代码中直接调用encrypt()，此时qualifier会是None。这时候，上述方法会漏掉这种情况。但根据问题描述的条件，用户可能要求显式调用AesUtils类的方法，所以静态导入可能不被考虑。或者，用户的条件是只要调用了AesUtils的方法，不管是否静态导入。这时候，可能需要检查方法调用的是否属于AesUtils类的方法，但这在AST中可能无法直接判断，因为需要知道方法的定义位置。这种情况下，可能无法准确判断，除非在解析时能够确定方法所属的类。这可能比较复杂，所以假设用户代码中是显式使用AesUtils.方法名的方式调用，这样qualifier就是'AesUtils'，可以被检测到。 综上，判断方法体中是否有MethodInvocation节点的qualifier为'AesUtils'，如果有，则说明调用了该类的静态方法。因此，在代码中，对于每个getter和setter方法，检查其方法体中是否存在这样的调用。 接下来，整合这些步骤： 对于每个字段，找到对应的getter和setter方法，如果都存在，并且两者的方法体中都调用了AesUtils的方法，则该字段是加密的。现在，编写代码的大致结构： 对于给定的Java类文件路径： 1.解析包名、类名、字段、方法。 2.对于每个字段，生成可能的getter和setter方法名。3.在类的方法列表中查找对应的getter和setter方法。4.如果都存在，检查每个方法是否调用了AesUtils的方法。 5.如果都调用了，则该字段标记为加密。 6.同时检查字段名是否以PSI结尾，标记是否为PSI字段。现在，具体实现：可能遇到的问题：-字段可能声明为多个变量，例如：String a, b;此时，每个变量名都是独立的字段，需要分别处理。-方法可能存在重载，但根据JavaBean规范，getter和setter通常没有参数（getter）或只有一个参数（setter），所以可能正确匹配。- javalang库的安装和使用：用户需要安装javalang，可以通过pipinstall javalang。 -处理不同类型的字段，如boolean类型对应的is前缀的getter。现在，编写代码： 首先，处理第一个问题：遍历仓库路径，找到所有PO/DTO结尾的Java类。 代码： importosimport javalangfromjavalang.parser importParserfromjavalang.tokenizer importtokenizeimportcsvdef find_po_dto_classes(repo_path):po_dto_classes= []forroot,dirs, filesin os.walk(repo_path):forfile infiles:iffile.endswith('.java'):filepath =os.path.join(root, file)with open(filepath, 'r')as f:content =f.read()try:tree= javalang.parse.parse(content)except:#解析失败，跳过continuepackage_name= tree.package.name iftree.package else''for type_decl intree.types:ifisinstance(type_decl, javalang.tree.ClassDeclaration):class_name =type_decl.namefull_class_name =f"{package_name}.{class_name}" ifpackage_nameelse class_nameifclass_name.endswith(('PO','DTO')):po_dto_classes.append((full_class_name, filepath))returnpo_dto_classes然后，处理第三个问题：检查类中的字段是否加密，并输出结果。 接下来，编写函数来处理单个Java类文件：def check_class_fields(filepath):withopen(filepath,'r') asf:content= f.read()try:tree =javalang.parse.parse(content)except:returnNone,None,None#解析失败package_name= tree.package.name iftree.package else''class_decl =Nonefor type_declin tree.types:if isinstance(type_decl,javalang.tree.ClassDeclaration):class_decl =type_declbreakif notclass_decl:returnNone,None,Noneclass_name =class_decl.namefull_class_name =f"{package_name}.{class_name}" ifpackage_nameelse class_namemethods= {method.name: methodfor methodin class_decl.methods}encrypted_fields= []unencrypted_fields =[]psi_fields= []#处理字段forfield inclass_decl.fields:modifiers= field.modifiers#获取字段类型和变量声明field_type= field.type.namefor declarator infield.declarators:field_name= declarator.name#判断是否是PSI字段is_psi= field_name.upper().endswith('PSI')#生成getter和setter方法名capitalized=field_name[0].upper() +field_name[1:]getter_names= []#假设字段类型为boolean时可能有is前缀if field_type =='boolean':getter_names.append(f'is{capitalized}')getter_names.append(f'get{capitalized}')setter_name =f'set{capitalized}'#查找getter和setter方法getter_found= Falsesetter_found= Falsegetter_calls_aes =Falsesetter_calls_aes =Falseforgetter_name ingetter_names:ifgetter_name inmethods:getter_found =Truegetter_method= methods[getter_name]#检查是否调用了AesUtilsgetter_calls_aes =method_calls_aes_utils(getter_method)breakifsetter_name inmethods:setter_found =Truesetter_method= methods[setter_name]setter_calls_aes= method_calls_aes_utils(setter_method)#判断是否加密if getter_found andsetter_foundand getter_calls_aes andsetter_calls_aes:encrypted_fields.append(field_name)else:unencrypted_fields.append(field_name)#记录是否是PSI字段ifis_psi:psi_fields.append(field_name)returnencrypted_fields,unencrypted_fields, psi_fields,full_class_namedef method_calls_aes_utils(method_node):for_,node inmethod_node.filter(javalang.tree.MethodInvocation):ifisinstance(node, javalang.tree.MethodInvocation):qualifier =node.qualifierifqualifier== 'AesUtils':returnTruereturnFalse注意：这里可能有错误，比如处理字段类型为boolean时的逻辑是否正确，或者是否应该考虑所有可能的getter名称，比如如果存在多个getter方法（比如同时存在get和is），但根据JavaBean规范，应该只有一个getter。所以这里一旦找到其中一个就停止。 接下来，处理第五个问题，生成CSV：def generate_csv_report(repo_path,output_csv):classes= find_po_dto_classes(repo_path)with open(output_csv, 'w',newline='')as csvfile:writer= csv.writer(csvfile)writer.writerow(['Class','Field', 'Is PSI','IsEncrypted'])for full_class_name, filepath inclasses:encrypted,unencrypted,psi_fields, actual_class_name= check_class_fields(filepath)if actual_class_nameis None:continue#获取所有字段all_fields= []#需要重新解析字段名，或者从check_class_fields返回更详细的数据结构？#这里可能需要调整check_class_fields的返回结构，使其返回每个字段的详细信息。#例如，返回一个列表，每个元素是字段名、是否加密、是否PSI。#因此，需要修改check_class_fields函数，使其返回每个字段的信息。#之前的check_class_fields返回的是加密字段列表、未加密字段列表、PSI字段列表，这可能不够，因为同一个字段可能同时属于PSI和加密。#所以，需要重新设计返回结构，例如返回一个字典列表，每个字典包含字段名、是否加密、是否PSI。#因此，修改check_class_fields函数：#重新设计check_class_fields的返回结构：#返回一个列表，每个元素是字典：{'name': field_name,'encrypted':True/False, 'psi':True/False}#因此，需要重新编写这部分代码。#但为了时间，假设在之前的函数中，已经处理了每个字段的信息，并返回了所有字段的加密和PSI状态。#可能需要重新调整函数逻辑，这里可能需要重新设计函数，所以可能之前的代码需要修改。#因此，这可能是一个错误，需要重新设计函数，以返回每个字段的详细信息。#因此，修改check_class_fields函数：#在check_class_fields中，对于每个字段，收集其名称、是否加密、是否PSI。#所以，修改后的函数返回一个列表，每个元素是字段的信息字典。#重构后的check_class_fields：defcheck_class_fields_v2(filepath):withopen(filepath,'r') asf:content= f.read()try:tree =javalang.parse.parse(content)except:returnNone,None#解析失败package_name= tree.package.name iftree.package else''class_decl =Nonefortype_decl intree.types:ifisinstance(type_decl, javalang.tree.ClassDeclaration):class_decl= type_declbreakifnot class_decl:return None, Noneclass_name= class_decl.namefull_class_name= f"{package_name}.{class_name}"if package_name elseclass_namemethods ={method.name:method formethod inclass_decl.methods}fields_info= []#处理每个字段forfield inclass_decl.fields:field_type =field.type.namefordeclaratorin field.declarators:field_name =declarator.nameis_psi= field_name.upper().endswith('PSI')#处理getter和settercapitalized= field_name[0].upper()+ field_name[1:]getter_names= []iffield_type== 'boolean':getter_names.append(f'is{capitalized}')getter_names.append(f'get{capitalized}')setter_name= f'set{capitalized}'#查找getter和settergetter_found= Falsesetter_found= Falsegetter_calls_aes= Falsesetter_calls_aes= Falsefor getter_namein getter_names:if getter_namein methods:getter_found= Truegetter_method =methods[getter_name]getter_calls_aes =method_calls_aes_utils(getter_method)breakifsetter_name inmethods:setter_found =Truesetter_method= methods[setter_name]setter_calls_aes= method_calls_aes_utils(setter_method)#判断是否加密encrypted =getter_foundand setter_found andgetter_calls_aesand setter_calls_aesfields_info.append({'name': field_name,'encrypted': encrypted,'psi': is_psi})return full_class_name, fields_info然后，在生成CSV时：full_class_name, fields_info =check_class_fields_v2(filepath)iffull_class_nameis None:continueforfield_infoin fields_info:writer.writerow([full_class_name,field_info['name'],field_info['psi'],field_info['encrypted']]) 这样，每个字段的信息都会被写入CSV。现在，整合所有代码： 但是，由于时间限制，这里可能有一些函数需要调整，例如find_po_dto_classes可能需要返回文件路径和全限定类名，而check_class_fields_v2需要处理每个文件，并返回字段信息。 此外，判断是否是PO/DTO类可能在遍历时进行，而不是在find_po_dto_classes函数中，因为find_po_dto_classes函数可能应该返回所有符合条件的类，即类名以PO/DTO结尾的类的全限定名和文件路径。 综上，完整的Python代码可能如下： importosimport javalangimportcsvdef find_po_dto_classes(repo_path):"""查找所有以PO或DTO结尾的Java类"""classes= []forroot,_, filesin os.walk(repo_path):forfile infiles:ifnot file.endswith('.java'):continuefilepath =os.path.join(root, file)with open(filepath, 'r')as f:content =f.read()try:tree= javalang.parse.parse(content)except:continue#解析失败，跳过package=tree.package.nameif tree.packageelse ''fortype_decl intree.types:ifisinstance(type_decl, javalang.tree.ClassDeclaration):class_name =type_decl.nameif class_name.endswith(('PO', 'DTO')):full_name= f"{package}.{class_name}" ifpackage elseclass_nameclasses.append((full_name,filepath))return classesdefmethod_calls_aes_utils(method_node):"""检查方法是否调用了AesUtils的静态方法"""for_, nodein method_node.filter(javalang.tree.MethodInvocation):if isinstance(node,javalang.tree.MethodInvocation) andnode.qualifier== 'AesUtils':returnTruereturnFalsedef analyze_class(filepath):"""分析单个Java类，返回字段信息"""withopen(filepath,'r') asf:content= f.read()try:tree =javalang.parse.parse(content)except:returnNone,None#解析失败package= tree.package.name iftree.package else''class_decl =next((t fort intree.types ifisinstance(t, javalang.tree.ClassDeclaration)),None)ifnot class_decl:return None, Noneclass_name= class_decl.namefull_class_name= f"{package}.{class_name}" ifpackage elseclass_namemethods ={m.name:m form inclass_decl.methods}fields_info =[]for fieldin class_decl.fields:field_type= field.type.nameif isinstance(field.type,javalang.tree.ReferenceType) elsestr(field.type)fordeclaratorin field.declarators:field_name =declarator.nameis_psi= field_name.upper().endswith('PSI')#生成getter和setter方法名capitalized= field_name[0].upper()+ field_name[1:]getter_names= []iffield_type=='boolean':getter_names.append(f'is{capitalized}')getter_names.append(f'get{capitalized}')setter_name =f'set{capitalized}'#查找getter和settergetter_exists= Falsegetter_aes= Falsefor namein getter_names:if namein methods:getter_exists =Truegetter_aes =method_calls_aes_utils(methods[name])breaksetter_exists= setter_namein methodssetter_aes= method_calls_aes_utils(methods[setter_name]) ifsetter_exists elseFalseencrypted= getter_existsand setter_existsand getter_aes andsetter_aesfields_info.append({'field': field_name,'encrypted': encrypted,'psi': is_psi})return full_class_name, fields_infodef generate_report(repo_path, output_csv):"""生成CSV报告"""classes =find_po_dto_classes(repo_path)withopen(output_csv,'w', newline='') ascsvfile:writer =csv.writer(csvfile)writer.writerow(['Class', 'Field','IsPSI', 'Is Encrypted'])forfull_name, filepath inclasses:class_name,fields =analyze_class(filepath)if notclass_name:continuefor infoin fields:writer.writerow([class_name,info['field'],info['psi'],info['encrypted']])#示例用法generate_report('/path/to/repo', 'report.csv')解释：- `find_po_dto_classes`函数遍历仓库路径，找到所有以PO/DTO结尾的Java类。- `method_calls_aes_utils`检查方法是否调用了AesUtils的静态方法。 -`analyze_class`解析单个Java类文件，收集每个字段的加密和PSI状态。- `generate_report`生成最终的CSV报告。注意事项：1.需要安装javalang库：`pipinstall javalang` 2.该代码假设所有getter/setter都符合JavaBean命名规范，且显式调用了AesUtils的方法。3.静态导入或方法引用可能无法被检测到。 4.不支持Lombok生成的getter/setter。5.字段名PSI的检测基于后缀，不区分大小写。§§相关问题§§: 1.如何处理JavaBean规范中的布尔类型字段的getter方法（is前缀）？ 2.如果AesUtils的方法调用是在父类方法中，如何检测？ 3.如何优化代码以处理大型代码仓库的性能问题？ 4.如何区分Lombok生成的getter/setter和显式定义的方法？</think>以下是实现需求的Python代码及详细解释： ```python import os import javalang import csv def find_po_dto_classes(repo_path): """查找所有以PO/DTO结尾的Java类""" classes = [] for root, _, files in os.walk(repo_path): for file in files: if not file.endswith('.java'): continue filepath = os.path.join(root, file) with open(filepath, 'r', encoding='utf-8') as f: content = f.read() try: tree = javalang.parse.parse(content) except: continue package = tree.package.name if tree.package else '' for type_decl in tree.types: if isinstance(type_decl, javalang.tree.ClassDeclaration): class_name = type_decl.name if class_name.upper().endswith(('PO', 'DTO')): full_name = f"{package}.{class_name}" if package else class_name classes.append((full_name, filepath)) return classes def method_calls_aes_utils(method_node): """检查方法是否包含AesUtils调用""" for _, node in method_node.filter(javalang.tree.MethodInvocation): if isinstance(node, javalang.tree.MethodInvocation): if node.qualifier == 'AesUtils': return True return False def analyze_class(filepath): """分析单个类文件""" with open(filepath, 'r', encoding='utf-8') as f: content = f.read() try: tree = javalang.parse.parse(content) except: return None, None class_decl = next((t for t in tree.types if isinstance(t, javalang.tree.ClassDeclaration)), None) if not class_decl: return None, None package = tree.package.name if tree.package else '' class_name = f"{package}.{class_decl.name}" if package else class_decl.name methods = {m.name: m for m in class_decl.methods} field_results = [] for field in class_decl.fields: field_type = str(field.type) for declarator in field.declarators: field_name = declarator.name # 判断PSI字段（问题4） is_psi = field_name.upper().endswith('PSI') # 获取getter/setter方法名（问题2） prefix = 'is' if field_type == 'boolean' else 'get' getter_names = [f'{prefix}{field_name[0].upper()}{field_name[1:]}'] if prefix == 'is': getter_names.append(f'get{field_name[0].upper()}{field_name[1:]}') setter_name = f'set{field_name[0].upper()}{field_name[1:]}' # 检查方法存在性及AES调用 getter_aes = False for getter in getter_names: if getter in methods: getter_aes = method_calls_aes_utils(methods[getter]) break setter_aes = method_calls_aes_utils(methods[setter_name]) if setter_name in methods else False is_encrypted = getter_aes and setter_aes field_results.append({ 'name': field_name, 'encrypted': is_encrypted, 'psi': is_psi }) return class_name, field_results def generate_report(repo_path, output_file): """生成最终报告（问题5）""" classes = find_po_dto_classes(repo_path) with open(output_file, 'w', newline='', encoding='utf-8') as f: writer = csv.writer(f) writer.writerow(['Class', 'Field', 'Is PSI', 'Is Encrypted']) for class_name, filepath in classes: full_name, fields = analyze_class(filepath) if not full_name: continue for field in fields: writer.writerow([ full_name, field['name'], field['psi'], field['encrypted'] ]) # 使用示例 generate_report('/path/to/repository', 'encryption_report.csv') ``` 代码解释： 1. `find_po_dto_classes`：遍历仓库目录，使用javalang解析Java文件，识别以PO/DTO结尾的类 2. `method_calls_aes_utils`：检查方法体内是否包含AesUtils的静态方法调用 3. `analyze_class`：分析单个类的字段，判断PSI字段和加密状态 4. `generate_report`：生成包含所有检测结果的CSV报告 注意事项： 1. 需要安装javalang库：`pip install javalang` 2. 假设所有getter/setter都符合标准命名规范 3. 不支持Lombok等代码生成工具 4. PSI字段判断基于字段名后缀（不区分大小写）