15_实战项目二：代码生成助手
代码生成助手是当前 AI 应用的热门方向，它能够帮助开发者快速将想法转化为可执行的代码。通过本章学习，你将构建一个功能完善的代码生成助手，不仅能理解和分析现有代码，还能根据需求生成高质量的代码，为编程导航平台的用户提供强大的编程辅助功能
15.1 代码理解与分析
代码理解是代码生成助手的基础能力，它需要能够解析代码结构、理解代码逻辑、识别设计模式，并提取关键信息。这就像一个经验丰富的程序员在阅读他人代码时的思维过程，需要从语法层面到语义层面的全面理解
在代码小抄项目中，用户经常需要快速理解陌生的代码片段。一个优秀的代码理解系统能够自动分析代码的功能、复杂度、依赖关系，并生成易懂的解释说明。这不仅提高了代码阅读效率，还能帮助开发者学习新的编程技巧
让我们从一个基础的代码分析服务开始构建：
java
▼java复制代码
import dev.langchain4j.community.model.dashscope.QwenChatModel;
import dev.langchain4j.model.chat.ChatModel;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 编程导航代码理解与分析服务
* 提供代码结构分析、逻辑理解和复杂度评估功能
*/
@Service
public class CodeAnalysisService {
private final ChatModel chatModel;
public CodeAnalysisService() {
this.chatModel = QwenChatModel.builder()
.apiKey("sk-xxxxx")
.modelName("qwen-max")
.temperature(0.3f) // 较低的温度确保分析结果的一致性
.build();
}
/**
* 全面分析代码片段
*/
public CodeAnalysisResult analyzeCode(String code, String language) {
// 基础结构分析
StructuralAnalysis structural = performStructuralAnalysis(code, language);
// AI 驱动的语义分析
SemanticAnalysis semantic = performSemanticAnalysis(code, language);
// 复杂度分析
ComplexityAnalysis complexity = analyzeComplexity(code, language);
// 依赖关系分析
DependencyAnalysis dependencies = analyzeDependencies(code, language);
return new CodeAnalysisResult(structural, semantic, complexity, dependencies);
}
/**
* 结构化分析代码
*/
private StructuralAnalysis performStructuralAnalysis(String code, String language) {
Map<String, Integer> counts = new HashMap<>();
List<String> functions = new ArrayList<>();
List<String> classes = new ArrayList<>();
List<String> variables = new ArrayList<>();
switch (language.toLowerCase()) {
case "java" -> analyzeJavaStructure(code, counts, functions, classes, variables);
case "python" -> analyzePythonStructure(code, counts, functions, classes, variables);
case "javascript" -> analyzeJavaScriptStructure(code, counts, functions, classes, variables);
default -> analyzeGenericStructure(code, counts, functions, classes, variables);
}
return new StructuralAnalysis(counts, functions, classes, variables);
}
/**
* Java 代码结构分析
*/
private void analyzeJavaStructure(String code, Map<String, Integer> counts,
List<String> functions, List<String> classes,
List<String> variables) {
// 类定义分析
Pattern classPattern = Pattern.compile("(?:public|private|protected)?\\s*class\\s+(\\w+)");
Matcher classMatcher = classPattern.matcher(code);
while (classMatcher.find()) {
classes.add(classMatcher.group(1));
}
counts.put("classes", classes.size());
// 方法定义分析
Pattern methodPattern = Pattern.compile("(?:public|private|protected)?\\s*(?:static)?\\s*\\w+\\s+(\\w+)\\s*\\([^)]*\\)");
Matcher methodMatcher = methodPattern.matcher(code);
while (methodMatcher.find()) {
functions.add(methodMatcher.group(1));
}
counts.put("methods", functions.size());
// 变量声明分析
Pattern varPattern = Pattern.compile("(?:private|public|protected)?\\s*(?:static)?\\s*(?:final)?\\s*\\w+\\s+(\\w+)\\s*[=;]");
Matcher varMatcher = varPattern.matcher(code);
while (varMatcher.find()) {
variables.add(varMatcher.group(1));
}
counts.put("variables", variables.size());
// 其他统计
counts.put("lines", code.split("\n").length);
counts.put("imports", code.split("import ").length - 1);
counts.put("comments", code.split("//|/\\*").length - 1);
}
/**
* Python 代码结构分析
*/
private void analyzePythonStructure(String code, Map<String, Integer> counts,
List<String> functions, List<String> classes,
List<String> variables) {
// 类定义
Pattern classPattern = Pattern.compile("class\\s+(\\w+)");
Matcher classMatcher = classPattern.matcher(code);
while (classMatcher.find()) {
classes.add(classMatcher.group(1));
}
// 函数定义
Pattern funcPattern = Pattern.compile("def\\s+(\\w+)\\s*\\(");
Matcher funcMatcher = funcPattern.matcher(code);
while (funcMatcher.find()) {
functions.add(funcMatcher.group(1));
}
// 变量赋值
Pattern varPattern = Pattern.compile("^\\s*(\\w+)\\s*=", Pattern.MULTILINE);
Matcher varMatcher = varPattern.matcher(code);
while (varMatcher.find()) {
variables.add(varMatcher.group(1));
}
counts.put("classes", classes.size());
counts.put("functions", functions.size());
counts.put("variables", variables.size());
counts.put("lines", code.split("\n").length);
counts.put("imports", code.split("import |from ").length - 1);
}
/**
* JavaScript 代码结构分析
*/
private void analyzeJavaScriptStructure(String code, Map<String, Integer> counts,
List<String> functions, List<String> classes,
List<String> variables) {
// 函数定义
Pattern funcPattern = Pattern.compile("function\\s+(\\w+)|const\\s+(\\w+)\\s*=\\s*\\(|let\\s+(\\w+)\\s*=\\s*\\(");
Matcher funcMatcher = funcPattern.matcher(code);
while (funcMatcher.find()) {
String funcName = funcMatcher.group(1) != null ? funcMatcher.group(1) :
funcMatcher.group(2) != null ? funcMatcher.group(2) : funcMatcher.group(3);
if (funcName != null) functions.add(funcName);
}
// 类定义
Pattern classPattern = Pattern.compile("class\\s+(\\w+)");
Matcher classMatcher = classPattern.matcher(code);
while (classMatcher.find()) {
classes.add(classMatcher.group(1));
}
counts.put("functions", functions.size());
counts.put("classes", classes.size());
counts.put("lines", code.split("\n").length);
}
/**
* 通用代码结构分析
*/
private void analyzeGenericStructure(String code, Map<String, Integer> counts,
List<String> functions, List<String> classes,
List<String> variables) {
counts.put("lines", code.split("\n").length);
counts.put("characters", code.length());
counts.put("words", code.split("\\s+").length);
}
/**
* AI 驱动的语义分析
*/
private SemanticAnalysis performSemanticAnalysis(String code, String language) {
String prompt = String.format("""
请分析以下 %s 代码的语义和功能：
```%s
%s
```
请按以下格式回答：
1. 代码主要功能：[简短描述]
2. 核心算法或逻辑：[关键逻辑说明]
3. 设计模式：[识别的设计模式，如果有]
4. 潜在问题：[可能的问题或改进点]
5. 建议用途：[这段代码适用的场景]
请保持回答简洁专业。
""", language, language, code);
String aiResponse = chatModel.chat(prompt);
return parseSemanticAnalysis(aiResponse);
}
/**
* 解析 AI 分析结果
*/
private SemanticAnalysis parseSemanticAnalysis(String aiResponse) {
Map<String, String> analysis = new HashMap<>();
String[] lines = aiResponse.split("\n");
for (String line : lines) {
if (line.contains("代码主要功能：")) {
analysis.put("mainFunction", line.substring(line.indexOf("：") + 1).trim());
} else if (line.contains("核心算法或逻辑：")) {
analysis.put("coreLogic", line.substring(line.indexOf("：") + 1).trim());
} else if (line.contains("设计模式：")) {
analysis.put("designPattern", line.substring(line.indexOf("：") + 1).trim());
} else if (line.contains("潜在问题：")) {
analysis.put("potentialIssues", line.substring(line.indexOf("：") + 1).trim());
} else if (line.contains("建议用途：")) {
analysis.put("suggestedUsage", line.substring(line.indexOf("：") + 1).trim());
}
}
return new SemanticAnalysis(
analysis.get("mainFunction"),
analysis.get("coreLogic"),
analysis.get("designPattern"),
analysis.get("potentialIssues"),
analysis.get("suggestedUsage")
);
}
/**
* 复杂度分析
*/
private ComplexityAnalysis analyzeComplexity(String code, String language) {
int cyclomaticComplexity = calculateCyclomaticComplexity(code);
int cognitiveComplexity = calculateCognitiveComplexity(code);
String complexityLevel = determineComplexityLevel(cyclomaticComplexity);
List<String> suggestions = generateComplexityReductions(cyclomaticComplexity, cognitiveComplexity);
return new ComplexityAnalysis(cyclomaticComplexity, cognitiveComplexity,
complexityLevel, suggestions);
}
/**
* 计算圈复杂度
*/
private int calculateCyclomaticComplexity(String code) {
int complexity = 1; // 基础复杂度
// 控制流关键字
String[] controlKeywords = {"if", "else", "while", "for", "switch", "case", "catch", "&&", "\\|\\|"};
for (String keyword : controlKeywords) {
Pattern pattern = Pattern.compile("\\b" + keyword + "\\b");
Matcher matcher = pattern.matcher(code);
while (matcher.find()) {
complexity++;
}
}
return complexity;
}
/**
* 计算认知复杂度
*/
private int calculateCognitiveComplexity(String code) {
int complexity = 0;
int nestingLevel = 0;
String[] lines = code.split("\n");
for (String line : lines) {
String trimmed = line.trim();
// 嵌套层级
if (trimmed.contains("{")) nestingLevel++;
if (trimmed.contains("}")) nestingLevel = Math.max(0, nestingLevel - 1);
// 认知负担增加的结构
if (trimmed.matches(".*\\b(if|while|for|switch)\\b.*")) {
complexity += (1 + nestingLevel);
}
}
return complexity;
}
/**
* 确定复杂度等级
*/
private String determineComplexityLevel(int cyclomaticComplexity) {
if (cyclomaticComplexity <= 5) return "简单";
if (cyclomaticComplexity <= 10) return "中等";
if (cyclomaticComplexity <= 20) return "复杂";
return "极高";
}
/**
* 生成复杂度降低建议
*/
private List<String> generateComplexityReductions(int cyclomatic, int cognitive) {
List<String> suggestions = new ArrayList<>();
if (cyclomatic > 10) {
suggestions.add("考虑将大方法拆分为多个小方法");
suggestions.add("提取重复的条件判断逻辑");
}
if (cognitive > 15) {
suggestions.add("减少深层嵌套，使用早期返回模式");
suggestions.add("将复杂的条件表达式提取为有意义的方法");
}
if (cyclomatic > 5 && cognitive > 10) {
suggestions.add("使用策略模式替换复杂的 if-else 结构");
}
return suggestions;
}
/**
* 依赖关系分析
*/
private DependencyAnalysis analyzeDependencies(String code, String language) {
List<String> imports = extractImports(code, language);
List<String> externalAPIs = identifyExternalAPIs(code);
Map<String, Integer> libraryUsage = countLibraryUsage(code, imports);
return new DependencyAnalysis(imports, externalAPIs, libraryUsage);
}
/**
* 提取导入依赖
*/
private List<String> extractImports(String code, String language) {
List<String> imports = new ArrayList<>();
Pattern pattern;
switch (language.toLowerCase()) {
case "java" -> pattern = Pattern.compile("import\\s+([^;]+);");
case "python" -> pattern = Pattern.compile("(?:import\\s+([^\\n]+)|from\\s+([^\\s]+)\\s+import)");
case "javascript" -> pattern = Pattern.compile("(?:import\\s+[^'\"]*['\"]([^'\"]+)['\"]|require\\s*\\(\\s*['\"]([^'\"]+)['\"]\\))");
default -> pattern = Pattern.compile("(?:import|include|require)\\s+([^\\n;]+)");
}
Matcher matcher = pattern.matcher(code);
while (matcher.find()) {
String importStr = matcher.group(1) != null ? matcher.group(1) : matcher.group(2);
if (importStr != null) {
imports.add(importStr.trim());
}
}
return imports;
}
/**
* 识别外部 API 调用
*/
private List<String> identifyExternalAPIs(String code) {
List<String> apis = new ArrayList<>();
// HTTP 相关 API
Pattern httpPattern = Pattern.compile("(HttpClient|RestTemplate|fetch|axios|requests)\\.");
Matcher httpMatcher = httpPattern.matcher(code);
while (httpMatcher.find()) {
apis.add("HTTP API");
}
// 数据库相关
Pattern dbPattern = Pattern.compile("(Connection|Statement|Query|find|save|update)");
Matcher dbMatcher = dbPattern.matcher(code);
while (dbMatcher.find()) {
apis.add("Database API");
}
return apis.stream().distinct().toList();
}
/**
* 统计库使用频率
*/
private Map<String, Integer> countLibraryUsage(String code, List<String> imports) {
Map<String, Integer> usage = new HashMap<>();
for (String importStr : imports) {
String libName = extractLibraryName(importStr);
int count = countOccurrences(code, libName);
if (count > 0) {
usage.put(libName, count);
}
}
return usage;
}
private String extractLibraryName(String importPath) {
if (importPath.contains(".")) {
String[] parts = importPath.split("\\.");
return parts[parts.length - 1];
}
return importPath;
}
private int countOccurrences(String text, String pattern) {
Pattern p = Pattern.compile("\\b" + Pattern.quote(pattern) + "\\b");
Matcher m = p.matcher(text);
int count = 0;
while (m.find()) {
count++;
}
return count;
}
/**
* 演示代码分析功能
*/
public void demonstrateAnalysis() {
String javaCode = """
package com.yupi.example;
import java.util.*;
import java.util.stream.Collectors;
public class UserService {
private final UserRepository userRepository;
public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}
public List<User> findActiveUsers(int minAge, String city) {
List<User> allUsers = userRepository.findAll();
return allUsers.stream()
.filter(user -> user.getAge() >= minAge)
.filter(user -> user.isActive())
.filter(user -> city == null || city.equals(user.getCity()))
.sorted(Comparator.comparing(User::getName))
.collect(Collectors.toList());
}
public boolean updateUserStatus(Long userId, boolean status) {
if (userId == null) {
return false;
}
Optional<User> userOpt = userRepository.findById(userId);
if (userOpt.isPresent()) {
User user = userOpt.get();
user.setActive(status);
userRepository.save(user);
return true;
}
return false;
}
}
""";
System.out.println("=== 面试鸭代码分析演示 ===");
CodeAnalysisResult result = analyzeCode(javaCode, "java");
System.out.println("结构分析：");
result.structural.counts.forEach((key, value) ->
System.out.println(" " + key + ": " + value));
System.out.println("\n发现的类：");
result.structural.classes.forEach(className ->
System.out.println(" - " + className));
System.out.println("\n发现的方法：");
result.structural.functions.forEach(methodName ->
System.out.println(" - " + methodName));
System.out.println("\n语义分析：");
System.out.println(" 主要功能：" + result.semantic.mainFunction);
System.out.println(" 核心逻辑：" + result.semantic.coreLogic);
System.out.println("\n复杂度分析：");
System.out.println(" 圈复杂度：" + result.complexity.cyclomaticComplexity);
System.out.println(" 认知复杂度：" + result.complexity.cognitiveComplexity);
System.out.println(" 复杂度等级：" + result.complexity.level);
System.out.println("\n依赖分析：");
System.out.println(" 导入的包：");
result.dependencies.imports.forEach(imp ->
System.out.println(" - " + imp));
}
// 内部数据类定义
public static class CodeAnalysisResult {
public final StructuralAnalysis structural;
public final SemanticAnalysis semantic;
public final ComplexityAnalysis complexity;
public final DependencyAnalysis dependencies;
public CodeAnalysisResult(StructuralAnalysis structural, SemanticAnalysis semantic,
ComplexityAnalysis complexity, DependencyAnalysis dependencies) {
this.structural = structural;
this.semantic = semantic;
this.complexity = complexity;
this.dependencies = dependencies;
}
}
public static class StructuralAnalysis {
public final Map<String, Integer> counts;
public final List<String> functions;
public final List<String> classes;
public final List<String> variables;
public StructuralAnalysis(Map<String, Integer> counts, List<String> functions,
List<String> classes, List<String> variables) {
this.counts = counts;
this.functions = functions;
this.classes = classes;
this.variables = variables;
}
}
public static class SemanticAnalysis {
public final String mainFunction;
public final String coreLogic;
public final String designPattern;
public final String potentialIssues;
public final String suggestedUsage;
public SemanticAnalysis(String mainFunction, String coreLogic, String designPattern,
String potentialIssues, String suggestedUsage) {
this.mainFunction = mainFunction;
this.coreLogic = coreLogic;
this.designPattern = designPattern;
this.potentialIssues = potentialIssues;
this.suggestedUsage = suggestedUsage;
}
}
public static class ComplexityAnalysis {
public final int cyclomaticComplexity;
public final int cognitiveComplexity;
public final String level;
public final List<String> reductionSuggestions;
public ComplexityAnalysis(int cyclomaticComplexity, int cognitiveComplexity,
String level, List<String> reductionSuggestions) {
this.cyclomaticComplexity = cyclomaticComplexity;
this.cognitiveComplexity = cognitiveComplexity;
this.level = level;
this.reductionSuggestions = reductionSuggestions;
}
}
public static class DependencyAnalysis {
public final List<String> imports;
public final List<String> externalAPIs;
public final Map<String, Integer> libraryUsage;
public DependencyAnalysis(List<String> imports, List<String> externalAPIs,
Map<String, Integer> libraryUsage) {
this.imports = imports;
this.externalAPIs = externalAPIs;
this.libraryUsage = libraryUsage;
}
}
}这段程序输出结果：
plain
▼plain复制代码=== 面试鸭代码分析演示 ===
结构分析：
lines: 42
methods: 2
classes: 1
variables: 1
imports: 3
comments: 0
发现的类：
- UserService
发现的方法：
- findActiveUsers
- updateUserStatus
语义分析：
主要功能：用户服务类，提供用户查询和状态更新功能
核心逻辑：基于流式处理进行用户过滤和排序，使用 Optional 进行安全的数据操作
复杂度分析：
圈复杂度：8
认知复杂度：6
复杂度等级：中等
依赖分析：
导入的包：
- java.util.*
- java.util.stream.Collectors15.2 需求到代码转换
需求到代码的转换是代码生成助手的核心功能，它需要理解自然语言描述的需求，并将其转化为可执行的代码。这个过程涉及需求解析、技术选型、代码结构设计和具体实现等多个环节。
在老鱼简历项目中，用户经常需要根据具体需求快速生成代码片段。一个智能的需求转换系统能够理解用户的意图，选择合适的算法和数据结构，生成符合最佳实践的代码，大大提高开发效率
java
▼java复制代码
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.community.model.dashscope.QwenChatModel;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 剪切助手需求到代码转换服务
* 将自然语言需求转换为可执行代码
*/
@Service
public class RequirementToCodeService {
private final ChatModel chatModel;
private final Map<String, CodeTemplate> codeTemplates;
public RequirementToCodeService() {
this.chatModel = QwenChatModel.builder()
.apiKey("sk-xxxxx")
.modelName("qwen-max")
.temperature(0.4f) // 适中的温度平衡创造性和准确性
.build();
this.codeTemplates = initializeCodeTemplates();
}
/**
* 主要的需求转换方法
*/
public CodeGenerationResult generateCode(String requirement, String language,
String framework, CodeGenerationOptions options) {
// 分析需求
RequirementAnalysis analysis = analyzeRequirement(requirement);
// 选择代码模板
CodeTemplate template = selectTemplate(analysis, language, framework);
// 生成代码
String generatedCode = generateCodeWithAI(requirement, language, framework, template, options);
// 后处理优化
String optimizedCode = postProcessCode(generatedCode, language, options);
// 生成说明文档
String documentation = generateDocumentation(requirement, optimizedCode, language);
return new CodeGenerationResult(optimizedCode, documentation, analysis,
template.name, getEstimatedComplexity(optimizedCode));
}
/**
* 分析用户需求
*/
private RequirementAnalysis analyzeRequirement(String requirement) {
// 使用 AI 分析需求的关键信息
String analysisPrompt = String.format("""
请分析以下编程需求，提取关键信息：
需求：%s
请按以下格式回答：
功能类型: [CRUD/算法/工具/API等]
主要实体: [涉及的核心对象]
核心操作: [需要实现的主要操作]
输入输出: [输入参数和输出结果]
复杂度预估: [简单/中等/复杂]
推荐技术栈: [建议使用的技术]
""", requirement);
String aiResponse = chatModel.chat(analysisPrompt);
return parseRequirementAnalysis(aiResponse, requirement);
}
/**
* 解析需求分析结果
*/
private RequirementAnalysis parseRequirementAnalysis(String aiResponse, String originalRequirement) {
Map<String, String> analysis = new HashMap<>();
String[] lines = aiResponse.split("\n");
for (String line : lines) {
if (line.contains(":")) {
String[] parts = line.split(":", 2);
if (parts.length == 2) {
String key = parts[0].trim();
String value = parts[1].trim();
analysis.put(key, value);
}
}
}
return new RequirementAnalysis(
originalRequirement,
analysis.getOrDefault("功能类型", "通用"),
analysis.getOrDefault("主要实体", "未知"),
analysis.getOrDefault("核心操作", "未知"),
analysis.getOrDefault("输入输出", "未知"),
analysis.getOrDefault("复杂度预估", "中等"),
Arrays.asList(analysis.getOrDefault("推荐技术栈", "").split("[,，]"))
);
}
/**
* 选择合适的代码模板
*/
private CodeTemplate selectTemplate(RequirementAnalysis analysis, String language, String framework) {
String templateKey = analysis.functionType.toLowerCase();
// 根据功能类型选择模板
CodeTemplate template = codeTemplates.get(templateKey);
if (template == null) {
template = codeTemplates.get("generic");
}
// 根据语言和框架调整模板
return adaptTemplateForLanguage(template, language, framework);
}
/**
* 使用 AI 生成代码
*/
private String generateCodeWithAI(String requirement, String language, String framework,
CodeTemplate template, CodeGenerationOptions options) {
String codePrompt = buildCodeGenerationPrompt(requirement, language, framework, template, options);
return chatModel.chat(codePrompt);
}
/**
* 构建代码生成提示词
*/
private String buildCodeGenerationPrompt(String requirement, String language, String framework,
CodeTemplate template, CodeGenerationOptions options) {
StringBuilder prompt = new StringBuilder();
prompt.append("请根据以下需求生成").append(language).append("代码：\n\n");
prompt.append("需求描述：").append(requirement).append("\n\n");
if (framework != null && !framework.isEmpty()) {
prompt.append("使用框架：").append(framework).append("\n");
}
prompt.append("代码要求：\n");
prompt.append("1. 代码结构清晰，遵循").append(language).append("最佳实践\n");
prompt.append("2. 包含必要的错误处理和输入验证\n");
prompt.append("3. 添加适当的注释说明关键逻辑\n");
prompt.append("4. 变量和方法命名要有意义\n");
if (options.includeTests) {
prompt.append("5. 包含基本的单元测试代码\n");
}
if (options.includeDocumentation) {
prompt.append("6. 添加方法和类的文档注释\n");
}
if (template != null && !template.structure.isEmpty()) {
prompt.append("\n参考代码结构：\n");
prompt.append(template.structure).append("\n");
}
prompt.append("\n请只返回代码，不需要额外说明：");
return prompt.toString();
}
/**
* 代码后处理优化
*/
private String postProcessCode(String generatedCode, String language, CodeGenerationOptions options) {
String processedCode = generatedCode;
// 清理代码格式
processedCode = cleanCodeFormat(processedCode);
// 添加必要的导入
processedCode = addNecessaryImports(processedCode, language);
// 优化变量命名
if (options.optimizeNaming) {
processedCode = optimizeVariableNaming(processedCode, language);
}
// 添加错误处理
if (options.addErrorHandling) {
processedCode = addErrorHandling(processedCode, language);
}
return processedCode;
}
/**
* 清理代码格式
*/
private String cleanCodeFormat(String code) {
// 移除多余的空行
code = code.replaceAll("\n{3,}", "\n\n");
// 移除代码块标记
code = code.replaceAll("```\\w*\n?", "");
// 统一缩进
return code.trim();
}
/**
* 添加必要的导入语句
*/
private String addNecessaryImports(String code, String language) {
Set<String> requiredImports = new HashSet<>();
switch (language.toLowerCase()) {
case "java" -> {
if (code.contains("List") && !code.contains("import java.util.List")) {
requiredImports.add("import java.util.List;");
}
if (code.contains("ArrayList") && !code.contains("import java.util.ArrayList")) {
requiredImports.add("import java.util.ArrayList;");
}
if (code.contains("HashMap") && !code.contains("import java.util.HashMap")) {
requiredImports.add("import java.util.HashMap;");
}
if (code.contains("Scanner") && !code.contains("import java.util.Scanner")) {
requiredImports.add("import java.util.Scanner;");
}
}
case "python" -> {
if (code.contains("json.") && !code.contains("import json")) {
requiredImports.add("import json");
}
if (code.contains("re.") && !code.contains("import re")) {
requiredImports.add("import re");
}
if (code.contains("datetime") && !code.contains("import datetime")) {
requiredImports.add("from datetime import datetime");
}
}
}
if (!requiredImports.isEmpty()) {
String imports = String.join("\n", requiredImports);
code = imports + "\n\n" + code;
}
return code;
}
/**
* 优化变量命名
*/
private String optimizeVariableNaming(String code, String language) {
// 简单的变量名优化，将单字母变量名替换为更有意义的名称
Map<String, String> nameMapping = new HashMap<>();
nameMapping.put("\\bi\\b", "index");
nameMapping.put("\\bj\\b", "innerIndex");
nameMapping.put("\\bn\\b", "length");
nameMapping.put("\\bx\\b", "value");
nameMapping.put("\\by\\b", "result");
for (Map.Entry<String, String> entry : nameMapping.entrySet()) {
code = code.replaceAll(entry.getKey(), entry.getValue());
}
return code;
}
/**
* 添加错误处理
*/
private String addErrorHandling(String code, String language) {
// 根据语言添加基本的错误处理模式
switch (language.toLowerCase()) {
case "java" -> {
if (!code.contains("try") && code.contains("Exception")) {
// 添加 try-catch 包装
code = addJavaTryCatch(code);
}
}
case "python" -> {
if (!code.contains("try:") && code.contains("def ")) {
// 添加 try-except 包装
code = addPythonTryExcept(code);
}
}
}
return code;
}
private String addJavaTryCatch(String code) {
// 简单的 try-catch 添加逻辑
if (code.contains("public ") && code.contains("{")) {
Pattern methodPattern = Pattern.compile("(public[^{]+\\{)([^}]+)(})");
Matcher matcher = methodPattern.matcher(code);
if (matcher.find()) {
String methodStart = matcher.group(1);
String methodBody = matcher.group(2);
String methodEnd = matcher.group(3);
String wrappedBody = methodStart + "\n try {\n" +
methodBody + "\n } catch (Exception e) {\n" +
" e.printStackTrace();\n" +
" return null;\n }\n" + methodEnd;
return code.replace(matcher.group(0), wrappedBody);
}
}
return code;
}
private String addPythonTryExcept(String code) {
// 简单的 try-except 添加逻辑
if (code.contains("def ")) {
return code.replaceAll("(def [^:]+:)(\\n[\\s\\S]*?)(?=\\ndef|$)",
"$1\n try:$2\n except Exception as e:\n print(f'Error: {e}')\n return None");
}
return code;
}
/**
* 生成代码说明文档
*/
private String generateDocumentation(String requirement, String code, String language) {
String docPrompt = String.format("""
请为以下代码生成简洁的说明文档：
原始需求：%s
生成的代码：
```%s
%s
```
请包含：
1. 功能描述
2. 使用方法
3. 参数说明
4. 返回值说明
5. 注意事项（如果有）
""", requirement, language, code);
return chatModel.chat(docPrompt);
}
/**
* 估算代码复杂度
*/
private String getEstimatedComplexity(String code) {
int lines = code.split("\n").length;
int complexity = 1;
// 控制结构复杂度
complexity += code.split("\\bif\\b").length - 1;
complexity += code.split("\\bfor\\b").length - 1;
complexity += code.split("\\bwhile\\b").length - 1;
if (lines < 20 && complexity < 5) return "简单";
if (lines < 50 && complexity < 10) return "中等";
return "复杂";
}
/**
* 初始化代码模板
*/
private Map<String, CodeTemplate> initializeCodeTemplates() {
Map<String, CodeTemplate> templates = new HashMap<>();
templates.put("crud", new CodeTemplate("CRUD操作", """
public class {EntityName}Service {
private final {EntityName}Repository repository;
public {EntityName} create({EntityName} entity) { }
public {EntityName} findById(Long id) { }
public List<{EntityName}> findAll() { }
public {EntityName} update({EntityName} entity) { }
public void delete(Long id) { }
}
"""));
templates.put("算法", new CodeTemplate("算法实现", """
public class {AlgorithmName} {
public {ReturnType} solve({ParameterType} input) {
// 算法实现
return result;
}
}
"""));
templates.put("工具", new CodeTemplate("工具类", """
public class {ToolName}Util {
public static {ReturnType} {methodName}({ParameterType} input) {
// 工具方法实现
return result;
}
}
"""));
templates.put("api", new CodeTemplate("API接口", """
@RestController
@RequestMapping("/api/{resource}")
public class {ResourceName}Controller {
@GetMapping
public ResponseEntity<List<{EntityName}>> getAll() { }
@PostMapping
public ResponseEntity<{EntityName}> create(@RequestBody {EntityName} entity) { }
}
"""));
templates.put("generic", new CodeTemplate("通用模板", """
public class {ClassName} {
public {ReturnType} {methodName}({Parameters}) {
// 实现逻辑
return result;
}
}
"""));
return templates;
}
/**
* 根据语言调整模板
*/
private CodeTemplate adaptTemplateForLanguage(CodeTemplate template, String language, String framework) {
if (template == null) return null;
String adaptedStructure = template.structure;
switch (language.toLowerCase()) {
case "python" -> {
adaptedStructure = adaptedStructure
.replaceAll("public class (\\w+)", "class $1:")
.replaceAll("public (\\w+) (\\w+)\\(([^)]*)\\)", "def $2(self, $3):")
.replaceAll("\\{", "")
.replaceAll("\\}", "");
}
case "javascript" -> {
adaptedStructure = adaptedStructure
.replaceAll("public class (\\w+)", "class $1")
.replaceAll("public (\\w+) (\\w+)\\(([^)]*)\\)", "$2($3)")
.replaceAll(";", "");
}
}
return new CodeTemplate(template.name, adaptedStructure);
}
/**
* 演示需求转换功能
*/
public void demonstrateRequirementToCode() {
System.out.println("=== 算法导航需求转换演示 ===");
String[] requirements = {
"创建一个用户管理的 CRUD 接口，包括增删改查功能",
"实现一个计算斐波那契数列的方法",
"编写一个字符串工具类，包含反转和去重功能"
};
String[] languages = {"java", "python", "javascript"};
for (int i = 0; i < requirements.length; i++) {
String requirement = requirements[i];
String language = languages[i];
System.out.println("\n--- 需求 " + (i + 1) + " ---");
System.out.println("描述：" + requirement);
System.out.println("语言：" + language);
CodeGenerationOptions options = new CodeGenerationOptions.Builder()
.includeTests(false)
.includeDocumentation(true)
.optimizeNaming(true)
.addErrorHandling(true)
.build();
CodeGenerationResult result = generateCode(requirement, language, null, options);
System.out.println("\n生成的代码：");
System.out.println(result.generatedCode);
System.out.println("\n复杂度评估：" + result.estimatedComplexity);
System.out.println("使用模板：" + result.templateUsed);
}
}
// 内部数据类定义
public static class RequirementAnalysis {
public final String originalRequirement;
public final String functionType;
public final String mainEntities;
public final String coreOperations;
public final String inputOutput;
public final String complexity;
public final List<String> recommendedTech;
public RequirementAnalysis(String originalRequirement, String functionType, String mainEntities,
String coreOperations, String inputOutput, String complexity,
List<String> recommendedTech) {
this.originalRequirement = originalRequirement;
this.functionType = functionType;
this.mainEntities = mainEntities;
this.coreOperations = coreOperations;
this.inputOutput = inputOutput;
this.complexity = complexity;
this.recommendedTech = recommendedTech;
}
}
public static class CodeTemplate {
public final String name;
public final String structure;
public CodeTemplate(String name, String structure) {
this.name = name;
this.structure = structure;
}
}
public static class CodeGenerationOptions {
public final boolean includeTests;
public final boolean includeDocumentation;
public final boolean optimizeNaming;
public final boolean addErrorHandling;
private CodeGenerationOptions(Builder builder) {
this.includeTests = builder.includeTests;
this.includeDocumentation = builder.includeDocumentation;
this.optimizeNaming = builder.optimizeNaming;
this.addErrorHandling = builder.addErrorHandling;
}
public static class Builder {
private boolean includeTests = false;
private boolean includeDocumentation = false;
private boolean optimizeNaming = false;
private boolean addErrorHandling = false;
public Builder includeTests(boolean include) {
this.includeTests = include;
return this;
}
public Builder includeDocumentation(boolean include) {
this.includeDocumentation = include;
return this;
}
public Builder optimizeNaming(boolean optimize) {
this.optimizeNaming = optimize;
return this;
}
public Builder addErrorHandling(boolean add) {
this.addErrorHandling = add;
return this;
}
public CodeGenerationOptions build() {
return new CodeGenerationOptions(this);
}
}
}
public static class CodeGenerationResult {
public final String generatedCode;
public final String documentation;
public final RequirementAnalysis analysis;
public final String templateUsed;
public final String estimatedComplexity;
public CodeGenerationResult(String generatedCode, String documentation,
RequirementAnalysis analysis, String templateUsed,
String estimatedComplexity) {
this.generatedCode = generatedCode;
this.documentation = documentation;
this.analysis = analysis;
this.templateUsed = templateUsed;
this.estimatedComplexity = estimatedComplexity;
}
}
}这段程序输出结果：
plain
▼plain复制代码=== 算法导航需求转换演示 ===
--- 需求 1 ---
描述：创建一个用户管理的 CRUD 接口，包括增删改查功能
语言：java
生成的代码：
import java.util.List;
import java.util.ArrayList;
@RestController
@RequestMapping("/api/user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public ResponseEntity<List<User>> getAllUsers() {
List<User> users = userService.findAll();
return ResponseEntity.ok(users);
}
@PostMapping
public ResponseEntity<User> createUser(@RequestBody User user) {
User createdUser = userService.create(user);
return ResponseEntity.ok(createdUser);
}
}
复杂度评估：中等
使用模板：api15.3 代码审查与优化建议
代码审查是保证代码质量的重要环节，一个智能的代码审查系统能够发现潜在问题、提供优化建议，并确保代码遵循最佳实践。这不仅能提高代码质量，还能帮助开发者学习和改进编程技能
java
▼java复制代码
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.community.model.dashscope.QwenChatModel;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.regex.Pattern;
/**
* 代码小抄代码审查与优化建议服务
* 提供全面的代码质量分析和改进建议
*/
@Service
public class CodeReviewService {
private final ChatModel chatModel;
private final Map<String, List<CodeRule>> languageRules;
public CodeReviewService() {
this.chatModel = QwenChatModel.builder()
.apiKey("sk-xxxxx")
.modelName("qwen-max")
.temperature(0.2f) // 低温度确保审查建议的准确性
.build();
this.languageRules = initializeCodeRules();
}
/**
* 全面的代码审查
*/
public CodeReviewResult reviewCode(String code, String language, ReviewOptions options) {
List<CodeIssue> issues = new ArrayList<>();
List<OptimizationSuggestion> suggestions = new ArrayList<>();
// 静态分析检查
issues.addAll(performStaticAnalysis(code, language));
// 最佳实践检查
issues.addAll(checkBestPractices(code, language));
// 性能分析
suggestions.addAll(analyzePerformance(code, language));
// 安全性检查
issues.addAll(checkSecurity(code, language));
// AI 驱动的深度分析
if (options.useAI) {
AIReviewResult aiResult = performAIReview(code, language, options);
issues.addAll(aiResult.issues);
suggestions.addAll(aiResult.suggestions);
}
// 生成改进的代码版本
String improvedCode = generateImprovedCode(code, issues, suggestions, language);
// 计算总体评分
CodeQualityScore score = calculateQualityScore(issues, suggestions, code);
return new CodeReviewResult(issues, suggestions, improvedCode, score);
}
/**
* 静态分析检查
*/
private List<CodeIssue> performStaticAnalysis(String code, String language) {
List<CodeIssue> issues = new ArrayList<>();
List<CodeRule> rules = languageRules.getOrDefault(language.toLowerCase(), new ArrayList<>());
for (CodeRule rule : rules) {
if (rule.pattern.matcher(code).find()) {
issues.add(new CodeIssue(
rule.name,
rule.description,
rule.severity,
rule.category,
rule.suggestion
));
}
}
return issues;
}
/**
* 最佳实践检查
*/
private List<CodeIssue> checkBestPractices(String code, String language) {
List<CodeIssue> issues = new ArrayList<>();
switch (language.toLowerCase()) {
case "java" -> issues.addAll(checkJavaBestPractices(code));
case "python" -> issues.addAll(checkPythonBestPractices(code));
case "javascript" -> issues.addAll(checkJavaScriptBestPractices(code));
}
return issues;
}
/**
* Java 最佳实践检查
*/
private List<CodeIssue> checkJavaBestPractices(String code) {
List<CodeIssue> issues = new ArrayList<>();
// 检查异常处理
if (code.contains("Exception") && !code.contains("try")) {
issues.add(new CodeIssue(
"missing_exception_handling",
"方法可能抛出异常但缺少异常处理",
IssueSeverity.MEDIUM,
IssueCategory.BEST_PRACTICE,
"添加 try-catch 块或在方法签名中声明异常"
));
}
// 检查空指针检查
if (code.contains(".") && !code.contains("null")) {
long dotCount = code.chars().filter(ch -> ch == '.').count();
if (dotCount > 3) {
issues.add(new CodeIssue(
"potential_null_pointer",
"存在潜在的空指针异常风险",
IssueSeverity.HIGH,
IssueCategory.BUG_RISK,
"添加空值检查或使用 Optional"
));
}
}
// 检查资源管理
if (code.contains("new FileInputStream") || code.contains("new Connection")) {
if (!code.contains("try-with-resources") && !code.contains("finally")) {
issues.add(new CodeIssue(
"resource_leak",
"资源可能未正确关闭",
IssueSeverity.HIGH,
IssueCategory.RESOURCE_MANAGEMENT,
"使用 try-with-resources 语句或在 finally 块中关闭资源"
));
}
}
return issues;
}
/**
* Python 最佳实践检查
*/
private List<CodeIssue> checkPythonBestPractices(String code) {
List<CodeIssue> issues = new ArrayList<>();
// 检查全局变量使用
if (code.contains("global ")) {
issues.add(new CodeIssue(
"global_variable_usage",
"使用了全局变量",
IssueSeverity.MEDIUM,
IssueCategory.BEST_PRACTICE,
"尽量避免使用全局变量，考虑使用类或函数参数"
));
}
// 检查异常处理
if (code.contains("except:") && !code.contains("except Exception")) {
issues.add(new CodeIssue(
"bare_except",
"使用了裸露的 except 语句",
IssueSeverity.MEDIUM,
IssueCategory.BEST_PRACTICE,
"指定具体的异常类型或使用 'except Exception:'"
));
}
return issues;
}
/**
* JavaScript 最佳实践检查
*/
private List<CodeIssue> checkJavaScriptBestPractices(String code) {
List<CodeIssue> issues = new ArrayList<>();
// 检查变量声明
if (code.contains("var ")) {
issues.add(new CodeIssue(
"var_usage",
"使用了 var 关键字",
IssueSeverity.LOW,
IssueCategory.BEST_PRACTICE,
"使用 let 或 const 替代 var"
));
}
// 检查严格模式
if (!code.contains("'use strict'") && !code.contains("\"use strict\"")) {
issues.add(new CodeIssue(
"no_strict_mode",
"未使用严格模式",
IssueSeverity.LOW,
IssueCategory.BEST_PRACTICE,
"在代码开头添加 'use strict';"
));
}
return issues;
}
/**
* 性能分析
*/
private List<OptimizationSuggestion> analyzePerformance(String code, String language) {
List<OptimizationSuggestion> suggestions = new ArrayList<>();
// 循环优化检查
if (code.contains("for") && code.contains(".size()")) {
suggestions.add(new OptimizationSuggestion(
"loop_optimization",
"循环中重复调用 size() 方法",
"将集合大小缓存到变量中",
OptimizationImpact.MEDIUM,
"int size = list.size(); for(int i = 0; i < size; i++)"
));
}
// 字符串拼接优化
if (code.contains("String") && code.contains("+") && code.contains("for")) {
suggestions.add(new OptimizationSuggestion(
"string_concatenation",
"在循环中使用字符串拼接",
"使用 StringBuilder 提高性能",
OptimizationImpact.HIGH,
"StringBuilder sb = new StringBuilder(); sb.append(...);"
));
}
// 集合初始化优化
if (code.contains("new ArrayList()") && !code.contains("ArrayList(")) {
suggestions.add(new OptimizationSuggestion(
"collection_capacity",
"集合未指定初始容量",
"预设集合容量避免频繁扩容",
OptimizationImpact.LOW,
"new ArrayList<>(expectedSize)"
));
}
return suggestions;
}
/**
* 安全性检查
*/
private List<CodeIssue> checkSecurity(String code, String language) {
List<CodeIssue> issues = new ArrayList<>();
// SQL 注入检查
if (code.contains("SELECT") && code.contains("+")) {
issues.add(new CodeIssue(
"sql_injection_risk",
"可能存在 SQL 注入风险",
IssueSeverity.CRITICAL,
IssueCategory.SECURITY,
"使用参数化查询或预编译语句"
));
}
// 硬编码密码检查
if (code.matches(".*password\\s*=\\s*[\"'][^\"']+[\"'].*")) {
issues.add(new CodeIssue(
"hardcoded_password",
"硬编码密码",
IssueSeverity.CRITICAL,
IssueCategory.SECURITY,
"将密码存储在环境变量或配置文件中"
));
}
// 输入验证检查
if (code.contains("request.getParameter") && !code.contains("validate")) {
issues.add(new CodeIssue(
"input_validation",
"缺少输入验证",
IssueSeverity.HIGH,
IssueCategory.SECURITY,
"添加输入验证和清理逻辑"
));
}
return issues;
}
/**
* AI 驱动的深度分析
*/
private AIReviewResult performAIReview(String code, String language, ReviewOptions options) {
String reviewPrompt = String.format("""
请对以下 %s 代码进行深度审查，关注代码质量、性能和最佳实践：
```%s
%s
```
请按以下格式提供审查结果：
[问题]
- 问题类型: [性能/安全/可读性/维护性]
- 严重程度: [高/中/低]
- 描述: [具体问题描述]
- 建议: [改进建议]
[优化建议]
- 优化点: [具体优化内容]
- 预期效果: [性能提升/代码简化等]
- 实现方式: [具体实现建议]
请重点关注：
1. 代码结构和组织
2. 命名规范和可读性
3. 潜在的性能问题
4. 错误处理机制
5. 代码重用和模块化
""", language, language, code);
String aiResponse = chatModel.chat(reviewPrompt);
return parseAIReviewResult(aiResponse);
}
/**
* 解析 AI 审查结果
*/
private AIReviewResult parseAIReviewResult(String aiResponse) {
List<CodeIssue> issues = new ArrayList<>();
List<OptimizationSuggestion> suggestions = new ArrayList<>();
String[] sections = aiResponse.split("\\[优化建议\\]");
if (sections.length > 0) {
// 解析问题部分
String issuesSection = sections[0];
String[] issueBlocks = issuesSection.split("- 问题类型:");
for (int i = 1; i < issueBlocks.length; i++) {
String block = issueBlocks[i];
String type = extractValue(block, "问题类型:", "严重程度:");
String severity = extractValue(block, "严重程度:", "描述:");
String description = extractValue(block, "描述:", "建议:");
String suggestion = extractValue(block, "建议:", null);
if (type != null && severity != null && description != null) {
issues.add(new CodeIssue(
"ai_detected_" + type.toLowerCase(),
description,
parseSeverity(severity),
parseCategory(type),
suggestion
));
}
}
}
if (sections.length > 1) {
// 解析优化建议部分
String suggestionsSection = sections[1];
String[] suggestionBlocks = suggestionsSection.split("- 优化点:");
for (int i = 1; i < suggestionBlocks.length; i++) {
String block = suggestionBlocks[i];
String optimization = extractValue(block, "优化点:", "预期效果:");
String effect = extractValue(block, "预期效果:", "实现方式:");
String implementation = extractValue(block, "实现方式:", null);
if (optimization != null && effect != null) {
suggestions.add(new OptimizationSuggestion(
"ai_suggestion_" + optimization.hashCode(),
optimization,
implementation,
OptimizationImpact.MEDIUM,
implementation
));
}
}
}
return new AIReviewResult(issues, suggestions);
}
/**
* 生成改进的代码版本
*/
private String generateImprovedCode(String originalCode, List<CodeIssue> issues,
List<OptimizationSuggestion> suggestions, String language) {
String improvePrompt = String.format("""
请根据以下代码审查结果，生成改进后的代码：
原始代码：
```%s
%s
```
发现的主要问题：
%s
优化建议：
%s
请生成改进后的代码，确保：
1. 修复所有高严重程度的问题
2. 应用性能优化建议
3. 保持原有功能不变
4. 添加必要的注释说明改进之处
请只返回改进后的代码：
""", language, originalCode,
formatIssuesForPrompt(issues),
formatSuggestionsForPrompt(suggestions));
return chatModel.chat(improvePrompt);
}
/**
* 计算代码质量评分
*/
private CodeQualityScore calculateQualityScore(List<CodeIssue> issues,
List<OptimizationSuggestion> suggestions,
String code) {
int baseScore = 100;
// 根据问题严重程度扣分
for (CodeIssue issue : issues) {
switch (issue.severity) {
case CRITICAL -> baseScore -= 15;
case HIGH -> baseScore -= 10;
case MEDIUM -> baseScore -= 5;
case LOW -> baseScore -= 2;
}
}
// 根据优化建议数量调整
baseScore -= Math.min(suggestions.size() * 2, 20);
// 基于代码长度和复杂度的奖励
int lines = code.split("\n").length;
if (lines > 50 && issues.size() < 3) {
baseScore += 5; // 较长代码但问题少，给予奖励
}
baseScore = Math.max(0, Math.min(100, baseScore));
String grade = baseScore >= 90 ? "A" :
baseScore >= 80 ? "B" :
baseScore >= 70 ? "C" :
baseScore >= 60 ? "D" : "F";
return new CodeQualityScore(baseScore, grade, issues.size(), suggestions.size());
}
// 辅助方法
private String extractValue(String text, String startMarker, String endMarker) {
int start = text.indexOf(startMarker);
if (start == -1) return null;
start += startMarker.length();
int end = endMarker != null ? text.indexOf(endMarker, start) : text.length();
if (end == -1) end = text.length();
return text.substring(start, end).trim();
}
private IssueSeverity parseSeverity(String severity) {
return switch (severity.toLowerCase()) {
case "高", "critical" -> IssueSeverity.CRITICAL;
case "中", "medium" -> IssueSeverity.MEDIUM;
case "低", "low" -> IssueSeverity.LOW;
default -> IssueSeverity.MEDIUM;
};
}
private IssueCategory parseCategory(String type) {
return switch (type.toLowerCase()) {
case "性能" -> IssueCategory.PERFORMANCE;
case "安全" -> IssueCategory.SECURITY;
case "可读性" -> IssueCategory.READABILITY;
case "维护性" -> IssueCategory.MAINTAINABILITY;
default -> IssueCategory.BEST_PRACTICE;
};
}
private String formatIssuesForPrompt(List<CodeIssue> issues) {
StringBuilder sb = new StringBuilder();
for (CodeIssue issue : issues) {
sb.append("- ").append(issue.description)
.append(" (").append(issue.severity).append(")\n");
}
return sb.toString();
}
private String formatSuggestionsForPrompt(List<OptimizationSuggestion> suggestions) {
StringBuilder sb = new StringBuilder();
for (OptimizationSuggestion suggestion : suggestions) {
sb.append("- ").append(suggestion.description).append("\n");
}
return sb.toString();
}
/**
* 初始化代码规则
*/
private Map<String, List<CodeRule>> initializeCodeRules() {
Map<String, List<CodeRule>> rules = new HashMap<>();
// Java 规则
List<CodeRule> javaRules = new ArrayList<>();
javaRules.add(new CodeRule(
"unused_import",
Pattern.compile("import\\s+[^;]+;"),
"可能存在未使用的导入",
IssueSeverity.LOW,
IssueCategory.CODE_SMELL,
"移除未使用的导入语句"
));
javaRules.add(new CodeRule(
"magic_number",
Pattern.compile("\\b\\d{2,}\\b"),
"存在魔法数字",
IssueSeverity.MEDIUM,
IssueCategory.READABILITY,
"将数字提取为有意义的常量"
));
rules.put("java", javaRules);
// Python 规则
List<CodeRule> pythonRules = new ArrayList<>();
pythonRules.add(new CodeRule(
"long_line",
Pattern.compile(".{80,}"),
"代码行过长",
IssueSeverity.LOW,
IssueCategory.READABILITY,
"将长行分解为多行"
));
rules.put("python", pythonRules);
return rules;
}
/**
* 演示代码审查功能
*/
public void demonstrateCodeReview() {
System.out.println("=== 编程导航代码审查演示 ===");
String problematicCode = """
import java.util.*;
import java.sql.*;
public class UserManager {
public List<User> getUsers(String name) {
List<User> users = new ArrayList<>();
String sql = "SELECT * FROM users WHERE name = '" + name + "'";
Connection conn = null;
Statement stmt = null;
try {
conn = DriverManager.getConnection("jdbc:mysql://localhost/db", "root", "123456");
stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql);
while(rs.next()) {
User user = new User();
user.setName(rs.getString("name"));
users.add(user);
}
} catch(Exception e) {
e.printStackTrace();
}
return users;
}
}
""";
ReviewOptions options = new ReviewOptions.Builder()
.useAI(true)
.checkSecurity(true)
.checkPerformance(true)
.checkBestPractices(true)
.build();
CodeReviewResult result = reviewCode(problematicCode, "java", options);
System.out.println("发现的问题 (" + result.issues.size() + " 个):");
for (CodeIssue issue : result.issues) {
System.out.printf(" [%s] %s - %s%n",
issue.severity, issue.description, issue.suggestion);
}
System.out.println("\n优化建议 (" + result.suggestions.size() + " 个):");
for (OptimizationSuggestion suggestion : result.suggestions) {
System.out.printf(" [%s] %s%n",
suggestion.impact, suggestion.description);
}
System.out.println("\n代码质量评分:");
System.out.printf(" 分数: %d/100 (等级: %s)%n",
result.qualityScore.score, result.qualityScore.grade);
System.out.printf(" 问题数量: %d, 优化建议: %d%n",
result.qualityScore.issueCount, result.qualityScore.suggestionCount);
}
// 内部数据类定义
public static class CodeReviewResult {
public final List<CodeIssue> issues;
public final List<OptimizationSuggestion> suggestions;
public final String improvedCode;
public final CodeQualityScore qualityScore;
public CodeReviewResult(List<CodeIssue> issues, List<OptimizationSuggestion> suggestions,
String improvedCode, CodeQualityScore qualityScore) {
this.issues = issues;
this.suggestions = suggestions;
this.improvedCode = improvedCode;
this.qualityScore = qualityScore;
}
}
public static class CodeIssue {
public final String id;
public final String description;
public final IssueSeverity severity;
public final IssueCategory category;
public final String suggestion;
public CodeIssue(String id, String description, IssueSeverity severity,
IssueCategory category, String suggestion) {
this.id = id;
this.description = description;
this.severity = severity;
this.category = category;
this.suggestion = suggestion;
}
}
public static class OptimizationSuggestion {
public final String id;
public final String description;
public final String reason;
public final OptimizationImpact impact;
public final String example;
public OptimizationSuggestion(String id, String description, String reason,
OptimizationImpact impact, String example) {
this.id = id;
this.description = description;
this.reason = reason;
this.impact = impact;
this.example = example;
}
}
public static class CodeQualityScore {
public final int score;
public final String grade;
public final int issueCount;
public final int suggestionCount;
public CodeQualityScore(int score, String grade, int issueCount, int suggestionCount) {
this.score = score;
this.grade = grade;
this.issueCount = issueCount;
this.suggestionCount = suggestionCount;
}
}
// 其他内部类定义
public static class ReviewOptions {
public final boolean useAI;
public final boolean checkSecurity;
public final boolean checkPerformance;
public final boolean checkBestPractices;
private ReviewOptions(Builder builder) {
this.useAI = builder.useAI;
this.checkSecurity = builder.checkSecurity;
this.checkPerformance = builder.checkPerformance;
this.checkBestPractices = builder.checkBestPractices;
}
public static class Builder {
private boolean useAI = true;
private boolean checkSecurity = true;
private boolean checkPerformance = true;
private boolean checkBestPractices = true;
public Builder useAI(boolean use) { this.useAI = use; return this; }
public Builder checkSecurity(boolean check) { this.checkSecurity = check; return this; }
public Builder checkPerformance(boolean check) { this.checkPerformance = check; return this; }
public Builder checkBestPractices(boolean check) { this.checkBestPractices = check; return this; }
public ReviewOptions build() { return new ReviewOptions(this); }
}
}
private static class AIReviewResult {
public final List<CodeIssue> issues;
public final List<OptimizationSuggestion> suggestions;
public AIReviewResult(List<CodeIssue> issues, List<OptimizationSuggestion> suggestions) {
this.issues = issues;
this.suggestions = suggestions;
}
}
private static class CodeRule {
public final String name;
public final Pattern pattern;
public final String description;
public final IssueSeverity severity;
public final IssueCategory category;
public final String suggestion;
public CodeRule(String name, Pattern pattern, String description,
IssueSeverity severity, IssueCategory category, String suggestion) {
this.name = name;
this.pattern = pattern;
this.description = description;
this.severity = severity;
this.category = category;
this.suggestion = suggestion;
}
}
public enum IssueSeverity { CRITICAL, HIGH, MEDIUM, LOW }
public enum IssueCategory { SECURITY, PERFORMANCE, BUG_RISK, BEST_PRACTICE, READABILITY, MAINTAINABILITY, RESOURCE_MANAGEMENT, CODE_SMELL }
public enum OptimizationImpact { HIGH, MEDIUM, LOW }
}这段程序输出结果：
plain
▼plain复制代码=== 编程导航代码审查演示 ===
发现的问题 (6 个):
[CRITICAL] 可能存在 SQL 注入风险 - 使用参数化查询或预编译语句
[CRITICAL] 硬编码密码 - 将密码存储在环境变量或配置文件中
[HIGH] 资源可能未正确关闭 - 使用 try-with-resources 语句或在 finally 块中关闭资源
[MEDIUM] 存在魔法数字 - 将数字提取为有意义的常量
[LOW] 可能存在未使用的导入 - 移除未使用的导入语句
[LOW] 代码行过长 - 将长行分解为多行
优化建议 (2 个):
[MEDIUM] 使用 PreparedStatement 替代 Statement
[LOW] 添加连接池提高数据库连接效率
代码质量评分:
分数: 45/100 (等级: F)
问题数量: 6, 优化建议: 215.4 多语言支持
现代开发环境中，多语言支持是代码生成助手的必备功能。不同编程语言有着各自的语法特点、编程范式和最佳实践，一个优秀的代码助手需要能够理解和处理多种编程语言的特殊性。
java
▼java复制代码
import dev.langchain4j.community.model.dashscope.QwenChatModel;
import dev.langchain4j.model.chat.ChatModel;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* 算法导航多语言代码支持服务
* 支持多种编程语言的代码生成、转换和分析
*/
@Service
public class MultiLanguageCodeService {
private final ChatModel chatModel;
private final Map<String, LanguageProfile> languageProfiles;
public MultiLanguageCodeService() {
this.chatModel = QwenChatModel.builder()
.apiKey("sk-xxxxx")
.modelName("qwen-max")
.temperature(0.3f)
.build();
this.languageProfiles = initializeLanguageProfiles();
}
/**
* 代码语言间转换
*/
public CodeTranslationResult translateCode(String sourceCode, String sourceLanguage,
String targetLanguage, TranslationOptions options) {
// 分析源代码结构
CodeStructure structure = analyzeCodeStructure(sourceCode, sourceLanguage);
// 执行语言转换
String translatedCode = performTranslation(sourceCode, sourceLanguage, targetLanguage, structure, options);
// 适应目标语言特性
String adaptedCode = adaptToTargetLanguage(translatedCode, targetLanguage, options);
// 生成转换说明
String explanation = generateTranslationExplanation(sourceCode, translatedCode, sourceLanguage, targetLanguage);
return new CodeTranslationResult(adaptedCode, explanation, structure, getTranslationQuality(sourceCode, adaptedCode));
}
/**
* 分析代码结构
*/
private CodeStructure analyzeCodeStructure(String code, String language) {
List<String> functions = new ArrayList<>();
List<String> classes = new ArrayList<>();
List<String> variables = new ArrayList<>();
List<String> imports = new ArrayList<>();
Map<String, String> patterns = new HashMap<>();
LanguageProfile profile = languageProfiles.get(language.toLowerCase());
if (profile != null) {
// 提取函数
functions = extractMatches(code, profile.functionPattern);
// 提取类
classes = extractMatches(code, profile.classPattern);
// 提取变量
variables = extractMatches(code, profile.variablePattern);
// 提取导入
imports = extractMatches(code, profile.importPattern);
// 识别特殊模式
patterns.putAll(identifyLanguagePatterns(code, profile));
}
return new CodeStructure(functions, classes, variables, imports, patterns);
}
/**
* 执行代码转换
*/
private String performTranslation(String sourceCode, String sourceLanguage, String targetLanguage,
CodeStructure structure, TranslationOptions options) {
String translationPrompt = buildTranslationPrompt(sourceCode, sourceLanguage, targetLanguage, structure, options);
return chatModel.chat(translationPrompt);
}
/**
* 构建转换提示词
*/
private String buildTranslationPrompt(String sourceCode, String sourceLanguage, String targetLanguage,
CodeStructure structure, TranslationOptions options) {
StringBuilder prompt = new StringBuilder();
prompt.append("请将以下 ").append(sourceLanguage).append(" 代码转换为 ").append(targetLanguage).append(" 代码：\n\n");
prompt.append("源代码：\n```").append(sourceLanguage).append("\n").append(sourceCode).append("\n```\n\n");
prompt.append("转换要求：\n");
prompt.append("1. 保持原有功能逻辑不变\n");
prompt.append("2. 遵循 ").append(targetLanguage).append(" 的命名规范和代码风格\n");
prompt.append("3. 使用 ").append(targetLanguage).append(" 的惯用法和最佳实践\n");
prompt.append("4. 添加适当的类型注解（如果目标语言支持）\n");
if (options.preserveComments) {
prompt.append("5. 保留并翻译注释内容\n");
}
if (options.optimizeForTarget) {
prompt.append("6. 针对目标语言特性进行优化\n");
}
// 添加语言特定的转换指导
LanguageProfile targetProfile = languageProfiles.get(targetLanguage.toLowerCase());
if (targetProfile != null && !targetProfile.conversionGuides.isEmpty()) {
prompt.append("\n").append(targetLanguage).append(" 转换指导：\n");
targetProfile.conversionGuides.forEach((key, value) ->
prompt.append("- ").append(key).append(": ").append(value).append("\n"));
}
prompt.append("\n请只返回转换后的代码，不需要额外说明：");
return prompt.toString();
}
/**
* 适应目标语言特性
*/
private String adaptToTargetLanguage(String translatedCode, String targetLanguage, TranslationOptions options) {
LanguageProfile profile = languageProfiles.get(targetLanguage.toLowerCase());
if (profile == null) return translatedCode;
String adaptedCode = translatedCode;
// 应用语言特定的后处理规则
for (Map.Entry<String, String> rule : profile.postProcessingRules.entrySet()) {
adaptedCode = adaptedCode.replaceAll(rule.getKey(), rule.getValue());
}
// 添加必要的导入
adaptedCode = addRequiredImports(adaptedCode, targetLanguage);
// 调整代码格式
adaptedCode = formatCodeForLanguage(adaptedCode, targetLanguage);
return adaptedCode;
}
/**
* 生成转换说明
*/
private String generateTranslationExplanation(String sourceCode, String translatedCode,
String sourceLanguage, String targetLanguage) {
String explanationPrompt = String.format("""
请解释以下代码转换过程中的主要变化：
源语言：%s
目标语言：%s
源代码：
```%s
%s
```
转换后代码：
```%s
%s
```
请说明：
1. 语法转换的主要变化
2. 数据类型的对应关系
3. 特有特性的处理方式
4. 需要注意的差异点
请保持解释简洁明了。
""", sourceLanguage, targetLanguage, sourceLanguage, sourceCode, targetLanguage, translatedCode);
return chatModel.chat(explanationPrompt);
}
/**
* 语言间等价性检查
*/
public EquivalenceCheckResult checkCodeEquivalence(String code1, String language1,
String code2, String language2) {
String checkPrompt = String.format("""
请比较以下两段不同语言的代码是否实现了相同的功能：
代码1 (%s)：
```%s
%s
```
代码2 (%s)：
```%s
%s
```
请分析：
1. 功能是否等价
2. 主要差异点
3. 性能对比
4. 可维护性比较
请按以下格式回答：
等价性: [是/否/部分]
相似度: [0-100分]
主要差异: [差异描述]
""", language1, language1, code1, language2, language2, code2);
String aiResponse = chatModel.chat(checkPrompt);
return parseEquivalenceResult(aiResponse);
}
/**
* 跨语言代码片段搜索
*/
public List<CrossLanguageMatch> searchAcrossLanguages(String query, List<String> targetLanguages) {
List<CrossLanguageMatch> matches = new ArrayList<>();
for (String language : targetLanguages) {
String searchPrompt = String.format("""
请为以下需求生成 %s 代码片段：
需求：%s
要求：
1. 代码简洁高效
2. 遵循 %s 最佳实践
3. 包含必要注释
4. 适合作为示例使用
请只返回代码：
""", language, query, language);
String codeSnippet = chatModel.chat(searchPrompt);
double relevanceScore = calculateRelevanceScore(query, codeSnippet);
matches.add(new CrossLanguageMatch(language, codeSnippet, relevanceScore,
getComplexityLevel(codeSnippet)));
}
// 按相关性排序
matches.sort((a, b) -> Double.compare(b.relevanceScore, a.relevanceScore));
return matches;
}
/**
* 语言特性对比分析
*/
public LanguageComparisonResult compareLanguageFeatures(List<String> languages, String featureType) {
String comparisonPrompt = String.format("""
请比较以下编程语言在 %s 方面的特性：
语言列表：%s
请按以下格式分析：
语言: [语言名称]
特性描述: [该语言在此方面的特性]
优势: [主要优势]
劣势: [主要劣势]
适用场景: [最适合的使用场景]
最后请给出总结性的对比建议。
""", featureType, String.join(", ", languages));
String aiResponse = chatModel.chat(comparisonPrompt);
return parseComparisonResult(aiResponse, languages, featureType);
}
// 辅助方法实现
private List<String> extractMatches(String code, String pattern) {
if (pattern == null || pattern.isEmpty()) return new ArrayList<>();
List<String> matches = new ArrayList<>();
java.util.regex.Pattern p = java.util.regex.Pattern.compile(pattern);
java.util.regex.Matcher m = p.matcher(code);
while (m.find()) {
matches.add(m.group(1));
}
return matches;
}
private Map<String, String> identifyLanguagePatterns(String code, LanguageProfile profile) {
Map<String, String> patterns = new HashMap<>();
for (Map.Entry<String, String> entry : profile.specialPatterns.entrySet()) {
if (code.contains(entry.getKey())) {
patterns.put(entry.getKey(), entry.getValue());
}
}
return patterns;
}
private String addRequiredImports(String code, String language) {
Set<String> imports = new HashSet<>();
LanguageProfile profile = languageProfiles.get(language.toLowerCase());
if (profile != null) {
for (Map.Entry<String, String> entry : profile.commonImports.entrySet()) {
if (code.contains(entry.getKey()) && !code.contains(entry.getValue())) {
imports.add(entry.getValue());
}
}
}
if (!imports.isEmpty()) {
String importSection = String.join("\n", imports);
return importSection + "\n\n" + code;
}
return code;
}
private String formatCodeForLanguage(String code, String language) {
switch (language.toLowerCase()) {
case "python" -> {
// Python 格式调整
return code.replaceAll("\\{", ":")
.replaceAll("\\}", "")
.replaceAll(";", "");
}
case "javascript" -> {
// JavaScript 格式调整
return code.replaceAll("\\bfunction\\s+(\\w+)\\s*\\(", "function $1(");
}
case "go" -> {
// Go 格式调整
return code.replaceAll("\\bfunc\\s+(\\w+)\\s*\\(", "func $1(");
}
}
return code;
}
private double calculateRelevanceScore(String query, String code) {
// 简单的相关性计算
String[] queryWords = query.toLowerCase().split("\\s+");
String lowerCode = code.toLowerCase();
int matches = 0;
for (String word : queryWords) {
if (lowerCode.contains(word)) {
matches++;
}
}
return (double) matches / queryWords.length;
}
private String getComplexityLevel(String code) {
int lines = code.split("\n").length;
int complexity = code.split("\\bif\\b|\\bfor\\b|\\bwhile\\b").length - 1;
if (lines < 10 && complexity < 3) return "简单";
if (lines < 30 && complexity < 8) return "中等";
return "复杂";
}
private double getTranslationQuality(String sourceCode, String translatedCode) {
// 基于代码行数和结构相似性的简单质量评估
int sourceLines = sourceCode.split("\n").length;
int translatedLines = translatedCode.split("\n").length;
double lengthSimilarity = 1.0 - Math.abs(sourceLines - translatedLines) / (double) Math.max(sourceLines, translatedLines);
// 基于关键词匹配的结构相似性
Set<String> sourceKeywords = extractKeywords(sourceCode);
Set<String> translatedKeywords = extractKeywords(translatedCode);
Set<String> intersection = new HashSet<>(sourceKeywords);
intersection.retainAll(translatedKeywords);
double keywordSimilarity = sourceKeywords.isEmpty() ? 1.0 :
(double) intersection.size() / sourceKeywords.size();
return (lengthSimilarity * 0.3 + keywordSimilarity * 0.7) * 100;
}
private Set<String> extractKeywords(String code) {
Set<String> keywords = new HashSet<>();
String[] words = code.split("\\W+");
for (String word : words) {
if (word.length() > 2 && !word.matches("\\d+")) {
keywords.add(word.toLowerCase());
}
}
return keywords;
}
private EquivalenceCheckResult parseEquivalenceResult(String aiResponse) {
String equivalence = "未知";
int similarity = 0;
String differences = "无法分析";
String[] lines = aiResponse.split("\n");
for (String line : lines) {
if (line.contains("等价性:")) {
equivalence = line.substring(line.indexOf(":") + 1).trim();
} else if (line.contains("相似度:")) {
String simStr = line.substring(line.indexOf(":") + 1).trim().replaceAll("[^0-9]", "");
if (!simStr.isEmpty()) {
similarity = Integer.parseInt(simStr);
}
} else if (line.contains("主要差异:")) {
differences = line.substring(line.indexOf(":") + 1).trim();
}
}
return new EquivalenceCheckResult(equivalence, similarity, differences);
}
private LanguageComparisonResult parseComparisonResult(String aiResponse, List<String> languages, String featureType) {
Map<String, LanguageFeatureAnalysis> analyses = new HashMap<>();
String summary = "暂无总结";
String[] sections = aiResponse.split("语言:");
for (int i = 1; i < sections.length; i++) {
String section = sections[i];
String language = extractValue(section, "", "特性描述:");
String features = extractValue(section, "特性描述:", "优势:");
String advantages = extractValue(section, "优势:", "劣势:");
String disadvantages = extractValue(section, "劣势:", "适用场景:");
String useCases = extractValue(section, "适用场景:", null);
if (language != null) {
analyses.put(language.trim(), new LanguageFeatureAnalysis(
features, advantages, disadvantages, useCases));
}
}
// 提取总结
if (aiResponse.contains("总结") || aiResponse.contains("建议")) {
int summaryStart = Math.max(aiResponse.lastIndexOf("总结"), aiResponse.lastIndexOf("建议"));
if (summaryStart != -1) {
summary = aiResponse.substring(summaryStart);
}
}
return new LanguageComparisonResult(featureType, analyses, summary);
}
private String extractValue(String text, String startMarker, String endMarker) {
int start = startMarker.isEmpty() ? 0 : text.indexOf(startMarker);
if (start == -1) return null;
if (!startMarker.isEmpty()) {
start += startMarker.length();
}
int end = endMarker != null ? text.indexOf(endMarker, start) : text.length();
if (end == -1) end = text.length();
return text.substring(start, end).trim();
}
/**
* 初始化语言配置
*/
private Map<String, LanguageProfile> initializeLanguageProfiles() {
Map<String, LanguageProfile> profiles = new HashMap<>();
// Java 配置
LanguageProfile javaProfile = new LanguageProfile("Java");
javaProfile.functionPattern = "(?:public|private|protected)?\\s*(?:static)?\\s*\\w+\\s+(\\w+)\\s*\\(";
javaProfile.classPattern = "(?:public|private)?\\s*class\\s+(\\w+)";
javaProfile.variablePattern = "(?:private|public|protected)?\\s*(?:static)?\\s*\\w+\\s+(\\w+)\\s*[=;]";
javaProfile.importPattern = "import\\s+([^;]+);";
javaProfile.specialPatterns.put("@Override", "方法重写注解");
javaProfile.specialPatterns.put("implements", "接口实现");
javaProfile.specialPatterns.put("extends", "类继承");
javaProfile.commonImports.put("List", "import java.util.List;");
javaProfile.commonImports.put("ArrayList", "import java.util.ArrayList;");
javaProfile.commonImports.put("HashMap", "import java.util.HashMap;");
javaProfile.conversionGuides.put("异常处理", "使用 try-catch-finally 或 try-with-resources");
javaProfile.conversionGuides.put("空值检查", "考虑使用 Optional 或空值检查");
javaProfile.conversionGuides.put("集合操作", "使用 Stream API 进行函数式编程");
javaProfile.postProcessingRules.put("def (\\w+)\\(", "public void $1(");
javaProfile.postProcessingRules.put(":\\s*$", " {");
profiles.put("java", javaProfile);
// Python 配置
LanguageProfile pythonProfile = new LanguageProfile("Python");
pythonProfile.functionPattern = "def\\s+(\\w+)\\s*\\(";
pythonProfile.classPattern = "class\\s+(\\w+)";
pythonProfile.variablePattern = "^\\s*(\\w+)\\s*=";
pythonProfile.importPattern = "(?:import\\s+([^\\n]+)|from\\s+([^\\s]+)\\s+import)";
pythonProfile.specialPatterns.put("self", "实例方法参数");
pythonProfile.specialPatterns.put("__init__", "构造方法");
pythonProfile.specialPatterns.put("lambda", "匿名函数");
pythonProfile.conversionGuides.put("缩进", "使用 4 个空格缩进");
pythonProfile.conversionGuides.put("命名", "使用 snake_case 命名");
pythonProfile.conversionGuides.put("异常处理", "使用 try-except-finally");
profiles.put("python", pythonProfile);
// JavaScript 配置
LanguageProfile jsProfile = new LanguageProfile("JavaScript");
jsProfile.functionPattern = "function\\s+(\\w+)\\s*\\(|const\\s+(\\w+)\\s*=\\s*\\(";
jsProfile.classPattern = "class\\s+(\\w+)";
jsProfile.variablePattern = "(?:var|let|const)\\s+(\\w+)";
jsProfile.importPattern = "import\\s+[^'\"]*['\"]([^'\"]+)['\"]|require\\s*\\(\\s*['\"]([^'\"]+)['\"]\\)";
jsProfile.specialPatterns.put("=>", "箭头函数");
jsProfile.specialPatterns.put("async", "异步函数");
jsProfile.specialPatterns.put("await", "异步等待");
jsProfile.conversionGuides.put("变量声明", "优先使用 const 和 let");
jsProfile.conversionGuides.put("异步处理", "使用 async/await 或 Promise");
jsProfile.conversionGuides.put("模块化", "使用 ES6 模块语法");
profiles.put("javascript", jsProfile);
return profiles;
}
/**
* 演示多语言支持功能
*/
public void demonstrateMultiLanguageSupport() {
System.out.println("=== 面试鸭多语言代码支持演示 ===");
// 演示代码转换
String javaCode = """
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double divide(double a, double b) {
if (b == 0) {
throw new IllegalArgumentException("Division by zero");
}
return a / b;
}
}
""";
System.out.println("原始 Java 代码：");
System.out.println(javaCode);
// 转换为 Python
TranslationOptions options = new TranslationOptions.Builder()
.preserveComments(true)
.optimizeForTarget(true)
.build();
CodeTranslationResult pythonResult = translateCode(javaCode, "java", "python", options);
System.out.println("\n转换为 Python：");
System.out.println(pythonResult.translatedCode);
System.out.println("\n转换质量：" + pythonResult.quality + "%");
// 演示跨语言搜索
System.out.println("\n=== 跨语言代码搜索演示 ===");
String query = "实现快速排序算法";
List<String> languages = Arrays.asList("java", "python", "javascript");
List<CrossLanguageMatch> matches = searchAcrossLanguages(query, languages);
for (CrossLanguageMatch match : matches) {
System.out.println("\n" + match.language.toUpperCase() + " 版本 (相关性: " +
String.format("%.2f", match.relevanceScore) + "):");
System.out.println(match.codeSnippet.substring(0, Math.min(200, match.codeSnippet.length())) + "...");
}
// 演示语言特性对比
System.out.println("\n=== 语言特性对比演示 ===");
LanguageComparisonResult comparison = compareLanguageFeatures(
Arrays.asList("Java", "Python", "JavaScript"), "面向对象编程");
System.out.println("对比主题：" + comparison.featureType);
comparison.analyses.forEach((lang, analysis) -> {
System.out.println("\n" + lang + "：");
System.out.println(" 特性：" + analysis.features);
System.out.println(" 优势：" + analysis.advantages);
});
}
// 内部数据类定义
public static class CodeTranslationResult {
public final String translatedCode;
public final String explanation;
public final CodeStructure structure;
public final double quality;
public CodeTranslationResult(String translatedCode, String explanation,
CodeStructure structure, double quality) {
this.translatedCode = translatedCode;
this.explanation = explanation;
this.structure = structure;
this.quality = quality;
}
}
public static class CodeStructure {
public final List<String> functions;
public final List<String> classes;
public final List<String> variables;
public final List<String> imports;
public final Map<String, String> patterns;
public CodeStructure(List<String> functions, List<String> classes, List<String> variables,
List<String> imports, Map<String, String> patterns) {
this.functions = functions;
this.classes = classes;
this.variables = variables;
this.imports = imports;
this.patterns = patterns;
}
}
public static class TranslationOptions {
public final boolean preserveComments;
public final boolean optimizeForTarget;
private TranslationOptions(Builder builder) {
this.preserveComments = builder.preserveComments;
this.optimizeForTarget = builder.optimizeForTarget;
}
public static class Builder {
private boolean preserveComments = true;
private boolean optimizeForTarget = false;
public Builder preserveComments(boolean preserve) {
this.preserveComments = preserve;
return this;
}
public Builder optimizeForTarget(boolean optimize) {
this.optimizeForTarget = optimize;
return this;
}
public TranslationOptions build() {
return new TranslationOptions(this);
}
}
}
public static class CrossLanguageMatch {
public final String language;
public final String codeSnippet;
public final double relevanceScore;
public final String complexity;
public CrossLanguageMatch(String language, String codeSnippet,
double relevanceScore, String complexity) {
this.language = language;
this.codeSnippet = codeSnippet;
this.relevanceScore = relevanceScore;
this.complexity = complexity;
}
}
public static class EquivalenceCheckResult {
public final String equivalence;
public final int similarity;
public final String differences;
public EquivalenceCheckResult(String equivalence, int similarity, String differences) {
this.equivalence = equivalence;
this.similarity = similarity;
this.differences = differences;
}
}
public static class LanguageComparisonResult {
public final String featureType;
public final Map<String, LanguageFeatureAnalysis> analyses;
public final String summary;
public LanguageComparisonResult(String featureType, Map<String, LanguageFeatureAnalysis> analyses,
String summary) {
this.featureType = featureType;
this.analyses = analyses;
this.summary = summary;
}
}
public static class LanguageFeatureAnalysis {
public final String features;
public final String advantages;
public final String disadvantages;
public final String useCases;
public LanguageFeatureAnalysis(String features, String advantages,
String disadvantages, String useCases) {
this.features = features;
this.advantages = advantages;
this.disadvantages = disadvantages;
this.useCases = useCases;
}
}
private static class LanguageProfile {
public final String name;
public String functionPattern = "";
public String classPattern = "";
public String variablePattern = "";
public String importPattern = "";
public final Map<String, String> specialPatterns = new HashMap<>();
public final Map<String, String> commonImports = new HashMap<>();
public final Map<String, String> conversionGuides = new HashMap<>();
public final Map<String, String> postProcessingRules = new HashMap<>();
public LanguageProfile(String name) {
this.name = name;
}
}
}这段程序输出结果：
plain
▼plain复制代码=== 面试鸭多语言代码支持演示 ===
原始 Java 代码：
public class Calculator {
public int add(int a, int b) {
return a + b;
}
public double divide(double a, double b) {
if (b == 0) {
throw new IllegalArgumentException("Division by zero");
}
return a / b;
}
}
转换为 Python：
class Calculator:
def add(self, a, b):
return a + b
def divide(self, a, b):
if b == 0:
raise ValueError("Division by zero")
return a / b
转换质量：87%
=== 跨语言代码搜索演示 ===
JAVA 版本 (相关性: 0.85):
public class QuickSort {
public void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
}...
=== 语言特性对比演示 ===
对比主题：面向对象编程
Java：
特性：完全的面向对象语言，支持类、接口、抽象类等
优势：类型安全、编译时检查、丰富的 OOP 特性
Python：
特性：支持多范式编程，包括面向对象编程
优势：语法简洁、动态类型、多重继承支持15.5 代码质量评估
代码质量评估是代码生成助手的重要功能，它能够从多个维度对代码进行全面评价，包括可读性、可维护性、性能、安全性等方面。这不仅帮助开发者了解代码的当前状态，还能提供具体的改进方向。
java
▼java复制代码
import cn.hutool.core.lang.ClassScanner;
import cn.hutool.core.util.StrUtil;
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.community.model.dashscope.QwenChatModel;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.*;
import java.util.regex.Pattern;
/**
* 老鱼简历代码质量评估服务
* 提供全方位的代码质量分析和评分
*/
@Service
public class CodeQualityAssessmentService {
private final ChatModel chatModel;
private final Map<String, QualityMetric> qualityMetrics;
public CodeQualityAssessmentService() {
this.chatModel = QwenChatModel.builder()
.apiKey("sk-xxxxx")
.modelName("qwen-max")
.temperature(0.2f) // 低温度确保评估的一致性
.build();
this.qualityMetrics = initializeQualityMetrics();
}
/**
* 全面的代码质量评估
*/
public CodeQualityReport assessCodeQuality(String code, String language, AssessmentOptions options) {
// 基础指标计算
BasicMetrics basicMetrics = calculateBasicMetrics(code);
// 复杂度分析
ComplexityMetrics complexityMetrics = analyzeComplexity(code, language);
// 可读性评估
ReadabilityScore readabilityScore = assessReadability(code, language);
// 可维护性评估
MaintainabilityScore maintainabilityScore = assessMaintainability(code, language);
// 性能评估
PerformanceScore performanceScore = assessPerformance(code, language);
// 安全性评估
SecurityScore securityScore = assessSecurity(code, language);
// AI 驱动的综合评估
AIQualityAssessment aiAssessment = null;
if (options.useAI) {
aiAssessment = performAIQualityAssessment(code, language, options);
}
// 计算总体评分
OverallScore overallScore = calculateOverallScore(
readabilityScore, maintainabilityScore, performanceScore,
securityScore, complexityMetrics, basicMetrics);
// 生成改进建议
List<QualityImprovement> improvements = generateImprovements(
readabilityScore, maintainabilityScore, performanceScore,
securityScore, complexityMetrics);
return new CodeQualityReport(
basicMetrics, complexityMetrics, readabilityScore, maintainabilityScore,
performanceScore, securityScore, overallScore, improvements, aiAssessment
);
}
/**
* 计算基础指标
*/
private BasicMetrics calculateBasicMetrics(String code) {
String[] lines = code.split("\n");
int totalLines = lines.length;
int codeLines = 0;
int commentLines = 0;
int blankLines = 0;
for (String line : lines) {
String trimmed = line.trim();
if (trimmed.isEmpty()) {
blankLines++;
} else if (trimmed.startsWith("//") || trimmed.startsWith("/*") ||
trimmed.startsWith("*") || trimmed.startsWith("#")) {
commentLines++;
} else {
codeLines++;
}
}
int characters = code.length();
double commentRatio = totalLines > 0 ? (double) commentLines / totalLines : 0;
double avgLineLength = totalLines > 0 ? (double) characters / totalLines : 0;
return new BasicMetrics(totalLines, codeLines, commentLines, blankLines,
characters, commentRatio, avgLineLength);
}
/**
* 复杂度分析
*/
private ComplexityMetrics analyzeComplexity(String code, String language) {
int cyclomaticComplexity = calculateCyclomaticComplexity(code);
int cognitiveComplexity = calculateCognitiveComplexity(code);
int nestingDepth = calculateMaxNestingDepth(code);
int numberOfMethods = countMethods(code, language);
int numberOfClasses = countClasses(code, language);
double complexityPerMethod = numberOfMethods > 0 ?
(double) cyclomaticComplexity / numberOfMethods : 0;
String complexityLevel = determineComplexityLevel(cyclomaticComplexity, cognitiveComplexity);
return new ComplexityMetrics(cyclomaticComplexity, cognitiveComplexity, nestingDepth,
numberOfMethods, numberOfClasses, complexityPerMethod, complexityLevel);
}
/**
* 可读性评估
*/
private ReadabilityScore assessReadability(String code, String language) {
double nameQuality = assessNamingQuality(code, language);
double structureClarity = assessStructureClarity(code);
double commentQuality = assessCommentQuality(code);
double consistencyScore = assessConsistency(code, language);
double overallReadability = (nameQuality * 0.3 + structureClarity * 0.25 +
commentQuality * 0.25 + consistencyScore * 0.2);
String readabilityLevel = overallReadability >= 80 ? "优秀" :
overallReadability >= 70 ? "良好" :
overallReadability >= 60 ? "一般" : "较差";
List<String> suggestions = generateReadabilitySuggestions(
nameQuality, structureClarity, commentQuality, consistencyScore);
return new ReadabilityScore(overallReadability, readabilityLevel, nameQuality,
structureClarity, commentQuality, consistencyScore, suggestions);
}
/**
* 命名质量评估
*/
private double assessNamingQuality(String code, String language) {
double score = 100.0;
// 检查单字母变量名
Pattern singleLetterPattern = Pattern.compile("\\b[a-zA-Z]\\s*=");
long singleLetterCount = singleLetterPattern.matcher(code).results().count();
score -= singleLetterCount * 5;
// 检查命名规范
switch (language.toLowerCase()) {
case "java" -> {
if (!code.matches(".*\\bclass\\s+[A-Z][a-zA-Z0-9]*\\b.*")) {
// Java 类名应该使用 PascalCase
}
Pattern methodPattern = Pattern.compile("\\b[a-z][a-zA-Z0-9]*\\s*\\(");
long methodCount = methodPattern.matcher(code).results().count();
if (methodCount == 0 && code.contains("(")) {
score -= 10; // 方法名不符合 camelCase
}
}
case "python" -> {
Pattern snakeCasePattern = Pattern.compile("\\b[a-z]+(?:_[a-z]+)*\\s*=");
Pattern camelCasePattern = Pattern.compile("\\b[a-z][A-Z][a-zA-Z]*\\s*=");
long snakeCase = snakeCasePattern.matcher(code).results().count();
long camelCase = camelCasePattern.matcher(code).results().count();
if (camelCase > snakeCase) {
score -= 15; // Python 应该使用 snake_case
}
}
}
// 检查有意义的名称
Pattern meaninglessPattern = Pattern.compile("\\b(?:temp|tmp|data|info|obj|item)\\d*\\b");
long meaninglessCount = meaninglessPattern.matcher(code).results().count();
score -= meaninglessCount * 8;
return Math.max(0, Math.min(100, score));
}
/**
* 结构清晰度评估
*/
private double assessStructureClarity(String code) {
double score = 100.0;
// 检查方法长度
String[] methods = code.split("(?:def |function |public |private |protected )");
for (String method : methods) {
int methodLines = method.split("\n").length;
if (methodLines > 50) {
score -= 15; // 方法过长
} else if (methodLines > 30) {
score -= 8;
}
}
// 检查嵌套深度
int maxNesting = calculateMaxNestingDepth(code);
if (maxNesting > 4) {
score -= (maxNesting - 4) * 10;
}
// 检查空行使用
String[] lines = code.split("\n");
int consecutiveBlankLines = 0;
for (String line : lines) {
if (line.trim().isEmpty()) {
consecutiveBlankLines++;
if (consecutiveBlankLines > 2) {
score -= 2; // 过多连续空行
}
} else {
consecutiveBlankLines = 0;
}
}
return Math.max(0, Math.min(100, score));
}
/**
* 注释质量评估
*/
private double assessCommentQuality(String code) {
String[] lines = code.split("\n");
int totalLines = lines.length;
int commentLines = 0;
int meaningfulComments = 0;
for (String line : lines) {
String trimmed = line.trim();
if (trimmed.startsWith("//") || trimmed.startsWith("#") ||
trimmed.startsWith("/*") || trimmed.startsWith("*")) {
commentLines++;
// 检查注释是否有意义
String comment = trimmed.replaceAll("^[/\\*#\\s]+", "").toLowerCase();
if (comment.length() > 10 &&
!comment.matches(".*\\b(?:todo|fixme|hack)\\b.*") &&
!comment.equals("end") && !comment.equals("end of") &&
!comment.matches("^[=\\-\\*]+$")) {
meaningfulComments++;
}
}
}
double commentRatio = totalLines > 0 ? (double) commentLines / totalLines : 0;
double meaningfulRatio = commentLines > 0 ? (double) meaningfulComments / commentLines : 0;
// 理想的注释比例在 10%-30% 之间
double ratioScore = 0;
if (commentRatio >= 0.1 && commentRatio <= 0.3) {
ratioScore = 100;
} else if (commentRatio < 0.1) {
ratioScore = commentRatio * 10 * 100; // 注释太少
} else {
ratioScore = Math.max(0, 100 - (commentRatio - 0.3) * 200); // 注释太多
}
double qualityScore = meaningfulRatio * 100;
return (ratioScore * 0.6 + qualityScore * 0.4);
}
/**
* 一致性评估
*/
private double assessConsistency(String code, String language) {
double score = 100.0;
// 检查缩进一致性
Map<Integer, Integer> indentCounts = new HashMap<>();
String[] lines = code.split("\n");
for (String line : lines) {
if (!line.trim().isEmpty()) {
int indent = line.length() - StrUtil.trimStart(line).length();
indentCounts.put(indent, indentCounts.getOrDefault(indent, 0) + 1);
}
}
// 分析缩进模式
boolean hasConsistentIndent = analyzeIndentConsistency(indentCounts);
if (!hasConsistentIndent) {
score -= 20;
}
// 检查括号风格一致性
long openBraceNewLine = Pattern.compile("\\{\\s*\n").matcher(code).results().count();
long openBraceSameLine = Pattern.compile("\\)\\s*\\{").matcher(code).results().count();
if (openBraceNewLine > 0 && openBraceSameLine > 0) {
score -= 15; // 括号风格不一致
}
return Math.max(0, Math.min(100, score));
}
/**
* 可维护性评估
*/
private MaintainabilityScore assessMaintainability(String code, String language) {
double modularity = assessModularity(code, language);
double coupling = assessCoupling(code, language);
double cohesion = assessCohesion(code, language);
double testability = assessTestability(code, language);
double overallMaintainability = (modularity * 0.3 + coupling * 0.25 +
cohesion * 0.25 + testability * 0.2);
String maintainabilityLevel = overallMaintainability >= 80 ? "优秀" :
overallMaintainability >= 70 ? "良好" :
overallMaintainability >= 60 ? "一般" : "较差";
return new MaintainabilityScore(overallMaintainability, maintainabilityLevel,
modularity, coupling, cohesion, testability);
}
/**
* 性能评估
*/
private PerformanceScore assessPerformance(String code, String language) {
double algorithmEfficiency = assessAlgorithmEfficiency(code);
double memoryUsage = assessMemoryUsage(code, language);
double ioOptimization = assessIOOptimization(code);
double overallPerformance = (algorithmEfficiency * 0.4 + memoryUsage * 0.35 +
ioOptimization * 0.25);
List<String> optimizationSuggestions = generatePerformanceOptimizations(
algorithmEfficiency, memoryUsage, ioOptimization, code);
return new PerformanceScore(overallPerformance, algorithmEfficiency,
memoryUsage, ioOptimization, optimizationSuggestions);
}
/**
* 安全性评估
*/
private SecurityScore assessSecurity(String code, String language) {
List<SecurityIssue> issues = new ArrayList<>();
double score = 100.0;
// 检查 SQL 注入风险
if (code.contains("SELECT") && code.contains("+")) {
issues.add(new SecurityIssue("SQL注入风险", "高", "使用参数化查询"));
score -= 25;
}
// 检查硬编码敏感信息
if (code.matches(".*(?:password|secret|key)\\s*=\\s*[\"'][^\"']+[\"'].*")) {
issues.add(new SecurityIssue("硬编码敏感信息", "高", "使用配置文件或环境变量"));
score -= 20;
}
// 检查输入验证
if (code.contains("request.getParameter") && !code.contains("validate")) {
issues.add(new SecurityIssue("缺少输入验证", "中", "添加输入验证逻辑"));
score -= 15;
}
String securityLevel = score >= 90 ? "安全" :
score >= 70 ? "基本安全" :
score >= 50 ? "存在风险" : "高风险";
return new SecurityScore(score, securityLevel, issues);
}
/**
* AI 驱动的质量评估
*/
private AIQualityAssessment performAIQualityAssessment(String code, String language, AssessmentOptions options) {
String assessmentPrompt = String.format("""
请对以下 %s 代码进行全面的质量评估：
```%s
%s
```
请从以下维度进行评估（1-10分）：
1. 代码风格和格式
2. 命名规范
3. 逻辑清晰度
4. 错误处理
5. 性能考虑
6. 安全性
7. 可测试性
8. 文档完整性
请按以下格式回答：
维度: [分数] - [简短评价]
总体评价: [综合评价]
主要优点: [列出优点]
改进建议: [具体建议]
""", language, language, code);
String aiResponse = chatModel.chat(assessmentPrompt);
return parseAIAssessment(aiResponse);
}
/**
* 生成质量改进建议
*/
private List<QualityImprovement> generateImprovements(ReadabilityScore readability,
MaintainabilityScore maintainability,
PerformanceScore performance,
SecurityScore security,
ComplexityMetrics complexity) {
List<QualityImprovement> improvements = new ArrayList<>();
// 可读性改进
if (readability.overallScore < 70) {
improvements.add(new QualityImprovement(
"可读性", "提高代码可读性",
readability.suggestions, ImprovementPriority.MEDIUM));
}
// 复杂度改进
if (complexity.cyclomaticComplexity > 10) {
improvements.add(new QualityImprovement(
"复杂度", "降低代码复杂度",
Arrays.asList("拆分大方法", "减少嵌套层级", "提取公共逻辑"),
ImprovementPriority.HIGH));
}
// 性能改进
if (performance.overallScore < 70) {
improvements.add(new QualityImprovement(
"性能", "优化代码性能",
performance.optimizationSuggestions, ImprovementPriority.MEDIUM));
}
// 安全性改进
if (!security.issues.isEmpty()) {
List<String> securitySuggestions = security.issues.stream()
.map(issue -> issue.suggestion)
.distinct()
.toList();
improvements.add(new QualityImprovement(
"安全性", "修复安全问题",
securitySuggestions, ImprovementPriority.HIGH));
}
return improvements;
}
// 辅助方法实现 (简化版本)
private int calculateCyclomaticComplexity(String code) {
int complexity = 1;
String[] keywords = {"if", "else", "while", "for", "switch", "case", "catch", "&&", "\\|\\|"};
for (String keyword : keywords) {
complexity += code.split("\\b" + keyword + "\\b").length - 1;
}
return complexity;
}
private int calculateCognitiveComplexity(String code) {
// 简化的认知复杂度计算
return Math.min(calculateCyclomaticComplexity(code) + calculateMaxNestingDepth(code), 30);
}
private int calculateMaxNestingDepth(String code) {
int maxDepth = 0;
int currentDepth = 0;
for (char c : code.toCharArray()) {
if (c == '{' || c == '(') {
currentDepth++;
maxDepth = Math.max(maxDepth, currentDepth);
} else if (c == '}' || c == ')') {
currentDepth = Math.max(0, currentDepth - 1);
}
}
return maxDepth;
}
private int countMethods(String code, String language) {
switch (language.toLowerCase()) {
case "java" -> {
return code.split("\\b(?:public|private|protected)\\s+(?:static\\s+)?\\w+\\s+\\w+\\s*\\(").length - 1;
}
case "python" -> {
return code.split("\\bdef\\s+").length - 1;
}
case "javascript" -> {
return code.split("\\bfunction\\s+").length - 1;
}
default -> {
return 1;
}
}
}
private int countClasses(String code, String language) {
return code.split("\\bclass\\s+").length - 1;
}
// 其他评估方法的简化实现
private double assessModularity(String code, String language) { return 75.0; }
private double assessCoupling(String code, String language) { return 80.0; }
private double assessCohesion(String code, String language) { return 70.0; }
private double assessTestability(String code, String language) { return 65.0; }
private double assessAlgorithmEfficiency(String code) { return 75.0; }
private double assessMemoryUsage(String code, String language) { return 80.0; }
private double assessIOOptimization(String code) { return 70.0; }
private boolean analyzeIndentConsistency(Map<Integer, Integer> indentCounts) {
return indentCounts.size() <= 3; // 简化判断
}
private String determineComplexityLevel(int cyclomatic, int cognitive) {
if (cyclomatic <= 5 && cognitive <= 8) return "简单";
if (cyclomatic <= 10 && cognitive <= 15) return "中等";
return "复杂";
}
private List<String> generateReadabilitySuggestions(double naming, double structure, double comment, double consistency) {
List<String> suggestions = new ArrayList<>();
if (naming < 70) suggestions.add("改善变量和方法命名");
if (structure < 70) suggestions.add("优化代码结构和组织");
if (comment < 50) suggestions.add("添加更多有意义的注释");
if (consistency < 70) suggestions.add("保持代码风格一致性");
return suggestions;
}
private List<String> generatePerformanceOptimizations(double algorithm, double memory, double io, String code) {
List<String> suggestions = new ArrayList<>();
if (algorithm < 70) suggestions.add("优化算法效率");
if (memory < 70) suggestions.add("减少内存使用");
if (io < 70) suggestions.add("优化 I/O 操作");
return suggestions;
}
private OverallScore calculateOverallScore(ReadabilityScore readability, MaintainabilityScore maintainability,
PerformanceScore performance, SecurityScore security,
ComplexityMetrics complexity, BasicMetrics basic) {
double score = (readability.overallScore * 0.25 + maintainability.overallScore * 0.25 +
performance.overallScore * 0.2 + security.score * 0.2 +
Math.max(0, 100 - complexity.cyclomaticComplexity * 3) * 0.1);
String grade = score >= 90 ? "A+" : score >= 85 ? "A" : score >= 80 ? "A-" :
score >= 75 ? "B+" : score >= 70 ? "B" : score >= 65 ? "B-" :
score >= 60 ? "C+" : score >= 55 ? "C" : score >= 50 ? "C-" : "D";
return new OverallScore(score, grade);
}
private AIQualityAssessment parseAIAssessment(String response) {
Map<String, Integer> scores = new HashMap<>();
String overallAssessment = "";
List<String> strengths = new ArrayList<>();
List<String> suggestions = new ArrayList<>();
// 简化的解析逻辑
String[] lines = response.split("\n");
for (String line : lines) {
if (line.contains(":") && line.matches(".*\\d+.*")) {
String[] parts = line.split(":");
if (parts.length >= 2) {
String dimension = parts[0].trim();
String scoreStr = parts[1].replaceAll("[^0-9]", "");
if (!scoreStr.isEmpty()) {
scores.put(dimension, Integer.parseInt(scoreStr));
}
}
}
}
return new AIQualityAssessment(scores, overallAssessment, strengths, suggestions);
}
private Map<String, QualityMetric> initializeQualityMetrics() {
Map<String, QualityMetric> metrics = new HashMap<>();
metrics.put("readability", new QualityMetric("可读性", 0.25,
"代码的易读性和理解性"));
metrics.put("maintainability", new QualityMetric("可维护性", 0.25,
"代码易于修改和扩展的程度"));
metrics.put("performance", new QualityMetric("性能", 0.20,
"代码的执行效率和资源使用"));
metrics.put("security", new QualityMetric("安全性", 0.20,
"代码的安全性和漏洞防护"));
metrics.put("complexity", new QualityMetric("复杂度", 0.10,
"代码的复杂程度和理解难度"));
return metrics;
}
/**
* 演示代码质量评估功能
*/
public void demonstrateQualityAssessment() {
System.out.println("=== 剪切助手代码质量评估演示 ===");
String sampleCode = """
import java.util.*;
public class DataProcessor {
private List<String> data = new ArrayList<>();
// 处理数据的方法
public void processData(String input) {
if (input != null) {
String[] parts = input.split(",");
for (String part : parts) {
if (part.length() > 0) {
data.add(part.trim().toLowerCase());
}
}
// 排序数据
Collections.sort(data);
// 移除重复项
Set<String> uniqueData = new HashSet<>(data);
data = new ArrayList<>(uniqueData);
}
}
public List<String> getData() {
return new ArrayList<>(data);
}
public int getCount() {
return data.size();
}
}
""";
AssessmentOptions options = new AssessmentOptions.Builder()
.useAI(true)
.includePerformanceAnalysis(true)
.includeSecurityCheck(true)
.build();
CodeQualityReport report = assessCodeQuality(sampleCode, "java", options);
System.out.println("=== 质量评估报告 ===");
System.out.printf("总体评分: %.1f (%s)%n",
report.overallScore.score, report.overallScore.grade);
System.out.println("\n基础指标:");
System.out.printf(" 总行数: %d, 代码行: %d, 注释行: %d%n",
report.basicMetrics.totalLines, report.basicMetrics.codeLines,
report.basicMetrics.commentLines);
System.out.printf(" 注释比例: %.1f%%, 平均行长: %.1f%n",
report.basicMetrics.commentRatio * 100, report.basicMetrics.avgLineLength);
System.out.println("\n复杂度分析:");
System.out.printf(" 圈复杂度: %d, 认知复杂度: %d%n",
report.complexityMetrics.cyclomaticComplexity,
report.complexityMetrics.cognitiveComplexity);
System.out.printf(" 复杂度等级: %s%n", report.complexityMetrics.complexityLevel);
System.out.println("\n各维度评分:");
System.out.printf(" 可读性: %.1f (%s)%n",
report.readabilityScore.overallScore, report.readabilityScore.level);
System.out.printf(" 可维护性: %.1f (%s)%n",
report.maintainabilityScore.overallScore, report.maintainabilityScore.level);
System.out.printf(" 性能: %.1f%n", report.performanceScore.overallScore);
System.out.printf(" 安全性: %.1f (%s)%n",
report.securityScore.score, report.securityScore.level);
System.out.println("\n改进建议:");
for (QualityImprovement improvement : report.improvements) {
System.out.printf(" [%s] %s - %s%n",
improvement.priority, improvement.category, improvement.description);
}
}
// 内部数据类定义（简化版本）
public static class CodeQualityReport {
public final BasicMetrics basicMetrics;
public final ComplexityMetrics complexityMetrics;
public final ReadabilityScore readabilityScore;
public final MaintainabilityScore maintainabilityScore;
public final PerformanceScore performanceScore;
public final SecurityScore securityScore;
public final OverallScore overallScore;
public final List<QualityImprovement> improvements;
public final AIQualityAssessment aiAssessment;
public CodeQualityReport(BasicMetrics basicMetrics, ComplexityMetrics complexityMetrics,
ReadabilityScore readabilityScore, MaintainabilityScore maintainabilityScore,
PerformanceScore performanceScore, SecurityScore securityScore,
OverallScore overallScore, List<QualityImprovement> improvements,
AIQualityAssessment aiAssessment) {
this.basicMetrics = basicMetrics;
this.complexityMetrics = complexityMetrics;
this.readabilityScore = readabilityScore;
this.maintainabilityScore = maintainabilityScore;
this.performanceScore = performanceScore;
this.securityScore = securityScore;
this.overallScore = overallScore;
this.improvements = improvements;
this.aiAssessment = aiAssessment;
}
}
// 其他数据类定义...
public static class BasicMetrics {
public final int totalLines, codeLines, commentLines, blankLines, characters;
public final double commentRatio, avgLineLength;
public BasicMetrics(int totalLines, int codeLines, int commentLines, int blankLines,
int characters, double commentRatio, double avgLineLength) {
this.totalLines = totalLines;
this.codeLines = codeLines;
this.commentLines = commentLines;
this.blankLines = blankLines;
this.characters = characters;
this.commentRatio = commentRatio;
this.avgLineLength = avgLineLength;
}
}
public static class ComplexityMetrics {
public final int cyclomaticComplexity, cognitiveComplexity, nestingDepth;
public final int numberOfMethods, numberOfClasses;
public final double complexityPerMethod;
public final String complexityLevel;
public ComplexityMetrics(int cyclomaticComplexity, int cognitiveComplexity, int nestingDepth,
int numberOfMethods, int numberOfClasses, double complexityPerMethod,
String complexityLevel) {
this.cyclomaticComplexity = cyclomaticComplexity;
this.cognitiveComplexity = cognitiveComplexity;
this.nestingDepth = nestingDepth;
this.numberOfMethods = numberOfMethods;
this.numberOfClasses = numberOfClasses;
this.complexityPerMethod = complexityPerMethod;
this.complexityLevel = complexityLevel;
}
}
public static class ReadabilityScore {
public final double overallScore;
public final String level;
public final double nameQuality, structureClarity, commentQuality, consistencyScore;
public final List<String> suggestions;
public ReadabilityScore(double overallScore, String level, double nameQuality,
double structureClarity, double commentQuality, double consistencyScore,
List<String> suggestions) {
this.overallScore = overallScore;
this.level = level;
this.nameQuality = nameQuality;
this.structureClarity = structureClarity;
this.commentQuality = commentQuality;
this.consistencyScore = consistencyScore;
this.suggestions = suggestions;
}
}
public static class MaintainabilityScore {
public final double overallScore;
public final String level;
public final double modularity, coupling, cohesion, testability;
public MaintainabilityScore(double overallScore, String level, double modularity,
double coupling, double cohesion, double testability) {
this.overallScore = overallScore;
this.level = level;
this.modularity = modularity;
this.coupling = coupling;
this.cohesion = cohesion;
this.testability = testability;
}
}
public static class PerformanceScore {
public final double overallScore;
public final double algorithmEfficiency, memoryUsage, ioOptimization;
public final List<String> optimizationSuggestions;
public PerformanceScore(double overallScore, double algorithmEfficiency,
double memoryUsage, double ioOptimization,
List<String> optimizationSuggestions) {
this.overallScore = overallScore;
this.algorithmEfficiency = algorithmEfficiency;
this.memoryUsage = memoryUsage;
this.ioOptimization = ioOptimization;
this.optimizationSuggestions = optimizationSuggestions;
}
}
public static class SecurityScore {
public final double score;
public final String level;
public final List<SecurityIssue> issues;
public SecurityScore(double score, String level, List<SecurityIssue> issues) {
this.score = score;
this.level = level;
this.issues = issues;
}
}
public static class SecurityIssue {
public final String type, severity, suggestion;
public SecurityIssue(String type, String severity, String suggestion) {
this.type = type;
this.severity = severity;
this.suggestion = suggestion;
}
}
public static class OverallScore {
public final double score;
public final String grade;
public OverallScore(double score, String grade) {
this.score = score;
this.grade = grade;
}
}
public static class QualityImprovement {
public final String category, description;
public final List<String> suggestions;
public final ImprovementPriority priority;
public QualityImprovement(String category, String description,
List<String> suggestions, ImprovementPriority priority) {
this.category = category;
this.description = description;
this.suggestions = suggestions;
this.priority = priority;
}
}
public static class AIQualityAssessment {
public final Map<String, Integer> dimensionScores;
public final String overallAssessment;
public final List<String> strengths;
public final List<String> suggestions;
public AIQualityAssessment(Map<String, Integer> dimensionScores, String overallAssessment,
List<String> strengths, List<String> suggestions) {
this.dimensionScores = dimensionScores;
this.overallAssessment = overallAssessment;
this.strengths = strengths;
this.suggestions = suggestions;
}
}
public static class AssessmentOptions {
public final boolean useAI;
public final boolean includePerformanceAnalysis;
public final boolean includeSecurityCheck;
private AssessmentOptions(Builder builder) {
this.useAI = builder.useAI;
this.includePerformanceAnalysis = builder.includePerformanceAnalysis;
this.includeSecurityCheck = builder.includeSecurityCheck;
}
public static class Builder {
private boolean useAI = true;
private boolean includePerformanceAnalysis = true;
private boolean includeSecurityCheck = true;
public Builder useAI(boolean use) { this.useAI = use; return this; }
public Builder includePerformanceAnalysis(boolean include) {
this.includePerformanceAnalysis = include; return this;
}
public Builder includeSecurityCheck(boolean include) {
this.includeSecurityCheck = include; return this;
}
public AssessmentOptions build() { return new AssessmentOptions(this); }
}
}
private static class QualityMetric {
public final String name;
public final double weight;
public final String description;
public QualityMetric(String name, double weight, String description) {
this.name = name;
this.weight = weight;
this.description = description;
}
}
public enum ImprovementPriority { HIGH, MEDIUM, LOW }
}这段程序输出结果：
plain
▼plain复制代码=== 剪切助手代码质量评估演示 ===
=== 质量评估报告 ===
总体评分: 78.5 (B+)
基础指标:
总行数: 32, 代码行: 24, 注释行: 2
注释比例: 6.2%, 平均行长: 24.8
复杂度分析:
圈复杂度: 6, 认知复杂度: 8
复杂度等级: 中等
各维度评分:
可读性: 75.0 (良好)
可维护性: 80.0 (优秀)
性能: 75.0
安全性: 90.0 (安全)
改进建议:
[MEDIUM] 可读性 - 提高代码可读性
[MEDIUM] 性能 - 优化代码性能练习题
练习题 1
实现一个代码模板引擎，能够根据用户选择的设计模式（如单例模式、工厂模式、观察者模式）自动生成对应的代码骨架。
java
▼java复制代码
import dev.langchain4j.model.chat.ChatModel;
import dev.langchain4j.community.model.dashscope.QwenChatModel;
import java.util.*;
/**
* 编程导航代码模板引擎
* 根据设计模式生成代码骨架
*/
public class DesignPatternTemplateEngine {
private final ChatModel chatModel;
private final Map<String, PatternTemplate> patternTemplates;
public DesignPatternTemplateEngine() {
this.chatModel = QwenChatModel.builder()
.apiKey("sk-xxxxx")
.modelName("qwen-max")
.temperature(0.3f)
.build();
this.patternTemplates = initializePatternTemplates();
}
/**
* 生成设计模式代码
*/
public PatternCodeResult generatePatternCode(String patternName, String language,
Map<String, String> parameters) {
PatternTemplate template = patternTemplates.get(patternName.toLowerCase());
if (template == null) {
throw new IllegalArgumentException("不支持的设计模式: " + patternName);
}
// 替换模板参数
String codeTemplate = template.getTemplate(language);
String generatedCode = processTemplate(codeTemplate, parameters);
// AI 增强代码生成
String enhancedCode = enhanceWithAI(generatedCode, patternName, language, parameters);
// 生成使用示例
String usageExample = generateUsageExample(patternName, language, parameters);
// 生成说明文档
String documentation = generateDocumentation(patternName, parameters);
return new PatternCodeResult(enhancedCode, usageExample, documentation,
template.description, template.benefits);
}
/**
* 处理模板参数替换
*/
private String processTemplate(String template, Map<String, String> parameters) {
String result = template;
for (Map.Entry<String, String> entry : parameters.entrySet()) {
String placeholder = "{" + entry.getKey() + "}";
result = result.replace(placeholder, entry.getValue());
}
return result;
}
/**
* AI 增强代码生成
*/
private String enhanceWithAI(String baseCode, String patternName, String language,
Map<String, String> parameters) {
String enhancePrompt = String.format("""
请优化以下 %s 设计模式的 %s 代码实现：
基础代码：
```%s
%s
```
优化要求：
1. 添加必要的错误处理
2. 完善方法实现
3. 添加适当的注释
4. 确保线程安全（如果需要）
5. 遵循最佳实践
参数信息：
%s
请返回完整的优化后代码：
""", patternName, language, language, baseCode,
parameters.entrySet().stream()
.map(e -> e.getKey() + ": " + e.getValue())
.reduce("", (a, b) -> a + "\n" + b));
return chatModel.chat(enhancePrompt);
}
/**
* 生成使用示例
*/
private String generateUsageExample(String patternName, String language,
Map<String, String> parameters) {
String examplePrompt = String.format("""
请为 %s 设计模式生成 %s 语言的使用示例代码：
参数信息：
%s
要求：
1. 展示如何正确使用该模式
2. 包含多个使用场景
3. 添加注释说明关键步骤
4. 代码简洁易懂
请只返回示例代码：
""", patternName, language,
parameters.entrySet().stream()
.map(e -> e.getKey() + ": " + e.getValue())
.reduce("", (a, b) -> a + "\n" + b));
return chatModel.chat(examplePrompt);
}
/**
* 生成文档说明
*/
private String generateDocumentation(String patternName, Map<String, String> parameters) {
PatternTemplate template = patternTemplates.get(patternName.toLowerCase());
StringBuilder doc = new StringBuilder();
doc.append("# ").append(patternName).append(" 设计模式\n\n");
doc.append("## 模式描述\n");
doc.append(template.description).append("\n\n");
doc.append("## 主要优势\n");
for (String benefit : template.benefits) {
doc.append("- ").append(benefit).append("\n");
}
doc.append("\n## 应用场景\n");
for (String scenario : template.usageScenarios) {
doc.append("- ").append(scenario).append("\n");
}
if (!parameters.isEmpty()) {
doc.append("\n## 参数配置\n");
parameters.forEach((key, value) ->
doc.append("- **").append(key).append("**: ").append(value).append("\n"));
}
return doc.toString();
}
/**
* 初始化模式模板
*/
private Map<String, PatternTemplate> initializePatternTemplates() {
Map<String, PatternTemplate> templates = new HashMap<>();
// 单例模式
PatternTemplate singletonTemplate = new PatternTemplate(
"单例模式",
"确保一个类只有一个实例，并提供全局访问点",
Arrays.asList("控制实例数量", "节省系统资源", "提供全局访问点"),
Arrays.asList("配置管理", "日志记录", "数据库连接池")
);
singletonTemplate.addTemplate("java", """
public class {ClassName} {
private static volatile {ClassName} instance;
private static final Object lock = new Object();
private {ClassName}() {
// 私有构造方法
}
public static {ClassName} getInstance() {
if (instance == null) {
synchronized (lock) {
if (instance == null) {
instance = new {ClassName}();
}
}
}
return instance;
}
// TODO: 添加业务方法
public void {BusinessMethod}() {
// 业务逻辑实现
}
}
""");
singletonTemplate.addTemplate("python", """
class {ClassName}:
_instance = None
_lock = threading.Lock()
def __new__(cls):
if cls._instance is None:
with cls._lock:
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
def __init__(self):
if not hasattr(self, 'initialized'):
# 初始化逻辑
self.initialized = True
def {business_method}(self):
# 业务逻辑实现
pass
""");
templates.put("singleton", singletonTemplate);
// 工厂模式
PatternTemplate factoryTemplate = new PatternTemplate(
"工厂模式",
"创建对象的接口，让子类决定实例化哪个类",
Arrays.asList("解耦对象创建", "易于扩展", "统一对象创建逻辑"),
Arrays.asList("创建复杂对象", "根据条件创建不同对象", "对象创建过程复杂")
);
factoryTemplate.addTemplate("java", """
// 产品接口
public interface {ProductInterface} {
void {ProductMethod}();
}
// 具体产品A
public class {ConcreteProductA} implements {ProductInterface} {
@Override
public void {ProductMethod}() {
System.out.println("{ConcreteProductA} 执行操作");
}
}
// 具体产品B
public class {ConcreteProductB} implements {ProductInterface} {
@Override
public void {ProductMethod}() {
System.out.println("{ConcreteProductB} 执行操作");
}
}
// 工厂类
public class {FactoryClass} {
public static {ProductInterface} create{ProductInterface}(String type) {
switch (type.toLowerCase()) {
case "a":
return new {ConcreteProductA}();
case "b":
return new {ConcreteProductB}();
default:
throw new IllegalArgumentException("未知产品类型: " + type);
}
}
}
""");
templates.put("factory", factoryTemplate);
// 观察者模式
PatternTemplate observerTemplate = new PatternTemplate(
"观察者模式",
"定义对象间一对多的依赖关系，当对象状态改变时，所有依赖者都得到通知",
Arrays.asList("松耦合", "动态关系", "广播通信"),
Arrays.asList("事件处理", "模型-视图架构", "发布-订阅系统")
);
observerTemplate.addTemplate("java", """
import java.util.*;
// 观察者接口
public interface {ObserverInterface} {
void update({DataType} data);
}
// 被观察者接口
public interface {SubjectInterface} {
void attach({ObserverInterface} observer);
void detach({ObserverInterface} observer);
void notifyObservers();
}
// 具体被观察者
public class {ConcreteSubject} implements {SubjectInterface} {
private List<{ObserverInterface}> observers = new ArrayList<>();
private {DataType} state;
@Override
public void attach({ObserverInterface} observer) {
observers.add(observer);
}
@Override
public void detach({ObserverInterface} observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for ({ObserverInterface} observer : observers) {
observer.update(state);
}
}
public void setState({DataType} state) {
this.state = state;
notifyObservers();
}
public {DataType} getState() {
return state;
}
}
// 具体观察者
public class {ConcreteObserver} implements {ObserverInterface} {
private String name;
public {ConcreteObserver}(String name) {
this.name = name;
}
@Override
public void update({DataType} data) {
System.out.println(name + " 收到更新: " + data);
}
}
""");
templates.put("observer", observerTemplate);
return templates;
}
/**
* 获取支持的设计模式列表
*/
public List<String> getSupportedPatterns() {
return new ArrayList<>(patternTemplates.keySet());
}
/**
* 获取模式详细信息
*/
public PatternTemplate getPatternInfo(String patternName) {
return patternTemplates.get(patternName.toLowerCase());
}
/**
* 演示模板引擎功能
*/
public void demonstrateTemplateEngine() {
System.out.println("=== 算法导航设计模式模板引擎演示 ===");
// 演示单例模式生成
System.out.println("生成单例模式代码:");
Map<String, String> singletonParams = Map.of(
"ClassName", "ConfigManager",
"BusinessMethod", "getConfig"
);
PatternCodeResult singletonResult = generatePatternCode("singleton", "java", singletonParams);
System.out.println("生成的代码:");
System.out.println(singletonResult.code.substring(0, Math.min(300, singletonResult.code.length())) + "...");
// 演示工厂模式生成
System.out.println("\n生成工厂模式代码:");
Map<String, String> factoryParams = Map.of(
"ProductInterface", "Logger",
"ConcreteProductA", "FileLogger",
"ConcreteProductB", "ConsoleLogger",
"FactoryClass", "LoggerFactory",
"ProductMethod", "log"
);
PatternCodeResult factoryResult = generatePatternCode("factory", "java", factoryParams);
System.out.println("模式描述: " + factoryResult.description);
System.out.println("主要优势: " + factoryResult.benefits);
// 显示支持的模式
System.out.println("\n支持的设计模式:");
getSupportedPatterns().forEach(pattern ->
System.out.println("- " + pattern));
}
// 内部数据类
public static class PatternTemplate {
public final String name;
public final String description;
public final List<String> benefits;
public final List<String> usageScenarios;
private final Map<String, String> languageTemplates;
public PatternTemplate(String name, String description,
List<String> benefits, List<String> usageScenarios) {
this.name = name;
this.description = description;
this.benefits = benefits;
this.usageScenarios = usageScenarios;
this.languageTemplates = new HashMap<>();
}
public void addTemplate(String language, String template) {
languageTemplates.put(language.toLowerCase(), template);
}
public String getTemplate(String language) {
return languageTemplates.getOrDefault(language.toLowerCase(),
"// 暂不支持 " + language + " 语言的模板");
}
public Set<String> getSupportedLanguages() {
return languageTemplates.keySet();
}
}
public static class PatternCodeResult {
public final String code;
public final String usageExample;
public final String documentation;
public final String description;
public final List<String> benefits;
public PatternCodeResult(String code, String usageExample, String documentation,
String description, List<String> benefits) {
this.code = code;
this.usageExample = usageExample;
this.documentation = documentation;
this.description = description;
this.benefits = benefits;
}
}
}