这篇文章介绍如何为代码审查 AI Agent 增加一套"AST 切片 + Map-Reduce"的大文件处理能力,用于突破大模型 Token 限制,实现对超大文件的智能代码审查。

读完后你将完成:

  1. 新增大文件配置属性,控制触发阈值和行为参数
  2. 实现 Token 估算服务,判断哪些文件需要切片
  3. 实现 AST 代码切片器(三级切片策略:方法级 → 语句级 → 行级回退)
  4. 实现切片数据模型
  5. 实现 Map-Reduce 审查服务(并行切片审查 → 去重 → 排序)
  6. 集成到现有审查流程中,自动触发

一、为什么需要 AST 切片 + Map-Reduce

大语言模型有上下文窗口限制。当一段代码太长(例如一个 3000 行的 Java 文件),直接送入大模型会被截断,导致:

  • 后面的代码完全丢失,AI 看不到完整逻辑
  • 即使勉强塞进去,模型对长上下文的注意力也会衰减
  • API 报错或产生幻觉

最粗暴的做法是按字符数硬切(比如每 2000 字符切一段),但这样会破坏代码结构:

// ❌ 错误做法:这样切出来的代码 AI 根本无法理解
切片1: public class UserService { public User findById(Long id) { return
切片2:  userRepository.findById(id).orElse(null); } public void createUser(Us

AST 切片 + Map-Reduce 的策略是:

  • 按方法粒度切片(AST 解析),每个切片都是语义完整的代码块
  • Map 阶段:并行调用 AI 对每个切片局部审查
  • Reduce 阶段:汇总所有结果,去重并按重要性排序

图片.png


二、核心设计

2.1 三级切片策略

级别名称触发条件说明
L1方法级切片默认首选以 Java 方法/构造器为粒度,附带包声明 + import + 类骨架作为上下文
L2语句级切片单个方法超过 maxSliceChars(6000 字符)进一步将方法体按语句分组拆分
L3行级回退切片非 Java 文件或语法解析失败按固定行数(80 行)切割,保留上下文重叠区(10 行)

2.2 方法级切片上下文

每个方法切片包含完整的上下文信息,确保 AI 能理解代码的完整背景:

package com.example;

import java.util.List;

public class UserService {
    private UserRepository userRepository;

    // === 以下是本次审查的目标代码 ===
    public User findById(Long id) {
        return userRepository.findById(id).orElse(null);
    }
}

2.3 Map-Reduce 数据处理

Map 阶段:

  • 使用固定大小线程池并行审查每个切片
  • 每个切片调用 AIModelService.reviewCode() 独立审查
  • 切片内的行号偏移量调整回原始文件行号

Reduce 阶段:

  • 去重:标题 Jaccard 相似度 >= 0.7 且行号差距 <= 3 行 → 视为同一问题,保留描述更详细的一条
  • 排序:严重程度 > 类别优先级(SECURITY > BUG > PERFORMANCE > MAINTAINABILITY > CODE\_STYLE)> 行号

三、后端实现(一步步)

3.1 增加配置属性 - LargeFileConfigProperties.java

创建文件:
src/main/java/com/codeguardian/config/LargeFileConfigProperties.java

package com.codeguardian.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * 大文件处理配置属性
 *
 * <p>控制AST切片 + Map-Reduce审查的触发阈值和行为参数</p>
 */
@Configuration
@ConfigurationProperties(prefix = "app.large-file")
@Data
public class LargeFileConfigProperties {

    /** 单次调用允许的最大代码Token数(超过此值触发Map-Reduce) */
    private int maxTokens = 2500;

    /** 单次调用允许的最大代码字符数(直接阈值,零表示不限制,由maxTokens计算) */
    private int maxCodeChars = 0;

    /** 单个AST切片的最大字符数(超过则进行语句级拆分) */
    private int maxSliceChars = 6000;

    /** 行级回退切片的行数 */
    private int chunkLines = 80;

    /** 行级切片上下文重叠行数 */
    private int overlapLines = 10;

    /** Map阶段最大并行切片数 */
    private int mapParallelism = 5;

    /** Reduce阶段去重标题相似度阈值(0.0 ~ 1.0) */
    private double dedupTitleSimilarity = 0.7;

    /** Reduce阶段去重的最大行号差距 */
    private int dedupLineProximity = 3;

    /** 是否启用大文件自动切片(关闭时超大文件将报错而非切片) */
    private boolean enabled = true;
}

关键设计说明:

  • maxTokens = 2500:单次审查最大 Token 数。为什么不是模型的上限(如 16384)?因为需要预留 Prompt 模板开销(~150 tokens)和输出空间(~1024 tokens),同时保留安全系数(0.85)。所以实际可用输入 Token = 模型最大上下文 × 0.85 - 150 - 1024。
  • maxCodeChars = 0:为 0 时使用 maxTokens 计算,按 3.5 字符 ≈ 1 token 折算。你也可以直接设置字符数阈值,更直观。
  • maxSliceChars = 6000:单个方法超过 6000 字符会被语句级二次拆分。这是为了应对某个方法体特别大的场景(比如某个 controller 方法写了 500 行)。
  • dedupTitleSimilarity = 0.7 + dedupLineProximity = 3:去重阈值。为什么是 0.7?因为不同切片审查同一个问题,AI 给出的标题会略有差异(如"SQL注入漏洞" vs "存在SQL注入风险"),Jaccard 相似度 0.7 已经能很好地区分"相同"与"不同"。

3.2 增加 application.yml 配置项

在 src/main/resources/application.yml 中添加:

app:
  # 大文件Map-Reduce审查配置
  large-file:
    enabled: true
    max-tokens: 2500               # 单次审查最大Token数(超过触发切片)
    max-code-chars: 0              # 直接字符数阈值(0=使用max-tokens计算)
    max-slice-chars: 6000          # 单个切片最大字符数
    chunk-lines: 80                # 回退行级切片行数
    overlap-lines: 10              # 切片上下文重叠行数
    map-parallelism: 5             # Map阶段并行度
    dedup-title-similarity: 0.7    # 去重标题相似度阈值
    dedup-line-proximity: 3        # 去重行号接近阈值

3.3 创建切片数据模型 - CodeSlice.java

创建文件:
src/main/java/com/codeguardian/model/CodeSlice.java

package com.codeguardian.model;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * 代码切片模型
 *
 * <p>表示经过AST解析后按方法/语句粒度切分的代码片段,
 * 用于大文件的Map-Reduce并行审查</p>
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CodeSlice {

    /** 切片在原始文件中的索引(从0开始) */
    private int sliceIndex;

    /** 切片名称(方法签名或类名,用于日志追踪) */
    private String sliceName;

    /** 切片代码内容(包含必要的上下文:imports + 类声明) */
    private String codeContent;

    /** 切片代码在原始文件中的起始行号(1-based) */
    private int startLine;

    /** 切片代码在原始文件中的结束行号(1-based) */
    private int endLine;

    /** 原始文件路径或标识 */
    private String originalFilePath;

    /** 切片类型:METHOD / STATEMENT / CHUNK(回退方式) */
    private String sliceType;
}

3.4 实现 Token 估算服务 - TokenEstimationService.java

创建文件:
src/main/java/com/codeguardian/service/review/TokenEstimationService.java

package com.codeguardian.service.review;

import com.codeguardian.config.AIConfigProperties;
import com.codeguardian.config.LargeFileConfigProperties;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

/**
 * Token估算服务
 *
 * <p>负责估算代码片段在送入大模型时会占用的Token数,
 * 以及判断文件是否需要触发AST切片+Map-Reduce审查</p>
 *
 * <h3>估算策略</h3>
 * <ul>
 *   <li>代码文本:约 3.5 个字符 ≈ 1 token(保守估计,代码空格/缩进较多)</li>
 *   <li>提示词模板开销:约 600 字符 ≈ 150 tokens</li>
 *   <li>输出预留:取模型 max-tokens 配置值或默认1024</li>
 *   <li>安全系数:0.85,避免边界情况导致截断</li>
 * </ul>
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class TokenEstimationService {

    /** 1个Token大约对应多少个字符(代码场景约3.5,比英文文本的4更保守) */
    private static final double CHARS_PER_TOKEN = 3.5;

    /** prompt模板固定开销估算(token数) */
    private static final int PROMPT_OVERHEAD_TOKENS = 150;

    /** 安全系数:实际可用上下文 = 模型最大上下文 × SAFETY_FACTOR */
    private static final double SAFETY_FACTOR = 0.85;

    /** 默认模型最大Token数映射 */
    private static final Map<String, Integer> DEFAULT_MODEL_MAX_TOKENS = new HashMap<>();
    static {
        DEFAULT_MODEL_MAX_TOKENS.put("gpt-3.5-turbo", 4096);
        DEFAULT_MODEL_MAX_TOKENS.put("gpt-4", 8192);
        DEFAULT_MODEL_MAX_TOKENS.put("gpt-4-turbo", 128000);
        DEFAULT_MODEL_MAX_TOKENS.put("gpt-4o", 128000);
        DEFAULT_MODEL_MAX_TOKENS.put("qwen-turbo", 8192);
        DEFAULT_MODEL_MAX_TOKENS.put("qwen-plus", 32768);
        DEFAULT_MODEL_MAX_TOKENS.put("qwen-max", 32768);
        DEFAULT_MODEL_MAX_TOKENS.put("qwen3-max", 32768);
        DEFAULT_MODEL_MAX_TOKENS.put("deepseek-r1:8b", 16384);
        DEFAULT_MODEL_MAX_TOKENS.put("deepseek-r1", 32768);
        DEFAULT_MODEL_MAX_TOKENS.put("deepseek-chat", 65536);
        DEFAULT_MODEL_MAX_TOKENS.put("deepseek-coder", 16384);
    }

    /** 兜底最大Token数 */
    private static final int FALLBACK_MAX_TOKENS = 4096;

    private final AIConfigProperties aiConfigProperties;
    private final LargeFileConfigProperties largeFileConfig;

    /**
     * 估算代码内容的Token数
     */
    public int estimateTokens(String codeContent) {
        if (codeContent == null || codeContent.isEmpty()) {
            return 0;
        }
        return (int) Math.ceil(codeContent.length() / CHARS_PER_TOKEN);
    }

    /**
     * 获取指定模型的可用Token上限(用于输入代码)
     *
     * <p>可用Token = 模型最大上下文 × 安全系数 - 提示词开销 - 输出预留</p>
     */
    public int getAvailableInputTokens(String modelName) {
        int maxTokens = DEFAULT_MODEL_MAX_TOKENS.getOrDefault(
                modelName != null ? modelName.toLowerCase() : "",
                FALLBACK_MAX_TOKENS
        );

        int outputTokens = 1024;
        int available = (int) ((maxTokens) * SAFETY_FACTOR)
                - PROMPT_OVERHEAD_TOKENS - outputTokens;
        return Math.max(available, 500);
    }

    /**
     * 获取可用输入Token转字符的上限
     */
    public int getAvailableInputChars(String modelName) {
        return (int) (getAvailableInputTokens(modelName) * CHARS_PER_TOKEN);
    }

    /**
     * 判断代码是否超过Token限制,需要触发Map-Reduce审查
     */
    public boolean isLargeFile(String codeContent, String modelName) {
        if (codeContent == null || codeContent.isEmpty()) {
            return false;
        }
        if (!largeFileConfig.isEnabled()) {
            return false;
        }
        // 优先使用直接字符数阈值
        if (largeFileConfig.getMaxCodeChars() > 0) {
            boolean isLarge = codeContent.length() > largeFileConfig.getMaxCodeChars();
            if (isLarge) {
                log.info("检测到大文件: 代码长度={}, 配置阈值={}字符",
                        codeContent.length(), largeFileConfig.getMaxCodeChars());
            }
            return isLarge;
        }
        // 使用Token估算
        int estimatedTokens = estimateTokens(codeContent);
        int configThreshold = largeFileConfig.getMaxTokens();
        int availableTokens = Math.min(configThreshold, getAvailableInputTokens(modelName));
        boolean isLarge = estimatedTokens > availableTokens;
        if (isLarge) {
            log.info("检测到大文件: 估算Token={}, 可用Token={}, 代码长度={}字符, 模型={}",
                    estimatedTokens, availableTokens, codeContent.length(), modelName);
        }
        return isLarge;
    }

    /**
     * 判断单个代码块是否本身也过大,需要进一步切分
     */
    public boolean isSingleSliceTooLarge(String sliceContent) {
        return sliceContent != null && sliceContent.length() > largeFileConfig.getMaxSliceChars();
    }
}

为什么用 3.5 而不是 4?

英文文本大约是 4 个字符 = 1 token。但代码中有大量空格、缩进、括号等符号,这些更接近"字符密集"类型。实测经验表明 3.5 字符/token 更贴近实际编码场景(尤其在 Java 这种"又长又啰嗦"的语言中)。

3000 行 Java 文件大约多少 token?

假设每行平均 40 个字符(含缩进),3000 × 40 = 120,000 字符 ÷ 3.5 ≈ 34,285 tokens。对于 qwen3-max(32768 上下文),已经接近上限。对于 DeepSeek-R1 8B 本地模型(16384),远远超过。所以这个文件必定触发切片。

3.5 实现 AST 代码切片器 - ASTCodeSlicer.java

这是整个功能的核心。创建文件:
src/main/java/com/codeguardian/service/review/ASTCodeSlicer.java

package com.codeguardian.service.review;

import com.codeguardian.model.CodeSlice;
import com.codeguardian.config.LargeFileConfigProperties;
import com.github.javaparser.JavaParser;
import com.github.javaparser.ParseResult;
import com.github.javaparser.ParserConfiguration;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.body.*;
import com.github.javaparser.ast.expr.AnnotationExpr;
import com.github.javaparser.ast.nodeTypes.NodeWithRange;
import com.github.javaparser.ast.stmt.Statement;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * AST代码切片器
 *
 * <p>核心功能:利用JavaParser以"方法"为粒度对代码进行AST切片,
 * 避免简单的按字符截断,保证每个切片都是语义完整的代码块。</p>
 *
 * <h3>切片策略(三级)</h3>
 * <ol>
 *   <li><b>方法级切片(首选)</b>:解析CompilationUnit,提取每个方法作为独立切片</li>
 *   <li><b>语句级切片(超大方法回退)</b>:对超过阈值的方法进一步按语句拆分</li>
 *   <li><b>行级切片(非Java语言回退)</b>:按固定行数切割,保留上下文重叠区</li>
 * </ol>
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class ASTCodeSlicer {

    private static final String JAVA_EXT = ".java";
    private static final String SLICE_TYPE_METHOD = "METHOD";
    private static final String SLICE_TYPE_STATEMENT = "STATEMENT";
    private static final String SLICE_TYPE_CHUNK = "CHUNK";

    private final TokenEstimationService tokenEstimationService;
    private final LargeFileConfigProperties largeFileConfig;

    /**
     * 对代码文件进行AST切片
     */
    public List<CodeSlice> slice(String codeContent, String filePath) {
        return slice(codeContent, filePath, null);
    }

    public List<CodeSlice> slice(String codeContent, String filePath, String language) {
        if (codeContent == null || codeContent.trim().isEmpty()) {
            return Collections.emptyList();
        }

        if (isJavaFile(filePath, language)) {
            return sliceJava(codeContent, filePath);
        }
        return fallbackLineChunking(codeContent, filePath);
    }

    private boolean isJavaFile(String filePath, String language) {
        if (filePath != null && filePath.toLowerCase().endsWith(JAVA_EXT)) {
            return true;
        }
        if (language != null) {
            return language.equalsIgnoreCase("java");
        }
        return false;
    }

    // ==================== Java AST 切片 ====================

    private List<CodeSlice> sliceJava(String codeContent, String filePath) {
        List<CodeSlice> slices = new ArrayList<>();
        try {
            ParserConfiguration config = new ParserConfiguration();
            config.setLanguageLevel(ParserConfiguration.LanguageLevel.JAVA_17);
            JavaParser parser = new JavaParser(config);

            ParseResult<CompilationUnit> result = parser.parse(codeContent);
            if (!result.isSuccessful() || result.getResult().isEmpty()) {
                log.warn("Java代码解析失败,回退到行级切片: {}", filePath);
                return fallbackLineChunking(codeContent, filePath);
            }

            CompilationUnit cu = result.getResult().get();
            String packageAndImports = extractPackageAndImports(cu, codeContent);

            List<TypeDeclaration<?>> types = findAllTypeDeclarations(cu);
            for (TypeDeclaration<?> type : types) {
                String classContext = buildClassContext(type);
                List<BodyDeclaration<?>> members = type.getMembers();
                if (members == null || members.isEmpty()) continue;

                for (BodyDeclaration<?> member : members) {
                    if (member instanceof MethodDeclaration method) {
                        slices.addAll(sliceMethod(packageAndImports, classContext,
                                method, codeContent, filePath, slices.size()));
                    } else if (member instanceof ConstructorDeclaration ctor) {
                        slices.addAll(sliceConstructor(packageAndImports, classContext,
                                ctor, codeContent, filePath, slices.size()));
                    }
                }
            }

            if (slices.isEmpty()) {
                return fallbackLineChunking(codeContent, filePath);
            }

            log.info("Java AST切片完成: 文件={}, 切片数={}", filePath, slices.size());
        } catch (Exception e) {
            log.error("AST切片异常,回退到行级切片: {}", filePath, e);
            return fallbackLineChunking(codeContent, filePath);
        }
        return slices;
    }

    /**
     * 对单个方法进行切片
     */
    private List<CodeSlice> sliceMethod(String packageAndImports, String classContext,
                                         MethodDeclaration method, String originalCode,
                                         String filePath, int baseIndex) {
        List<CodeSlice> slices = new ArrayList<>();
        String methodBody = extractNodeSource(method, originalCode);
        int startLine = method.getBegin().map(p -> p.line).orElse(1);
        int endLine = method.getEnd().map(p -> p.line).orElse(startLine);
        String methodSignature = method.getDeclarationAsString(false, false, true);

        if (tokenEstimationService.isSingleSliceTooLarge(methodBody)) {
            // 超大方法 → 语句级拆分
            slices.addAll(sliceLargeMethod(packageAndImports, classContext, method,
                    methodBody, originalCode, filePath, baseIndex));
        } else {
            // 正常大小的方法 → 直接作为一个切片
            String sliceCode = buildSliceCode(packageAndImports, classContext, methodBody);
            slices.add(CodeSlice.builder()
                    .sliceIndex(baseIndex)
                    .sliceName(methodSignature)
                    .codeContent(sliceCode)
                    .startLine(startLine)
                    .endLine(endLine)
                    .originalFilePath(filePath)
                    .sliceType(SLICE_TYPE_METHOD)
                    .build());
        }
        return slices;
    }

    /**
     * 对构造器进行切片
     */
    private List<CodeSlice> sliceConstructor(String packageAndImports, String classContext,
                                              ConstructorDeclaration ctor, String originalCode,
                                              String filePath, int baseIndex) {
        List<CodeSlice> slices = new ArrayList<>();
        String ctorBody = extractNodeSource(ctor, originalCode);
        int startLine = ctor.getBegin().map(p -> p.line).orElse(1);
        int endLine = ctor.getEnd().map(p -> p.line).orElse(startLine);
        String signature = ctor.getDeclarationAsString(false, false, true);

        String sliceCode = buildSliceCode(packageAndImports, classContext, ctorBody);
        slices.add(CodeSlice.builder()
                .sliceIndex(baseIndex)
                .sliceName(signature)
                .codeContent(sliceCode)
                .startLine(startLine)
                .endLine(endLine)
                .originalFilePath(filePath)
                .sliceType(SLICE_TYPE_METHOD)
                .build());
        return slices;
    }

    // ==================== 语句级二次拆分 ====================

    private List<CodeSlice> sliceLargeMethod(String packageAndImports, String classContext,
                                              MethodDeclaration method, String methodBody,
                                              String originalCode, String filePath, int baseIndex) {
        List<CodeSlice> slices = new ArrayList<>();
        int methodStartLine = method.getBegin().map(p -> p.line).orElse(1);

        method.getBody().ifPresent(body -> {
            List<Statement> statements = body.getStatements();
            if (statements.isEmpty()) return;

            List<List<Statement>> groups = groupStatements(statements);

            for (int i = 0; i < groups.size(); i++) {
                List<Statement> group = groups.get(i);
                int groupStartLine = group.get(0).getBegin()
                        .map(p -> p.line).orElse(methodStartLine + 1);
                int groupEndLine = group.get(group.size() - 1).getEnd()
                        .map(p -> p.line).orElse(groupStartLine);

                StringBuilder stmtCode = new StringBuilder();
                stmtCode.append(method.getDeclarationAsString(false, false, true))
                        .append(" {\n");
                for (Statement stmt : group) {
                    stmtCode.append(extractNodeSource(stmt, originalCode)).append("\n");
                }
                stmtCode.append("}\n");

                String sliceCode = buildSliceCode(packageAndImports, classContext, stmtCode.toString());
                slices.add(CodeSlice.builder()
                        .sliceIndex(baseIndex + i)
                        .sliceName(method.getNameAsString() + " (语句组" + (i + 1) + ")")
                        .codeContent(sliceCode)
                        .startLine(groupStartLine)
                        .endLine(groupEndLine)
                        .originalFilePath(filePath)
                        .sliceType(SLICE_TYPE_STATEMENT)
                        .build());
            }
        });
        return slices;
    }

    /**
     * 将语句按大小分组
     */
    private List<List<Statement>> groupStatements(List<Statement> statements) {
        List<List<Statement>> groups = new ArrayList<>();
        List<Statement> currentGroup = new ArrayList<>();
        int currentSize = 0;

        for (Statement stmt : statements) {
            int stmtSize = estimateStatementSize(stmt);
            if (currentSize + stmtSize > largeFileConfig.getMaxSliceChars() / 2
                    && !currentGroup.isEmpty()) {
                groups.add(currentGroup);
                currentGroup = new ArrayList<>();
                currentSize = 0;
            }
            currentGroup.add(stmt);
            currentSize += stmtSize;
        }
        if (!currentGroup.isEmpty()) {
            groups.add(currentGroup);
        }
        return groups;
    }

    private int estimateStatementSize(Statement stmt) {
        return stmt.getEnd().map(p -> p.column).orElse(0)
                - stmt.getBegin().map(p -> p.column).orElse(0) + 1;
    }

    // ==================== 行级回退切片 ====================

    /**
     * 对非Java代码或语法解析失败时的行级回退切片
     */
    private List<CodeSlice> fallbackLineChunking(String codeContent, String filePath) {
        List<CodeSlice> slices = new ArrayList<>();
        String[] lines = codeContent.split("\r?\n", -1);

        if (lines.length <= largeFileConfig.getChunkLines()) {
            slices.add(CodeSlice.builder()
                    .sliceIndex(0)
                    .sliceName("完整文件")
                    .codeContent(codeContent)
                    .startLine(1)
                    .endLine(lines.length)
                    .originalFilePath(filePath)
                    .sliceType(SLICE_TYPE_CHUNK)
                    .build());
            return slices;
        }

        int chunkIndex = 0;
        int currentLine = 0;
        while (currentLine < lines.length) {
            int chunkStart = currentLine;
            int chunkEnd = Math.min(currentLine + largeFileConfig.getChunkLines(), lines.length);
            int actualStartLine = chunkStart + 1;
            int actualEndLine = chunkEnd;

            StringBuilder chunkBuilder = new StringBuilder();
            // 添加上文重叠区(帮助AI理解上下文)
            if (chunkStart > 0) {
                chunkBuilder.append("// === 上文(来自行")
                        .append(Math.max(1, chunkStart - largeFileConfig.getOverlapLines() + 1))
                        .append("-").append(chunkStart)
                        .append(") ===\n");
                for (int i = Math.max(0, chunkStart - largeFileConfig.getOverlapLines());
                        i < chunkStart; i++) {
                    chunkBuilder.append(lines[i]).append("\n");
                }
            }

            for (int i = chunkStart; i < chunkEnd; i++) {
                chunkBuilder.append(lines[i]).append("\n");
            }

            slices.add(CodeSlice.builder()
                    .sliceIndex(chunkIndex)
                    .sliceName("切片" + (chunkIndex + 1)
                            + " (行" + actualStartLine + "-" + actualEndLine + ")")
                    .codeContent(chunkBuilder.toString())
                    .startLine(actualStartLine)
                    .endLine(actualEndLine)
                    .originalFilePath(filePath)
                    .sliceType(SLICE_TYPE_CHUNK)
                    .build());

            chunkIndex++;
            currentLine += largeFileConfig.getChunkLines();
        }

        log.info("行级回退切片完成: 文件={}, 行数={}, 切片数={}",
                filePath, lines.length, slices.size());
        return slices;
    }

    // ==================== 辅助方法 ====================

    /**
     * 提取包声明和import语句(所有切片的公共上下文)
     */
    private String extractPackageAndImports(CompilationUnit cu, String originalCode) {
        StringBuilder sb = new StringBuilder();
        cu.getPackageDeclaration().ifPresent(pkg -> {
            sb.append(extractNodeSource(pkg, originalCode));
            if (!sb.toString().endsWith("\n")) sb.append("\n");
        });
        if (!cu.getImports().isEmpty()) {
            if (sb.length() > 0) sb.append("\n");
            for (var imp : cu.getImports()) {
                sb.append(extractNodeSource(imp, originalCode));
                if (!sb.toString().endsWith("\n")) sb.append("\n");
            }
        }
        return sb.toString();
    }

    /**
     * 构建类的上下文骨架(类声明 + 注解 + 字段)
     */
    private String buildClassContext(TypeDeclaration<?> type) {
        StringBuilder sb = new StringBuilder();
        for (AnnotationExpr ann : type.getAnnotations()) {
            sb.append(ann.toString()).append("\n");
        }

        String modifiers = type.getModifiers().stream()
                .map(mod -> mod.getKeyword().asString())
                .collect(Collectors.joining(" "));
        if (!modifiers.isEmpty()) sb.append(modifiers).append(" ");

        if (type instanceof ClassOrInterfaceDeclaration ci) {
            if (ci.isInterface()) sb.append("interface ");
            else sb.append("class ");
            sb.append(ci.getNameAsString());
            ci.getTypeParameters().ifNonEmpty(params ->
                    sb.append("<").append(params.stream()
                            .map(Object::toString)
                            .collect(Collectors.joining(", "))).append(">"));
        } else if (type instanceof EnumDeclaration) {
            sb.append("enum ").append(type.getNameAsString());
        } else {
            sb.append(type.getNameAsString());
        }

        sb.append(" {\n");

        // 字段声明作为上下文保留
        for (FieldDeclaration field : type.getFields()) {
            sb.append("    ").append(field.toString()).append("\n");
        }
        sb.append("\n");
        return sb.toString();
    }

    /**
     * 组合完整的切片代码:包导入 + 类上下文 + 方法体
     */
    private String buildSliceCode(String packageAndImports, String classContext,
                                   String memberBody) {
        StringBuilder sb = new StringBuilder();
        sb.append(packageAndImports);
        if (sb.length() > 0 && !sb.toString().endsWith("\n\n")) {
            sb.append("\n");
        }
        sb.append(classContext);
        sb.append("    // === 以下是本次审查的目标代码 ===\n");
        sb.append("    ").append(memberBody);
        sb.append("}\n");
        return sb.toString();
    }

    /**
     * 安全查找所有TypeDeclaration(避免泛型类型推断问题)
     */
    @SuppressWarnings("unchecked")
    private List<TypeDeclaration<?>> findAllTypeDeclarations(CompilationUnit cu) {
        return cu.findAll(Node.class).stream()
                .filter(node -> node instanceof TypeDeclaration)
                .map(node -> (TypeDeclaration<?>) node)
                .collect(Collectors.toList());
    }

    /**
     * 从原始代码中根据AST节点位置精确提取源码文本
     */
    private String extractNodeSource(Node node, String originalCode) {
        if (node instanceof NodeWithRange) {
            return node.getRange()
                    .map(range -> {
                        String[] lines = originalCode.split("\r?\n", -1);
                        int startLine = range.begin.line - 1;
                        int endLine = range.end.line - 1;
                        int startCol = range.begin.column - 1;
                        int endCol = range.end.column - 1;

                        StringBuilder sb = new StringBuilder();
                        for (int i = startLine; i <= endLine && i < lines.length; i++) {
                            String line = lines[i];
                            if (i == startLine && i == endLine) {
                                sb.append(line, startCol, Math.min(endCol, line.length()));
                            } else if (i == startLine) {
                                sb.append(line.substring(startCol));
                            } else if (i == endLine) {
                                sb.append(line, 0, Math.min(endCol, line.length()));
                            } else {
                                sb.append(line);
                            }
                            if (i < endLine) sb.append("\n");
                        }
                        return sb.toString();
                    })
                    .orElse(node.toString());
        }
        return node.toString();
    }
}

extractNodeSource** 为什么不用 **node.toString()**?**

JavaParser 的 toString() 会用自己的格式器重新格式化代码,导致缩进、换行等与原始代码不一致。而 extractNodeSource 直接从原始代码字符串中根据 AST 节点的行号/列号范围截取文本,保留了原始的代码格式和风格。这对于后续的行号映射至关重要。

3.6 实现 Map-Reduce 审查服务 - MapReduceReviewService.java

创建文件:
src/main/java/com/codeguardian/service/review/MapReduceReviewService.java

package com.codeguardian.service.review;

import com.codeguardian.entity.Finding;
import com.codeguardian.enums.SeverityEnum;
import com.codeguardian.config.LargeFileConfigProperties;
import com.codeguardian.model.CodeSlice;
import com.codeguardian.service.AIModelService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.*;

/**
 * Map-Reduce大文件审查服务
 *
 * <p>采用AST切片 + Map-Reduce策略处理超过Token限制的大文件代码审查。</p>
 *
 * <h3>处理流程</h3>
 * <ol>
 *   <li><b>检测+切片</b>:TokenEstimationService检测大文件,ASTCodeSlicer按方法粒度切片</li>
 *   <li><b>Map阶段</b>:并行调用AI对每个切片进行局部审查</li>
 *   <li><b>Reduce阶段</b>:汇总结果,去重,按重要性排序,生成最终报告</li>
 * </ol>
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class MapReduceReviewService {

    private final AIModelService aiModelService;
    private final ASTCodeSlicer astCodeSlicer;
    private final LargeFileConfigProperties largeFileConfig;

    /** 类别排序权重(值越小越优先) */
    private static final Map<String, Integer> CATEGORY_PRIORITY = new LinkedHashMap<>();
    static {
        CATEGORY_PRIORITY.put("SECURITY", 0);
        CATEGORY_PRIORITY.put("BUG", 1);
        CATEGORY_PRIORITY.put("PERFORMANCE", 2);
        CATEGORY_PRIORITY.put("MAINTAINABILITY", 3);
        CATEGORY_PRIORITY.put("CODE_STYLE", 4);
    }

    /** 切片审查专用线程池 */
    private ExecutorService sliceReviewExecutor;

    @jakarta.annotation.PostConstruct
    public void init() {
        int parallelism = Math.max(1, Math.min(largeFileConfig.getMapParallelism(),
                Runtime.getRuntime().availableProcessors() * 2));
        this.sliceReviewExecutor = Executors.newFixedThreadPool(parallelism, r -> {
            Thread t = new Thread(r, "slice-review-");
            t.setDaemon(true);
            return t;
        });
        log.info("切片审查线程池初始化: 并行度={}", parallelism);
    }

    @jakarta.annotation.PreDestroy
    public void destroy() {
        log.info("关闭切片审查线程池...");
        sliceReviewExecutor.shutdown();
    }

    /**
     * 执行Map-Reduce审查(核心入口)
     */
    public List<Finding> reviewLargeFile(String codeContent, String language,
                                          String modelProvider, boolean enableRag,
                                          String filePath, List<Finding> existingFindings) {
        log.info("========== Map-Reduce大文件审查开始 ==========");
        log.info("文件: {}, 语言: {}, 代码长度: {} 字符",
                filePath, language, codeContent.length());

        long startTime = System.currentTimeMillis();

        // Step 1: AST切片
        List<CodeSlice> slices = astCodeSlicer.slice(codeContent, filePath);
        log.info("[切片完成] 共 {} 个切片", slices.size());

        if (slices.isEmpty()) {
            log.warn("切片结果为空,回退到原始审查");
            return aiModelService.reviewCode(codeContent, language,
                    modelProvider, enableRag, existingFindings);
        }

        // Step 2: Map阶段 - 并行审查每个切片
        List<Finding> allFindings = mapPhase(slices, language,
                modelProvider, enableRag, existingFindings);
        log.info("[Map阶段完成] 共发现 {} 个原始问题", allFindings.size());

        // Step 3: Reduce阶段 - 去重 + 排序
        List<Finding> finalFindings = reducePhase(allFindings);

        long totalTime = System.currentTimeMillis() - startTime;
        log.info("========== Map-Reduce审查完成: 总耗时{}ms, 原始{}→最终{} ==========",
                totalTime, allFindings.size(), finalFindings.size());

        return finalFindings;
    }

    // ==================== Map 阶段 ====================

    private List<Finding> mapPhase(List<CodeSlice> slices, String language,
                                    String modelProvider, boolean enableRag,
                                    List<Finding> existingFindings) {
        List<CompletableFuture<List<Finding>>> futures = new ArrayList<>();

        for (CodeSlice slice : slices) {
            CompletableFuture<List<Finding>> future = CompletableFuture.supplyAsync(() -> {
                try {
                    log.info("[Map] 审查切片 [{}/{}]: {} (行{}-{})",
                            slice.getSliceIndex() + 1, slices.size(),
                            slice.getSliceName(),
                            slice.getStartLine(), slice.getEndLine());
                    return reviewSlice(slice, language, modelProvider, enableRag);
                } catch (Exception e) {
                    log.error("[Map] 切片审查失败: {} (行{}-{})",
                            slice.getSliceName(),
                            slice.getStartLine(), slice.getEndLine(), e);
                    return new ArrayList<Finding>();
                }
            }, sliceReviewExecutor);
            futures.add(future);
        }

        // 等待所有切片审查完成(120秒超时)
        List<Finding> allFindings = new ArrayList<>();
        for (int i = 0; i < futures.size(); i++) {
            try {
                List<Finding> sliceFindings = futures.get(i).get(120, TimeUnit.SECONDS);
                if (sliceFindings != null) {
                    // 关键步骤:将切片内的行号偏移量调整回原始文件行号
                    int lineOffset = slices.get(i).getStartLine() - 1;
                    for (Finding f : sliceFindings) {
                        adjustLineNumbers(f, lineOffset);
                    }
                    allFindings.addAll(sliceFindings);
                }
            } catch (TimeoutException e) {
                log.error("[Map] 切片[{}] 审查超时", i);
            } catch (Exception e) {
                log.error("[Map] 获取切片[{}] 审查结果失败", i, e);
            }
        }
        return allFindings;
    }

    private List<Finding> reviewSlice(CodeSlice slice, String language,
                                       String modelProvider, boolean enableRag) {
        long start = System.currentTimeMillis();
        List<Finding> findings = aiModelService.reviewCode(
                slice.getCodeContent(), language, modelProvider, enableRag, null
        );
        for (Finding f : findings) {
            f.setSource("AI-MapReduce");
            if (f.getLocation() == null || f.getLocation().isBlank()) {
                f.setLocation(slice.getOriginalFilePath() + ":" + slice.getStartLine());
            }
        }
        log.debug("[Map] 切片 {} 审查完成, 耗时{}ms, 发现{}个问题",
                slice.getSliceName(),
                System.currentTimeMillis() - start, findings.size());
        return findings;
    }

    /**
     * 调整Finding行号:从切片内行号(以1开始) → 原始文件行号
     */
    private void adjustLineNumbers(Finding finding, int lineOffset) {
        if (finding.getStartLine() != null) {
            finding.setStartLine(finding.getStartLine() + lineOffset);
        }
        if (finding.getEndLine() != null) {
            finding.setEndLine(finding.getEndLine() + lineOffset);
        }
    }

    // ==================== Reduce 阶段 ====================

    private List<Finding> reducePhase(List<Finding> rawFindings) {
        if (rawFindings == null || rawFindings.isEmpty()) {
            return new ArrayList<>();
        }

        // Step 1: 去重
        List<Finding> deduped = deduplicateFindings(rawFindings);
        log.info("[Reduce-去重] {} → {}(去重后)", rawFindings.size(), deduped.size());

        // Step 2: 排序
        deduped.sort(this::compareFindings);
        log.info("[Reduce-排序] 按严重程度和类别优先级完成排序");

        return deduped;
    }

    /**
     * 去重:标题Jaccard相似度 > 0.7 且 位置接近(≤ 3行)→ 视为同一问题
     */
    List<Finding> deduplicateFindings(List<Finding> findings) {
        if (findings.size() <= 1) {
            return new ArrayList<>(findings);
        }

        List<Finding> result = new ArrayList<>();
        boolean[] merged = new boolean[findings.size()];

        for (int i = 0; i < findings.size(); i++) {
            if (merged[i]) continue;
            Finding current = findings.get(i);
            Finding best = current;

            for (int j = i + 1; j < findings.size(); j++) {
                if (merged[j]) continue;
                Finding other = findings.get(j);
                double titleSim = computeTitleSimilarity(
                        current.getTitle(), other.getTitle());
                boolean linesClose = areLinesClose(current, other);

                if (titleSim >= largeFileConfig.getDedupTitleSimilarity()
                        && linesClose) {
                    merged[j] = true;
                    best = mergeTwoFindings(best, other);
                }
            }
            result.add(best);
            merged[i] = true;
        }
        return result;
    }

    /**
     * 计算Jaccard相似度(bigram分词,适合中英文混合)
     */
    private double computeTitleSimilarity(String title1, String title2) {
        if (title1 == null || title2 == null) return 0.0;
        if (title1.equals(title2)) return 1.0;

        Set<String> words1 = tokenize(title1);
        Set<String> words2 = tokenize(title2);

        if (words1.isEmpty() && words2.isEmpty()) return 1.0;
        if (words1.isEmpty() || words2.isEmpty()) return 0.0;

        Set<String> union = new HashSet<>(words1);
        union.addAll(words2);

        Set<String> intersection = new HashSet<>(words1);
        intersection.retainAll(words2);

        return (double) intersection.size() / union.size();
    }

    private Set<String> tokenize(String text) {
        Set<String> tokens = new HashSet<>();
        text = text.toLowerCase().trim();
        // bigram
        for (int i = 0; i < text.length() - 1; i++) {
            tokens.add(text.substring(i, i + 2));
        }
        // unigram
        for (char c : text.toCharArray()) {
            if (Character.isLetterOrDigit(c)) {
                tokens.add(String.valueOf(c));
            }
        }
        return tokens;
    }

    private boolean areLinesClose(Finding f1, Finding f2) {
        Integer s1 = f1.getStartLine();
        Integer s2 = f2.getStartLine();
        if (s1 == null || s2 == null) return false;
        return Math.abs(s1 - s2) <= largeFileConfig.getDedupLineProximity();
    }

    /**
     * 合并两个相似Finding,保留描述更详细的一条
     */
    private Finding mergeTwoFindings(Finding f1, Finding f2) {
        int len1 = (f1.getDescription() != null ? f1.getDescription().length() : 0)
                + (f1.getSuggestion() != null ? f1.getSuggestion().length() : 0);
        int len2 = (f2.getDescription() != null ? f2.getDescription().length() : 0)
                + (f2.getSuggestion() != null ? f2.getSuggestion().length() : 0);

        Finding primary = len1 >= len2 ? f1 : f2;
        Finding secondary = len1 >= len2 ? f2 : f1;

        if (secondary.getDescription() != null
                && !secondary.getDescription().isBlank()
                && !primary.getDescription().contains(secondary.getDescription())) {
            primary.setDescription(primary.getDescription()
                    + "\n(补充: " + secondary.getDescription() + ")");
        }
        return primary;
    }

    /**
     * 排序比较器:严重程度 > 类别优先级 > 行号
     */
    private int compareFindings(Finding f1, Finding f2) {
        int sev1 = f1.getSeverity() != null ? f1.getSeverity() : Integer.MAX_VALUE;
        int sev2 = f2.getSeverity() != null ? f2.getSeverity() : Integer.MAX_VALUE;
        if (sev1 != sev2) return Integer.compare(sev1, sev2);

        int cat1 = getCategoryPriority(f1.getCategory());
        int cat2 = getCategoryPriority(f2.getCategory());
        if (cat1 != cat2) return Integer.compare(cat1, cat2);

        int line1 = f1.getStartLine() != null ? f1.getStartLine() : Integer.MAX_VALUE;
        int line2 = f2.getStartLine() != null ? f2.getStartLine() : Integer.MAX_VALUE;
        return Integer.compare(line1, line2);
    }

    private int getCategoryPriority(String category) {
        if (category == null) return 99;
        return CATEGORY_PRIORITY.getOrDefault(category.toUpperCase(), 99);
    }
}

