Spring AI 代码辅助工具：智能生成、审查与重构实战

作者：架构源启技术栈：Spring Boot 3.5.9 + Spring AI 1.1.4 + Tree-sitter + JavaParser + GPT-5.5 + Claude 4 Opus + DeepSeek-V4-Pro + CodeLlama-3-70B前置知识：已完成基础15篇博客，特别是第1篇（入门）、第5篇（函数调用）和第8篇（成本优化）SpringAI 基础入门系列专题

📖 前言

疑问：已有GitHub Copilot、Claude Code等成熟工具，为何还要自建？

这是一个非常关键的问题。让我从实际场景和业务价值两个维度深度分析。

🎯 核心原因（7大理由）

1. 企业级定制化需求

场景: 团队有严格的编码规范

// ❌ GitHub Copilot生成的代码（不符合规范）public class UserService {    public User find(Long id) { ... }  // 方法名不明确}// ✅ 自定义系统生成的代码（100%符合规范）public class UserService {    /**     * 根据ID查询用户     * @param id 用户ID，不能为空     * @return 用户对象，不存在时抛出异常     * @throws ResourceNotFoundException 用户不存在     */    public User findById(Long id) {        log.info("Querying user by id: {}", id);        return userRepository.findById(id)            .orElseThrow(() -> new ResourceNotFoundException("User not found"));    }}

价值对比:

2. 数据安全与合规

场景: 金融/医疗行业的严格要求

❌ 使用GitHub Copilot的风险:   - 代码发送到外部服务器   - 可能包含敏感信息（密钥、客户数据）   - 违反GDPR/等保要求   - 审计不通过✅ 本地部署的自定义系统:   - 代码不出内网   - 数据完全可控   - 符合合规要求   - 审计友好

真实案例: 某银行的要求

• 所有代码必须在内网处理
• 禁止使用外部API
• 需要完整的操作日志
• 需要审批流程

只能自建系统:

LocalCodeAssistant assistant = new LocalCodeAssistant(    Model.CODE_LLAMA_70B,  // 本地模型    Network.ISOLATED,       // 隔离网络    Audit.ENABLED           // 启用审计);

3. 成本控制（大规模团队）

成本对比（500人研发团队）:

每年节省: $42,000 - 500/月（CodeLlama-70B）  - 存储: 50/月软件许可:  - 开源模型: 200/月总计: $850/月 ≈ $1.7/人/月

❌ 通用工具的局限:GitHub Copilot → 生成代码 → 手动提交 → 手动CI/CD                （断点较多，效率低）✅ 自定义系统的优势:自定义AI助手 → 生成代码 → 自动审查 → 自动测试               → 自动构建 → 自动部署 → 通知审核              （全流程自动化）

@Componentpublic class IntegratedCodeWorkflow {    /**     * 一键完成从需求到部署的全流程     */    public WorkflowResult completeWorkflow(String requirement) {        // 1. AI生成代码        CodeResult code = generator.generate(requirement);        // 2. 自动代码审查        ReviewResult review = reviewer.review(code);        if (!review.isPassed()) {            return WorkflowResult.failed("Review failed");        }        // 3. 自动生成测试        TestResult tests = testGen.generate(code);        // 4. 运行测试        if (!runTests(tests)) {            return WorkflowResult.failed("Tests failed");        }        // 5. 自动提交Git        gitService.commitAndPush("feature/auto-generated", code);        // 6. 触发CI/CD        ciPipeline.trigger("feature/auto-generated");        // 7. 创建Pull Request并通知审核        PullRequest pr = gitService.createPR(...);        notificationService.notifyReviewers(pr);        return WorkflowResult.success(pr);    }}

// 保险行业的保单生成（通用AI不懂业务规则）InsurancePolicy policy = InsurancePolicyGenerator.generate(    PolicyRequirement.builder()        .type("车险")        .vehicleType("SUV")        .coverage("全险")        .driverAge(35)        .noClaimYears(3)        .build(),    // 注入业务规则    BusinessRules.insuranceRules2026,    // 注入监管要求    RegulatoryRequirements.cbirc2026);// 生成的保单100%符合监管要求

// 20年前的老系统改造（Struts 1 → Spring Boot 3）LegacyModernizer modernizer = new LegacyModernizer(    SourceSystem.STRUTS1_EJB2,    TargetSystem.SPRING_BOOT3_JPA,    MigrationStrategy.PHASED  // 渐进式迁移);MigrationPlan plan = modernizer.analyze(oldSystem);List<Refactoring> refactorings = modernizer.generate(plan);// 保持业务逻辑不变，生成现代化代码

❌ 通用AI工具:  - 黑盒操作，无法追溯  - 出问题找不到责任人  - 无法证明代码来源  - 审计不通过✅ 自定义系统:  - 完整的操作日志  - 每个代码变更可追溯  - AI建议 + 人工审核记录  - 符合审计要求

@Componentpublic class AuditableCodeGeneration {    public CodeResult generateWithAudit(CodeRequest request) {        // 1. 记录请求        AuditRecord record = auditLog.startRecording(            request.getUserId(),            request.getRequirement(),            LocalDateTime.now()        );        try {            // 2. 生成代码            CodeResult result = codeGenerator.generate(request);            // 3. 记录使用的模型和Prompt            record.setModelUsed(result.getModel());            record.setTokenUsage(result.getTokenUsage());            // 4. 记录人工审核            Approval approval = approvalService.requestApproval(result);            record.setApprovedBy(approval.getApprover());            // 5. 完成记录            auditLog.completeRecording(record);            return result;        } catch (Exception e) {            auditLog.failRecording(record, e);            throw e;        }    }}// 审计查询：完整的证据链List<AuditRecord> records = auditLog.query(    Query.builder()        .userId("developer123")        .dateRange(LocalDate.of(2026, 1, 1), LocalDate.of(2026, 5, 17))        .build());

❌ 通用AI的局限:GitHub Copilot:  - 全球通用模型  - 不了解你的团队  - 不会根据你的反馈改进  - 永远是"平均水平"✅ 自定义系统的优势:  - 学习团队编码风格  - 记住常用模式  - 基于反馈持续优化  - 越用越聪明

@Componentpublic class SelfLearningCodeAssistant {    /**     * 基于团队反馈持续优化（每周执行）     */    @Scheduled(fixedRate = 7 * 24 * 3600 * 1000)    public void weeklyOptimization() {        // 1. 收集本周反馈        List<Feedback> feedbacks = feedbackRepo.findThisWeek();        // 2. 分析问题模式        PatternAnalysis analysis = analyzePatterns(feedbacks);        // 3. 微调模型        if (analysis.hasSignificantPatterns()) {            fineTuner.fineTune(baseModel,                 analysis.getPositiveExamples(),                analysis.getNegativeExamples());        }        // 4. 更新Prompt模板        promptTemplateService.optimize(analysis);        log.info("Weekly optimization completed. Satisfaction improved by {}%",             analysis.getSatisfactionImprovement());    }}

日常开发（80%场景）:  → 使用 GitHub Copilot / Cursor  → 快速、便捷、成本低特殊场景（20%场景）:  → 使用自建系统  → 安全敏感代码  → 企业框架代码  → 需要审计的场景  → 批量代码生成

@Componentpublic class HybridCodeAssistant {    @Autowired    private GitHubCopilot copilot;  // 通用工具    @Autowired    private CustomCodeAssistant custom;  // 自建系统    public CodeResult assist(CodeRequest request) {        // 智能路由：判断是否适合用自建系统        if (needsCustomSystem(request)) {            return custom.generate(request);        } else {            return copilot.generate(request);        }    }    private boolean needsCustomSystem(CodeRequest request) {        return request.isSensitive() ||           // 敏感代码               request.usesInternalFramework() || // 内部框架               request.requiresAudit() ||         // 需要审计               request.isBatchGeneration();       // 批量生成    }}

┌───────────────────────────────────────────────────────────────┐│                   IDE Plugins Layer                           ││  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       ││  │ VSCode       │  │ IntelliJ     │  │ Eclipse      │       ││  │ Extension    │  │ Plugin       │  │ Plugin       │       ││  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘       ││         ↓ LSP             ↓ LSP             ↓ LSP            │└─────────┼─────────────────┼─────────────────┼───────────────┘          ↓                 ↓                 ↓┌───────────────────────────────────────────────────────────────┐│                  API Gateway Layer                            ││  ┌──────────────────────────────────────────────────────┐   ││  │ Kong / Traefik                                       │   ││  │ - 认证鉴权 (JWT/OAuth2)                              │   ││  │ - 限流熔断 (Rate Limiting)                           │   ││  │ - 负载均衡 (Load Balancing)                          │   ││  │ - 日志聚合 (Logging)                                 │   ││  └──────────────────────────────────────────────────────┘   │└────────────────────────┬────────────────────────────────────┘                         ↓┌───────────────────────────────────────────────────────────────┐│              Code Assistant Microservices                     ││                                                               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Context Service (上下文服务)                          │   ││  │ - AST解析 (Tree-sitter/JavaParser)                   │   ││  │ - 依赖分析 (Dependency Graph)                        │   ││  │ - 项目结构理解 (Project Structure)                   │   ││  │ - 历史代码检索 (Similar Code Search)                 │   ││  └──────────────────────────────────────────────────────┘   ││                                                               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Generation Service (代码生成服务)                     │   ││  │ - Controller生成                                     │   ││  │ - Service生成                                        │   ││  │ - Entity/DTO生成                                     │   ││  │ - Mapper生成                                         │   ││  │ - 模板引擎 + LLM混合生成                             │   ││  └──────────────────────────────────────────────────────┘   ││                                                               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Review Service (代码审查服务)                         │   ││  │ - 静态分析 (SonarQube集成)                           │   ││  │ - AI语义审查 (LLM深度分析)                           │   ││  │ - 安全扫描 (SAST/DAST)                               │   ││  │ - 性能分析 (Performance Profiling)                   │   ││  └──────────────────────────────────────────────────────┘   ││                                                               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Refactoring Service (重构服务)                        │   ││  │ - 代码异味检测 (Code Smell Detection)                │   ││  │ - 重构建议 (Refactoring Suggestions)                 │   ││  │ - 影响分析 (Impact Analysis)                         │   ││  │ - 自动化重构 (Automated Refactoring)                 │   ││  └──────────────────────────────────────────────────────┘   ││                                                               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Test Generation Service (测试生成服务)                │   ││  │ - 单元测试生成 (JUnit 5 + Mockito)                   │   ││  │ - 集成测试生成                                       │   ││  │ - 覆盖率分析                                         │   ││  │ - 边界条件识别                                       │   ││  └──────────────────────────────────────────────────────┘   ││                                                               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Documentation Service (文档服务)                      │   ││  │ - JavaDoc生成                                        │   ││  │ - README生成                                         │   ││  │ - API文档生成 (OpenAPI/Swagger)                      │   ││  │ - 架构文档生成                                       │   ││  └──────────────────────────────────────────────────────┘   │└────────────────────────┬────────────────────────────────────┘                         ↓┌───────────────────────────────────────────────────────────────┐│                  Model Router Layer (智能路由层)               ││  ┌──────────────────────────────────────────────────────┐   ││  │ Intelligent Model Router                             │   ││  │ - 任务复杂度评估                                     │   ││  │ - 成本效益分析                                       │   ││  │ - 模型选择策略                                       │   ││  └────┬───────────┬────────────┬────────────┬──────────┘   ││       ↓           ↓            ↓            ↓              ││  ┌────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐       ││  │GPT-5.5 │ │Claude 4  │ │DeepSeek  │ │CodeLlama │       ││  │        │ │Opus      │ │V4-Pro    │ │3-70B     │       ││  │复杂任务│ │代码审查  │ │中文最优  │ │本地推理  │       ││  └────────┘ └──────────┘ └──────────┘ └──────────┘       │└────────────────────────┬────────────────────────────────────┘                         ↓┌───────────────────────────────────────────────────────────────┐│                  Data & Cache Layer                           ││  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       ││  │ Redis        │  │ PostgreSQL   │  │ MinIO/S3     │       ││  │ (缓存层)      │  │ (主数据库)    │  │ (对象存储)    │       ││  │ - L1/L2缓存  │  │ - 代码片段   │  │ - 大型文件   │       ││  │ - 会话管理   │  │ - 用户配置   │  │ - 模型权重   │       ││  └──────────────┘  └──────────────┘  └──────────────┘       │└───────────────────────────────────────────────────────────────┘

用户操作（生成/审查/重构）   ↓┌─────────────────────────────────────────┐│ Step 1: 上下文提取                       ││ - 读取当前文件                           ││ - 分析项目结构                           ││ - 提取依赖关系                           ││ - 检索相似代码                           │└──────────────┬──────────────────────────┘               ↓┌─────────────────────────────────────────┐│ Step 2: AST解析与语义分析                ││ - Tree-sitter语法树解析                  ││ - JavaParser语义分析                     ││ - 构建代码知识图谱                       │└──────────────┬──────────────────────────┘               ↓┌─────────────────────────────────────────┐│ Step 3: Prompt工程                       ││ - 整合上下文信息                         ││ - 应用团队规范                           ││ - 构建结构化Prompt                       │└──────────────┬──────────────────────────┘               ↓┌─────────────────────────────────────────┐│ Step 4: 智能模型路由                     ││ - 评估任务复杂度                         ││ - 选择最优模型                           ││ - 成本控制                               │└──────────────┬──────────────────────────┘               ↓┌─────────────────────────────────────────┐│ Step 5: LLM生成/分析                     ││ - 调用选定模型                           ││ - 流式响应                               ││ - 实时反馈                               │└──────────────┬──────────────────────────┘               ↓┌─────────────────────────────────────────┐│ Step 6: 后处理与验证                     ││ - 代码格式化                             ││ - 编译验证                               ││ - 安全检查                               ││ - 单元测试运行                           │└──────────────┬──────────────────────────┘               ↓┌─────────────────────────────────────────┐│ Step 7: 结果返回与应用                   ││ - 显示建议/差异对比                      ││ - 用户确认                               ││ - 应用修改                               ││ - 记录反馈                               │└─────────────────────────────────────────┘

// 原始代码public class UserService {    public User findById(Long id) { ... }}// AST提取的信息{  "class": "UserService",  "methods": [    {      "name": "findById",      "returnType": "User",      "parameters": [{"name": "id", "type": "Long"}],      "visibility": "public"    }  ]}// 构建的Prompt更精准"为UserService类的findById方法生成单元测试..."

@Componentpublic class ControllerGenerator {    @Autowired    private ChatClient chatClient;    /**     * 根据Entity生成Controller     */    public String generateController(String entityCode, String entityName) {        String prompt = String.format("""            你是一个专业的Java开发工程师。请根据以下Entity类，生成完整的REST Controller。            要求：            1. 使用Spring Boot最佳实践            2. 包含CRUD接口（GET/POST/PUT/DELETE）            3. 使用@RestController和@RequestMapping            4. 添加Swagger注解            5. 包含异常处理            6. 使用@Service注入            7. 添加适当的日志            Entity类：            ```java            %s            ```            生成的Controller类名：%sController            只返回Java代码，不要其他说明。            """, entityCode, entityName);        return chatClient.prompt()            .system("你是一个资深的Java后端开发专家")            .user(prompt)            .call()            .content();    }}

@Entity@Table(name = "products")public class Product {    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;    @Column(nullable = false)    private String name;    private BigDecimal price;    private String description;    // getters and setters}

@RestController@RequestMapping("/api/products")@Tag(name = "Product Management", description = "产品管理接口")@Slf4jpublic class ProductController {    @Autowired    private ProductService productService;    @GetMapping    @Operation(summary = "获取所有产品")    public ResponseEntity<List<Product>> getAllProducts() {        log.info("Fetching all products");        List<Product> products = productService.findAll();        return ResponseEntity.ok(products);    }    @GetMapping("/{id}")    @Operation(summary = "根据ID获取产品")    public ResponseEntity<Product> getProductById(@PathVariable Long id) {        log.info("Fetching product with id: {}", id);        Product product = productService.findById(id)            .orElseThrow(() -> new ResourceNotFoundException("Product not found"));        return ResponseEntity.ok(product);    }    @PostMapping    @Operation(summary = "创建新产品")    public ResponseEntity<Product> createProduct(@Valid @RequestBody Product product) {        log.info("Creating new product: {}", product.getName());        Product savedProduct = productService.save(product);        return ResponseEntity.status(HttpStatus.CREATED).body(savedProduct);    }    @PutMapping("/{id}")    @Operation(summary = "更新产品")    public ResponseEntity<Product> updateProduct(            @PathVariable Long id,             @Valid @RequestBody Product product) {        log.info("Updating product with id: {}", id);        Product updatedProduct = productService.update(id, product);        return ResponseEntity.ok(updatedProduct);    }    @DeleteMapping("/{id}")    @Operation(summary = "删除产品")    public ResponseEntity<Void> deleteProduct(@PathVariable Long id) {        log.info("Deleting product with id: {}", id);        productService.delete(id);        return ResponseEntity.noContent().build();    }}

@Componentpublic class ServiceGenerator {    @Autowired    private ChatClient chatClient;    /**     * 生成Service接口和实现类     */    public ServiceCode generateService(String entityName, List<String> methods) {        String prompt = String.format("""            请为%s生成Service接口和实现类。            需要的方法：            %s            要求：            1. 使用@Transactional管理事务            2. 添加日志记录            3. 参数验证            4. 异常处理            5. 使用Optional处理空值            分别返回接口和实现类的代码。            """,             entityName,            String.join(", ", methods)        );        String response = chatClient.prompt()            .user(prompt)            .call()            .content();        return parseServiceCode(response);    }}

@Componentpublic class DtoMapperGenerator {    @Autowired    private ChatClient chatClient;    /**     * 生成DTO转换器     */    public String generateDtoMapper(String entityCode, String dtoCode) {        String prompt = String.format("""            请生成Entity到DTO的转换代码。            Entity:            ```java            %s            ```            DTO:            ```java            %s            ```            请使用MapStruct生成Mapper接口，包含：            1. toDto方法            2. toEntity方法            3. toDtoList方法            4. 自定义字段映射（如果有）            """, entityCode, dtoCode);        return chatClient.prompt()            .user(prompt)            .call()            .content();    }}

@Mapper(componentModel = "spring")public interface ProductMapper {    ProductMapper INSTANCE = Mappers.getMapper(ProductMapper.class);    @Mapping(source = "id", target = "productId")    @Mapping(source = "name", target = "productName")    ProductDto toDto(Product product);    @Mapping(source = "productId", target = "id")    @Mapping(source = "productName", target = "name")    Product toEntity(ProductDto dto);    List<ProductDto> toDtoList(List<Product> products);    default ProductDto withCustomMapping(Product product) {        ProductDto dto = toDto(product);        // 自定义逻辑        dto.setFormattedPrice(formatPrice(product.getPrice()));        return dto;    }}

@Componentpublic class CodeReviewService {    @Autowired    private ChatClient chatClient;    @Autowired    private StaticAnalyzer staticAnalyzer;    /**     * 综合代码审查     */    public CodeReviewResult review(String code, String filePath) {        List<ReviewIssue> issues = new ArrayList<>();        // 1. 静态分析（快速检测）        List<StaticIssue> staticIssues = staticAnalyzer.analyze(code);        issues.addAll(convertToReviewIssues(staticIssues));        // 2. AI深度审查（语义理解）        List<AiIssue> aiIssues = aiReview(code, filePath);        issues.addAll(aiIssues);        // 3. 按严重程度排序        issues.sort(Comparator.comparing(ReviewIssue::getSeverity).reversed());        return new CodeReviewResult(issues);    }    /**     * AI深度审查     */    private List<AiIssue> aiReview(String code, String filePath) {        String prompt = String.format("""            请审查以下Java代码，检查以下方面：            1. **潜在Bug**：空指针、资源泄漏、并发问题            2. **安全问题**：SQL注入、XSS、敏感信息泄露            3. **性能问题**：低效算法、不必要的对象创建            4. **代码规范**：命名、注释、复杂度            5. **最佳实践**：Spring Boot、设计模式            文件路径：%s            代码：            ```java            %s            ```            请以JSON数组格式返回发现的问题：            [              {                "type": "BUG/SECURITY/PERFORMANCE/STYLE/BEST_PRACTICE",                "severity": "HIGH/MEDIUM/LOW",                "line": 行号,                "message": "问题描述",                "suggestion": "修复建议"              }            ]            如果没有问题，返回空数组[]。            """, filePath, code);        String response = chatClient.prompt()            .system("你是一个资深的代码审查专家")            .user(prompt)            .call()            .content();        return parseAiIssues(response);    }}

// ❌ 有问题public String getUserName(User user) {    return user.getName().toUpperCase();  // NPE风险}// ✅ AI建议修复public String getUserName(User user) {    if (user == null || user.getName() == null) {        return "Unknown";    }    return user.getName().toUpperCase();}

// ❌ 有问题public String readFile(String path) throws IOException {    FileInputStream fis = new FileInputStream(path);    byte[] data = fis.readAllBytes();    return new String(data);  // fis未关闭}// ✅ AI建议修复public String readFile(String path) throws IOException {    try (FileInputStream fis = new FileInputStream(path)) {        byte[] data = fis.readAllBytes();        return new String(data);    }}

// ❌ 有问题String sql = "SELECT * FROM users WHERE name = '" + name + "'";Statement stmt = connection.createStatement();ResultSet rs = stmt.executeQuery(sql);// ✅ AI建议修复String sql = "SELECT * FROM users WHERE name = ?";PreparedStatement pstmt = connection.prepareStatement(sql);pstmt.setString(1, name);ResultSet rs = pstmt.executeQuery();

@Componentpublic class SecurityScanner {    @Autowired    private ChatClient chatClient;    /**     * 安全漏洞扫描     */    public List<SecurityVulnerability> scan(String code) {        String prompt = String.format("""            请扫描以下代码的安全漏洞：            检查项：            1. SQL注入            2. XSS攻击            3. CSRF漏洞            4. 硬编码密码/密钥            5. 不安全的反序列化            6. 路径遍历            7. XXE攻击            代码：            ```java            %s            ```            返回JSON格式的安全问题列表。            """, code);        String response = chatClient.prompt()            .user(prompt)            .call()            .content();        return parseVulnerabilities(response);    }}

@Componentpublic class CodeSmellDetector {    @Autowired    private ChatClient chatClient;    /**     * 检测代码异味并给出重构建议     */    public List<RefactoringSuggestion> detectSmells(String code) {        String prompt = String.format("""            请检测以下代码的"代码异味"，并给出重构建议：            常见的代码异味：            1. **长方法**：超过50行的方法            2. **大类**：超过500行的类            3. **重复代码**：相似的代码块            4. **过长参数列表**：超过5个参数            5. **过度耦合**：依赖过多            6. **魔法数字**：未命名的常量            7. **注释代码**：应该删除            代码：            ```java            %s            ```            对于每个发现的问题，提供：            1. 问题类型            2. 位置（行号）            3. 问题描述            4. 重构建议            5. 重构后的代码示例            以JSON格式返回。            """, code);        String response = chatClient.prompt()            .user(prompt)            .call()            .content();        return parseRefactoringSuggestions(response);    }}

@Componentpublic class ExtractMethodRefactorer {    @Autowired    private ChatClient chatClient;    /**     * 建议提取方法     */    public RefactoringResult suggestExtractMethod(String methodCode) {        String prompt = String.format("""            请分析以下方法，识别可以提取的子功能：            ```java            %s            ```            建议：            1. 哪些代码块可以提取为独立方法            2. 新方法的名字            3. 参数和返回值            4. 重构后的完整代码            目标：提高可读性和可维护性。            """, methodCode);        String response = chatClient.prompt()            .user(prompt)            .call()            .content();        return parseRefactoringResult(response);    }}

// ❌ 重构前：长方法public void processOrder(Order order) {    // 验证订单（20行）    if (order.getItems() == null || order.getItems().isEmpty()) {        throw new IllegalArgumentException("Order items cannot be empty");    }    for (OrderItem item : order.getItems()) {        if (item.getQuantity() <= 0) {            throw new IllegalArgumentException("Invalid quantity");        }        if (item.getPrice().compareTo(BigDecimal.ZERO) <= 0) {            throw new IllegalArgumentException("Invalid price");        }    }    // 计算总价（15行）    BigDecimal total = BigDecimal.ZERO;    for (OrderItem item : order.getItems()) {        BigDecimal itemTotal = item.getPrice()            .multiply(new BigDecimal(item.getQuantity()));        total = total.add(itemTotal);    }    if (order.getDiscount() != null) {        total = total.multiply(order.getDiscount());    }    order.setTotal(total);    // 保存订单（10行）    order.setStatus("PENDING");    order.setCreatedAt(LocalDateTime.now());    orderRepository.save(order);    // 发送通知（10行）    Notification notification = new Notification();    notification.setUserId(order.getUserId());    notification.setMessage("Order created: " + order.getId());    notificationService.send(notification);}// ✅ 重构后：提取方法public void processOrder(Order order) {    validateOrder(order);    calculateTotal(order);    saveOrder(order);    sendNotification(order);}private void validateOrder(Order order) {    if (order.getItems() == null || order.getItems().isEmpty()) {        throw new IllegalArgumentException("Order items cannot be empty");    }    for (OrderItem item : order.getItems()) {        if (item.getQuantity() <= 0) {            throw new IllegalArgumentException("Invalid quantity");        }        if (item.getPrice().compareTo(BigDecimal.ZERO) <= 0) {            throw new IllegalArgumentException("Invalid price");        }    }}private void calculateTotal(Order order) {    BigDecimal total = order.getItems().stream()        .map(item -> item.getPrice().multiply(new BigDecimal(item.getQuantity())))        .reduce(BigDecimal.ZERO, BigDecimal::add);    if (order.getDiscount() != null) {        total = total.multiply(order.getDiscount());    }    order.setTotal(total);}private void saveOrder(Order order) {    order.setStatus("PENDING");    order.setCreatedAt(LocalDateTime.now());    orderRepository.save(order);}private void sendNotification(Order order) {    Notification notification = new Notification();    notification.setUserId(order.getUserId());    notification.setMessage("Order created: " + order.getId());    notificationService.send(notification);}

@Componentpublic class TestGenerator {    @Autowired    private ChatClient chatClient;    /**     * 生成单元测试     */    public String generateUnitTest(String sourceCode, String className) {        String prompt = String.format("""            请为以下类生成完整的JUnit 5单元测试：            类名：%s            代码：            ```java            %s            ```            要求：            1. 使用JUnit 5和Mockito            2. 覆盖所有公共方法            3. 测试正常场景和边界情况            4. 使用@DisplayName描述测试用例            5. 包含setUp方法            6. 断言清晰明确            7. 测试覆盖率目标：80%%+            只返回测试代码。            """, className, sourceCode);        return chatClient.prompt()            .user(prompt)            .call()            .content();    }}

@ExtendWith(MockitoExtension.class)class ProductServiceTest {    @Mock    private ProductRepository productRepository;    @InjectMocks    private ProductService productService;    private Product testProduct;    @BeforeEach    void setUp() {        testProduct = new Product();        testProduct.setId(1L);        testProduct.setName("Test Product");        testProduct.setPrice(new BigDecimal("99.99"));    }    @Test    @DisplayName("应该成功创建产品")    void shouldCreateProduct() {        when(productRepository.save(any(Product.class))).thenReturn(testProduct);        Product result = productService.create(testProduct);        assertNotNull(result);        assertEquals("Test Product", result.getName());        verify(productRepository, times(1)).save(any(Product.class));    }    @Test    @DisplayName("产品名称为空时应该抛出异常")    void shouldThrowExceptionWhenNameIsEmpty() {        testProduct.setName("");        assertThrows(IllegalArgumentException.class, () -> {            productService.create(testProduct);        });    }    @Test    @DisplayName("应该根据ID找到产品")    void shouldFindProductById() {        when(productRepository.findById(1L)).thenReturn(Optional.of(testProduct));        Optional<Product> result = productService.findById(1L);        assertTrue(result.isPresent());        assertEquals(1L, result.get().getId());    }    @Test    @DisplayName("产品不存在时应该返回空")    void shouldReturnEmptyWhenProductNotFound() {        when(productRepository.findById(999L)).thenReturn(Optional.empty());        Optional<Product> result = productService.findById(999L);        assertFalse(result.isPresent());    }}

@Componentpublic class CoverageAnalyzer {    @Autowired    private ChatClient chatClient;    /**     * 分析测试覆盖率并提出改进建议     */    public CoverageReport analyzeCoverage(String sourceCode, String testCode) {        String prompt = String.format("""            请分析以下代码的测试覆盖率：            源代码：            ```java            %s            ```            测试代码：            ```java            %s            ```            请评估：            1. 当前覆盖率（百分比）            2. 未覆盖的代码路径            3. 缺失的边界条件测试            4. 建议新增的测试用例            以JSON格式返回分析报告。            """, sourceCode, testCode);        String response = chatClient.prompt()            .user(prompt)            .call()            .content();        return parseCoverageReport(response);    }}

@Componentpublic class CommentGenerator {    @Autowired    private ChatClient chatClient;    /**     * 为代码生成JavaDoc注释     */    public String generateJavaDoc(String code) {        String prompt = String.format("""            请为以下Java代码生成规范的JavaDoc注释：            ```java            %s            ```            要求：            1. 类级别注释：说明类的职责和使用场景            2. 方法级别注释：@param、@return、@throws            3. 复杂逻辑的行内注释            4. 使用中文注释            5. 遵循JavaDoc规范            返回带注释的完整代码。            """, code);        return chatClient.prompt()            .user(prompt)            .call()            .content();    }}

/** * 产品服务类 * <p> * 负责产品的业务逻辑处理，包括产品的创建、查询、更新和删除。 * 提供事务管理和数据验证功能。 * </p> * * @author AI Assistant * @version 1.0 * @since 2026-05-04 */@Service@Transactional@Slf4jpublic class ProductService {    @Autowired    private ProductRepository productRepository;    /**     * 创建新产品     * <p>     * 验证产品信息的合法性，保存到数据库，并记录日志。     * </p>     *     * @param product 产品信息，不能为null     * @return 保存后的产品对象，包含生成的ID     * @throws IllegalArgumentException 当产品信息不合法时抛出     * @throws DataAccessException 当数据库访问失败时抛出     */    public Product create(Product product) {        log.info("Creating new product: {}", product.getName());        // 参数验证        validateProduct(product);        // 保存到数据库        Product savedProduct = productRepository.save(product);        log.info("Product created successfully with id: {}", savedProduct.getId());        return savedProduct;    }    // ...}

@Componentpublic class CodeExplainer {    @Autowired    private ChatClient chatClient;    /**     * 用通俗语言解释代码     */    public String explainCode(String code, String targetAudience) {        String prompt = String.format("""            请用%s能理解的语言解释以下代码：            ```java            %s            ```            解释内容：            1. 这段代码的功能是什么            2. 主要逻辑流程            3. 关键技术和概念            4. 可能的应用场景            使用比喻和例子，避免专业术语。            """, targetAudience, code);        return chatClient.prompt()            .user(prompt)            .call()            .content();    }}

这段代码就像一个餐厅的服务员：1. **功能**：接收顾客的点单（创建产品），确认后交给厨房（保存到数据库）2. **流程**：   - 首先检查点单是否有效（验证参数）   - 然后把点单记录下来（保存到数据库）   - 最后告诉顾客点单成功（返回结果）3. **关键技术**：   - @Service：标记这是一个服务类   - @Transactional：确保要么全部成功，要么全部失败（原子性）   - log.info：记录日志，方便追踪问题4. **应用场景**：电商网站添加商品、社交平台发布帖子等

{  "name": "spring-ai-code-assistant",  "displayName": "Spring AI Code Assistant",  "version": "1.0.0",  "engines": {    "vscode": "^1.80.0"  },  "activationEvents": [    "onLanguage:java"  ],  "contributes": {    "commands": [      {        "command": "springai.generateController",        "title": "AI: Generate Controller"      },      {        "command": "springai.reviewCode",        "title": "AI: Review Code"      },      {        "command": "springai.generateTests",        "title": "AI: Generate Tests"      }    ],    "menus": {      "editor/context": [        {          "command": "springai.generateController",          "when": "editorLangId == java"        },        {          "command": "springai.reviewCode",          "when": "editorLangId == java"        }      ]    }  }}

import * as vscode from 'vscode';import axios from 'axios';export function activate(context: vscode.ExtensionContext) {    let generateControllerCmd = vscode.commands.registerCommand(        'springai.generateController',        async () => {            const editor = vscode.window.activeTextEditor;            if (!editor) return;            const code = editor.document.getText();            const fileName = editor.document.fileName;            vscode.window.withProgress(                { location: vscode.ProgressLocation.Notification },                async (progress) => {                    progress.report({ message: "Generating Controller..." });                    try {                        const response = await axios.post(                            'http://localhost:8080/api/code/generate/controller',                            { code, fileName }                        );                        const generatedCode = response.data.code;                        // 在新文件中显示                        const doc = await vscode.workspace.openTextDocument({                            content: generatedCode,                            language: 'java'                        });                        await vscode.window.showTextDocument(doc);                    } catch (error) {                        vscode.window.showErrorMessage('Generation failed');                    }                }            );        }    );    context.subscriptions.push(generateControllerCmd);}

<idea-plugin>    <id>com.example.springai.assistant</id>    <name>Spring AI Code Assistant</name>    <version>1.0.0</version>    <actions>        <actionid="GenerateController"                class="com.example.GenerateControllerAction"                text="AI: Generate Controller">            <add-to-groupgroup-id="EditorPopupMenu"anchor="last"/>        </action>    </actions></idea-plugin>

public class GenerateControllerAction extends AnAction {    @Override    public void actionPerformed(@NotNull AnActionEvent e) {        Project project = e.getProject();        Editor editor = e.getData(CommonDataKeys.EDITOR);        if (project == null || editor == null) return;        String code = editor.getDocument().getText();        ProgressManager.getInstance().runProcessWithProgressSynchronously(            () -> {                try {                    String generatedCode = callApi(code);                    ApplicationManager.getApplication().invokeLater(() -> {                        PsiFileFactory factory = PsiFileFactory.getInstance(project);                        PsiFile file = factory.createFileFromText(                            "GeneratedController.java",                            JavaFileType.INSTANCE,                            generatedCode                        );                        FileEditorManager.getInstance(project)                            .openFile(file.getVirtualFile(), true);                    });                } catch (Exception ex) {                    Messages.showErrorDialog(project, "Generation failed", "Error");                }                return null;            },            "Generating Controller...",            false,            project        );    }}

@Componentpublic class CachedCodeAssistant {    @Cacheable(value = "code_generation", key = "#code.hashCode()")    public String generateWithCache(String code, String task) {        return codeGenerator.generate(code, task);    }    @Cacheable(value = "code_review", key = "#code.hashCode()")    public CodeReviewResult reviewWithCache(String code) {        return codeReviewer.review(code);    }}

@Componentpublic class BatchCodeProcessor {    /**     * 批量生成代码（减少API调用次数）     */    public List<String> batchGenerate(List<CodeRequest> requests) {        // 合并相似的请求        Map<String, List<CodeRequest>> grouped = requests.stream()            .collect(Collectors.groupingBy(CodeRequest::getType));        List<String> results = new ArrayList<>();        for (Map.Entry<String, List<CodeRequest>> entry : grouped.entrySet()) {            String type = entry.getKey();            List<CodeRequest> similarRequests = entry.getValue();            // 一次性生成同类代码            String batchPrompt = buildBatchPrompt(similarRequests);            String batchResponse = chatClient.prompt()                .user(batchPrompt)                .call()                .content();            results.addAll(parseBatchResponse(batchResponse));        }        return results;    }}

开发者主导 → AI提供建议 → 开发者决定是否采纳

开发者 ↔ AI双向互动- AI主动提问澄清需求- AI提出多种方案供选择- AI解释推荐理由- 开发者反馈，AI学习调整

用户: "创建一个REST API，支持用户注册、登录、查询个人信息"Claude Code自主执行:1. 分析需求，设计API接口2. 创建Entity类 (User)3. 创建Repository接口4. 创建Service层5. 创建Controller层6. 生成单元测试7. 运行测试，修复Bug8. 生成API文档9. 提交PR，等待审核输出: 完整的、可运行的代码 + 测试 + 文档

1. 自然语言描述需求2. AI生成可视化界面原型3. 开发者调整布局4. AI生成后端代码5. 自动连接前后端6. 生成部署脚本