基于Java实现文档章节结构智能提取方案详解

private List<Chapter> getLLMChapters(String input) {
    List<Chapter> allTitles = new ArrayList<>();
    if (input.length() > 100000) // 限制文本长度，避免大模型调用超限
        return allTitles;
    try {
        // 获取大模型配置（模型编码、API地址、密钥）
        KbLlmModelsCacheService.KbLlmModelDto model = kbLlmModelsCacheService.getChatModel().getModelMapById().get(2L);
        // 定制化Prompt，约束输出格式为JSON
        String prompt = "角色：你是一名文档解析助手，请对用户的输入文本进行解析，找到目录所在，输出文本的章节目录结构。\n" +
                "输出格式：JSON格式：[{\"title\":\"标题\", \"level\":2, \"pageNumber\":7, \"subChapters\":[]}\n" +
                "约束条件：输出原文";
        JSONObject cfgLLM = new JSONObject();
        cfgLLM.put("model", model.getModelCode());
        cfgLLM.put("prompt", prompt);
        cfgLLM.put("url", model.getApiUrl());
        cfgLLM.put("authorization", model.getApiKey());
        // 调用大模型API
        JSONObject result = httpUtils.chatMessages(input, cfgLLM);
        if (result.getBoolean("success")) {
            String    content   = result.getString("content");
            JSONArray jsonArray = httpUtils.formatListJSON(content);
            allTitles = Chapter.parseChapter(jsonArray); // 解析JSON为Chapter对象
        } else
            log.info("大模型识别目录失败：" + result.toJSONString());
    } catch (Exception e) {
        e.printStackTrace();
    }
    return allTitles;
}

public static boolean isTitleText(String text) {
    // 过滤空文本、制表符、特殊标点
    if (text.trim().isEmpty() || text.matches("\t") || text.contains("\t") || text.contains("。") || text.endsWith("、"))
        return false;
    // 过滤纯数字/特殊符号文本
    String cleanText = text.trim();
    if (cleanText.matches("^[0-9\\p{Punct}]+$"))
        return false;
    // 过滤长度异常文本（2-50字符为合理标题长度）
    if (text.length() > 50 || text.length() < 2) return false;
    // 匹配常见标题格式（第X章、X.1、一、(一)等）
    for (Pattern pattern : TITLE_PATTERNS) {
        if (pattern.matcher(text).matches()) {
            return true;
        }
    }
    // 匹配标题关键词（概况、总则、前言等）
    String[] titleKeywords = {"概况", "概述", "前言", "引言", "摘要", "总结", "结论", "总则"};
    for (String keyword : titleKeywords) {
        if (text.contains(keyword)) {
            return true;
        }
    }
    return false;
}

// 常见标题格式正则
private static final List<Pattern> TITLE_PATTERNS = Arrays.asList(
        Pattern.compile("^第[零一二三四五六七八九十百千\\d]+章[\\s　]+(.+)$"),
        Pattern.compile("^第[零一二三四五六七八九十百千\\d]+节[\\s　]+(.+)$"),
        Pattern.compile("^\\d+[．\\.](?!.*%).*[^%]$"),
        Pattern.compile("^[一二三四五六七八九十]、[\\s　]*(.+)$"),
        Pattern.compile("^[\\(（][一二三四五六七八九十][\\)）][\\s\\t]*(.+)$"),
        Pattern.compile("^\\d+[．\\.]\\d+[．\\.].[^%]$")
);

public static int detectChapterLevel(String text) {
    text = text.trim();
    // 1级标题：第X章、中文数字+顿号
    if (text.matches("^第[零一二三四五六七八九十百千\\d]+章.*") || text.matches("^[零一二三四五六七八九十百千\\d]+、.*")) {
        return 1;
    }
    // 2级标题：(一)、X.X格式
    if (text.matches("^[\\(（][一二三四五六七八九十][\\)）][\\s\\t]*(.+)$") || text.matches("^\\d+[．\\.]\\d+[．\\.].[^%]$")) {
        return 2;
    }
    return 0; // 非标题
}

public List<Chapter> organizeChaptersByLevel(List<Chapter> rawChapters) {
    List<Chapter>  rootChapters = new ArrayList<>();
    Stack<Chapter> levelStack   = new Stack<>(); // 栈记录当前层级父节点

    for (Chapter chapter : rawChapters) {
        int level = chapter.getLevel();
        // 找到当前节点的父节点（栈顶层级 < 当前层级）
        while (!levelStack.isEmpty() && levelStack.peek().getLevel() >= level) {
            levelStack.pop();
        }
        // 根节点（无父节点）加入根列表，否则加入父节点子列表
        if (levelStack.isEmpty()) {
            rootChapters.add(chapter);
        } else {
            levelStack.peek().getSubChapters().add(chapter);
        }
        // 当前节点入栈，作为后续子节点的父节点
        levelStack.push(chapter);
    }
    return rootChapters;
}

public List<Chapter> extractChaptersFromUnstructured(JSONArray responseJson) {
    List<Chapter> chapters = new ArrayList<>();
    Map<String, Chapter> chapterMap = new HashMap<>(); // element_id -> Chapter
    Map<String, List<Chapter>> parentChildrenMap = new HashMap<>(); // parent_id -> 子章节

    // 第一步：提取所有Title类型元素
    for (Object parsed : responseJson) {
        JSONObject parsedObject = (JSONObject) parsed;
        String     type         = parsedObject.getString("type");
        if (StringUtils.isNotEmpty(type) && type.toLowerCase().contains("title")) {
            String     elementId = parsedObject.getString("element_id");
            String     text      = parsedObject.getString("text");
            JSONObject metadata  = parsedObject.getJSONObject("metadata");
            Integer    depth     = metadata != null ? metadata.getInteger("category_depth") : null;
            String     parentId  = metadata != null ? metadata.getString("parent_id") : null;

            int level = (depth != null ? depth : 0) + 1; // 层级计算（depth从0开始）
            Chapter chapter = new Chapter(text, level, 0);
            chapterMap.put(elementId, chapter);

            // 建立父子映射
            if (parentId != null && !parentId.isEmpty()) {
                parentChildrenMap.computeIfAbsent(parentId, k -> new ArrayList<>()).add(chapter);
            } else {
                chapters.add(chapter); // 无父节点为根章节
            }
        }
    }

    // 第二步：将子章节挂载到父章节
    for (Map.Entry<String, List<Chapter>> entry : parentChildrenMap.entrySet()) {
        String        parentId = entry.getKey();
        List<Chapter> children = entry.getValue();
        Chapter       parent   = chapterMap.get(parentId);
        if (parent != null) {
            parent.getSubChapters().addAll(children);
        }
    }
    return chapters;
}

public List<Chapter> extractChapters(String content) throws IOException {
    log.info("开始大模型识别文本标题");
    if (content == null || content.isEmpty())
        return new ArrayList<>();

    List<Chapter> llmChapters = getLLMChapters(content);
    if (llmChapters.isEmpty()) {
        log.info("未检测到大模型识别的文本标题，开始文本分析识别文本标题");
        return getChaptersByAnalysis(content);
    } else
        return llmChapters;
}