3.7 在 ReviewService 中集成大文件检测

修改 ReviewService.java,在 executeReviewStrategy() 方法中添加大文件检测逻辑:

// 注入 TokenEstimationService 和 MapReduceReviewService
private final TokenEstimationService tokenEstimationService;
private final MapReduceReviewService mapReduceReviewService;

// ... 在 executeReviewStrategy 方法中,找到 AI 审查的分支:
if (resolvedProvider == null) {
    // ... 获取可用提供商
}

final ModelProviderEnum provider = resolvedProvider;
final String providerNameForAi = provider != null ? provider.name() : requestedProvider;
final int blockStartLine = 1;

// 大文件检测:代码超过Token限制时自动转入 AST切片 + Map-Reduce 审查
boolean isLargeFile = false;
try {
    isLargeFile = tokenEstimationService.isLargeFile(codeContent, providerNameForAi);
} catch (Exception e) {
    log.warn("大文件检测失败,继续常规审查流程: {}", e.getMessage());
}

if (isLargeFile) {
    log.info("检测到大文件(超过Token限制),转入 AST切片 + Map-Reduce 审查流程");
    findings = mapReduceReviewService.reviewLargeFile(
            codeContent, language, providerNameForAi, enableRag, null, null);
} else {
    // 正常大小的文件走原来的语义指纹缓存 + AI 审查流程
    findings = fingerprintCacheService
            .tryGetCachedFindings(codeContent, language, provider, enableRag, blockStartLine)
            .orElseGet(() -> {
                List<Finding> fresh = aiModelService.reviewCode(
                        codeContent, language, providerNameForAi, enableRag);
                fingerprintCacheService.storeFindings(
                        codeContent, language, provider, enableRag, blockStartLine, fresh);
                return fresh;
            });
}

关键点:

  • 大文件检测放在缓存检查之前。大文件不经过语义指纹缓存,因为每次切片结果可能不同。
  • isLargeFile 由 TokenEstimationService 判断逻辑决定。
  • 如果切片失败(比如解析异常),Map-Reduce 内部会回退到原始 AI 审查。

3.8 添加 Maven 依赖

在 pom.xml 中添加 JavaParser 依赖(用于 AST 解析):

<dependency>
    <groupId>com.github.javaparser</groupId>
    <artifactId>javaparser-core</artifactId>
    <version>3.26.0</version>
</dependency>

四、完整数据流

让我们用一个 500 行的 Java 文件作为例子,追踪完整流程:

原始文件(500行,约15000字符)
        │
        ▼
TokenEstimationService.isLargeFile()
        │ 估算 Token: 15000 / 3.5 ≈ 4286
        │ 可用 Token: min(2500配置, 32768模型) = 2500
        │ 4286 > 2500 → true! 触发切片
        ▼
ASTCodeSlicer.slice()
        │ JavaParser 解析 AST
        │ 发现 8 个方法 + 2 个构造器 + 1 个内部类
        │ 排除字段声明(作为上下文保留在类骨架中)
        ▼
生成 10 个方法级切片(每个切片包含 import + 类声明 + 字段 + 目标方法)
        │
        ▼
Map 阶段(线程池,并行度=5)
        │ 第一批:5 个切片同时审查(5秒)
        │ 第二批:5 个切片同时审查(5秒)
        │ 共发现 32 个原始问题
        ▼
Reduce 阶段
        │ 去重:32 → 23(9个重复问题被合并)
        │ 排序:
        │   CRITICAL: 2 (安全漏洞)
        │   HIGH: 5 (性能问题)
        │   MEDIUM: 8 (可维护性问题)
        │   LOW: 8 (代码风格)
        ▼
最终报告:23 个问题

为什么 10 个切片用 parallelism=5?

同时发送 10 个请求到同一个大模型 API 可能导致限流。使用并行度 5 的线程池,每批处理 5 个切片,剩余 5 个排队等待。

这是"控制并发、保护后端"的常见做法。

五、验证方式

  1. 准备测试文件:创建一个超过 2500 token 的 Java 文件(大约 9000 字符以上)
  2. 启动应用:确保大模型可用(DeepSeek 或 Qwen)
  3. 发起审查:在审查页面选择"单个文件",上传测试文件
  4. 查看日志:确认以下日志出现:
检测到大文件(超过Token限制),转入 AST切片 + Map-Reduce 审查流程
Java AST切片完成: 文件=xxx.java, 切片数=N
[切片完成] 共 N 个切片
[Map] 审查切片 [1/N]: xxx (行x-y)
[Map阶段完成] 共发现 M 个原始问题
[Reduce-去重] 原始 → 最终
[Reduce-排序] 按严重程度和类别优先级完成排序
========== Map-Reduce审查完成 ==========
  1. 验证结果:审查结果应该覆盖文件所有部分,且不同方法的问题会合并去重

六、常见问题

Q: 所有文件都走切片了怎么办?

检查配置 app.large-file.enabled: true 和 max-tokens 是否设置合理。默认 2500 tokens 大约对应 9000 字符(约 300 行 Java 代码)。将 max-tokens 调高可以让更多小文件走常规审查。

Q: 某些方法切片后AI审查结果不准怎么办?

方法级切片的问题在于"缺少完整上下文"——切片中的方法看不到其他方法的实现。可以尝试:

  1. 增大 max-slice-chars 让切片包含更多上下文
  2. 在 buildSliceCode 中添加类的完整字段+其他方法签名(仅签名不包含实现),帮助 AI 理解类结构
  3. 回退到非切片模式直接审查小文件

Q: 多个切片产生重复问题?

这是预期行为。Reduce 阶段的去重逻辑(Jaccard 相似度 + 行号接近)会合并重复。如果发现去重不足(重复问题仍然出现),调高 dedup-title-similarity(如 0.8)或调低 dedup-line-proximity(如 2)。

如果发现去重过度(不同问题被合并),调低 dedup-title-similarity(如 0.6)或调低 dedup-line-proximity。

最后修改:2026 年 10 月 24 日
如果觉得我的文章对你有用,请随意赞赏