AI辅助教学：调用大模型从教材中生成习题，方便学员练习

一个AI辅助教学的小项目，记录一下。

先看效果，用户在选择资料库上传文件，勾选加入增强检索。

系统上传文件并将切片存入neo4j，用户选择题库，点击添加问题，系统按照选择题型、难度和数量生成问题并说明来源。

技术栈：spring boot 3.0.3 + neo4j-community-5.26.32 + spring-ai ，模型选择qwen3-4b（本地测试）。

ExamGenService负责出题的后台任务：

package com.magicdata.web.service; import com.magicdata.system.utils.SnowFlakeUtils; import com.magicdata.web.domain.ExamGenJob; import com.magicdata.web.domain.SysExamQuestion; import com.magicdata.web.domain.SysKnowledge; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Service; import java.util.Comparator; import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadFactory; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; /** * 练习题生成后台任务 * * <p>出题要读向量库、按批调用大模型再解析入库，在线模型一跑就是几十秒到几分钟。 * 与「加入增强检索」同理，直接在 HTTP 请求里同步做很容易被网关/代理超时掐断， * 用户只看到一句「失败」。所以：</p> * * <pre> * 点击生成 → 立即返回 taskId → 后台线程出题 → 前端轮询 /knowledge/examProgress 显示进度 * </pre> * * <p>任务状态只放内存（{@link #jobs}）：进度只对当次操作有意义，重启后丢失可接受。 * 已结束的任务保留 {@link #JOB_KEEP_MS}，方便前端补取题目列表。</p> * * <p>执行线程只有一个：出题是 IO 密集且依赖同一个大模型服务，并发跑多个任务只会互相拖慢。</p> * * @author magicdata */ @Service public class ExamGenService { private static final Logger log = LoggerFactory.getLogger(ExamGenService.class); /** 已结束任务的保留时长：前端轮询 1 秒一次，留 30 分钟足够用户慢慢看结果 */ private static final long JOB_KEEP_MS = 30 * 60 * 1000L; /** 内存里最多保留的任务数（超出时丢最旧的已结束任务） */ private static final int MAX_JOBS = 50; private final Map<String, ExamGenJob> jobs = new ConcurrentHashMap<>(); private final ThreadPoolExecutor executor; private final SysKnowledgeService knowledgeService; private final ExamQuestionService examQuestionService; public ExamGenService(SysKnowledgeService knowledgeService, ExamQuestionService examQuestionService) { this.knowledgeService = knowledgeService; this.examQuestionService = examQuestionService; this.executor = new ThreadPoolExecutor(1, 1, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), threadFactory()); this.executor.allowCoreThreadTimeOut(true); } /** * 提交出题任务 * * @param knowledge 资料来源（已被校验存在且已加入增强检索） * @param bankId 归属题库编号（可空；从「题库管理 → 添加问题」进来时必填） * @param questionType 题型：single / multiple / judge * @param difficulty 难度：easy / normal / hard * @param count 题量（1~{@link ExamQuestionService#MAX_COUNT}） * @param operator 操作人 * @return 任务对象（前端拿 taskId 轮询） */ public ExamGenJob submit(SysKnowledge knowledge, Long bankId, String questionType, String difficulty, int count, String operator) { cleanExpired(); ExamGenJob job = new ExamGenJob(nextTaskId(), knowledge.getId(), knowledge.getKnowledgeName(), questionType, difficulty, count); jobs.put(job.getTaskId(), job); try { executor.execute(() -> run(job, knowledge.getId(), bankId, questionType, difficulty, count, operator)); } catch (Exception e) { log.error("出题任务提交失败：taskId={}", job.getTaskId(), e); job.reject("任务提交失败：" + e.getMessage()); } return job; } /** * 取任务状态 * * @param taskId 任务编号；为空时返回「最近一个任务」 * @return 任务对象；不存在返回 {@code null} */ public ExamGenJob get(String taskId) { cleanExpired(); if (taskId != null && !taskId.isBlank()) { return jobs.get(taskId.trim()); } return jobs.values().stream() .max(Comparator.comparingLong(ExamGenJob::getCreateTime)) .orElse(null); } /** 当前是否有出题任务在跑 */ public boolean hasRunning() { return jobs.values().stream().anyMatch(ExamGenJob::isRunning); } /** * 后台执行：调用 {@link ExamQuestionService} 出题，进度写回任务对象 */ private void run(ExamGenJob job, Long knowledgeId, Long bankId, String questionType, String difficulty, int count, String operator) { job.markRunning(); log.info("出题任务开始：taskId={}，资料={}，题库={}，题型={}，难度={}，题量={}", job.getTaskId(), knowledgeId, bankId, questionType, difficulty, count); try { SysKnowledge knowledge = knowledgeService.getById(knowledgeId); if (knowledge == null) { job.reject("资料不存在，可能已被删除"); return; } ExamQuestionService.GenResult result = examQuestionService.generate(knowledge, bankId, questionType, difficulty, count, operator, (percent, stage, detail) -> job.report(percent, stage, detail)); for (SysExamQuestion question : result.getQuestions()) { job.addQuestion(question); } List<String> failures = result.getFailures(); int ok = result.getQuestions().size(); for (String failure : failures) { job.addFailure(failure); } job.finish(ok, failures.size()); job.setMessage(buildMessage(job, ok, failures.size())); log.info("出题任务结束：taskId={}，成功 {} 道，失败 {} 批", job.getTaskId(), ok, failures.size()); } catch (Exception e) { String reason = shortMessage(e); log.error("出题任务失败：taskId={}", job.getTaskId(), e); job.addFailure(reason); job.finish(0, 1); job.setMessage("生成练习题失败：" + reason); } } /** 结束文案：全部成功 / 部分失败两种口吻 */ private String buildMessage(ExamGenJob job, int ok, int fail) { String scope = typeLabel(job.getQuestionType()) + "·" + difficultyLabel(job.getDifficulty()); if (fail == 0) { return "生成练习题完成：" + scope + " 共 " + ok + " 道，已保存到题库"; } if (ok == 0) { return "生成练习题失败：" + String.join("；", job.getFailures()); } return "生成练习题完成 " + ok + " 道，" + fail + " 批失败：" + String.join("；", job.getFailures()); } /** 题型中文名 */ public static String typeLabel(String type) { if (SysExamQuestion.TYPE_MULTIPLE.equals(type)) { return "多选题"; } if (SysExamQuestion.TYPE_JUDGE.equals(type)) { return "判断题"; } return "单选题"; } /** 难度中文名 */ public static String difficultyLabel(String difficulty) { if (SysExamQuestion.DIFFICULTY_EASY.equals(difficulty)) { return "简单"; } if (SysExamQuestion.DIFFICULTY_HARD.equals(difficulty)) { return "困难"; } return "正常"; } /** 异常信息压成一行 */ private String shortMessage(Exception e) { String text = e.getMessage(); if (text == null || text.isBlank()) { text = e.getClass().getSimpleName(); } text = text.replace('\n', ' ').trim(); return text.length() > 260 ? text.substring(0, 260) + "..." : text; } /** * 清理过期任务：已结束且超过保留时长的删掉；任务数超过上限时从最旧的已结束任务开始删 */ private void cleanExpired() { long now = System.currentTimeMillis(); jobs.values().removeIf(job -> job.isFinished() && now - job.getEndTime() > JOB_KEEP_MS); if (jobs.size() <= MAX_JOBS) { return; } List<ExamGenJob> finished = jobs.values().stream() .filter(ExamGenJob::isFinished) .sorted(Comparator.comparingLong(ExamGenJob::getCreateTime)) .toList(); for (ExamGenJob job : finished) { if (jobs.size() <= MAX_JOBS) { break; } jobs.remove(job.getTaskId()); } } private String nextTaskId() { return "ex-" + SnowFlakeUtils.snowFlakeId(); } private ThreadFactory threadFactory() { AtomicInteger seq = new AtomicInteger(1); return runnable -> { Thread thread = new Thread(runnable, "exam-gen-" + seq.getAndIncrement()); thread.setDaemon(true); return thread; }; } }

examQuestionService负责出题：

/** * 为某篇资料生成练习题并入库 * * @param knowledge 资料来源（必须已加入增强检索） * @param bankId 归属题库编号（可空；空表示未归类） * @param questionType 题型：single / multiple / judge * @param difficulty 难度：easy / normal / hard * @param count 期望题量（1~{@link #MAX_COUNT}） * @param operator 操作人 * @param listener 进度回调，可为 {@code null} * @return 出题结果（题目 + 失败原因） * @throws Exception 取不到原文 / 一道题都没出成时抛出，异常信息可直接回显 */ public GenResult generate(SysKnowledge knowledge, Long bankId, String questionType, String difficulty, int count, String operator, ProgressListener listener) throws Exception { String type = normalizeType(questionType); String level = normalizeDifficulty(difficulty); int want = Math.max(1, Math.min(count, MAX_COUNT)); // 1. 确认向量库里确实有原文（真正的取样放在每批循环里做，每次随机取一小段） report(listener, 2, "读取资料原文", "正在从向量库取回《" + knowledge.getKnowledgeName() + "》的原文片段"); long totalChunks; try { totalChunks = graphService.countChunks(knowledge.getId()); } catch (Exception e) { throw new IllegalStateException("读取向量库失败：" + shortMessage(e)); } if (totalChunks <= 0) { throw new IllegalStateException("该资料在向量库里没有可用的原文分片，请先「加入增强检索」再出题"); } // 已经用过的片段：每批随机取样后据此去重，相邻批次尽量不考同一处 Set<String> usedChunks = new HashSet<>(); report(listener, 10, "准备出题", "向量库共 " + totalChunks + " 片原文，每批随机取样（上下文上限 " + CONTEXT_TOTAL_CHARS + " 字），即将调用大模型"); // 2. 分批出题 // 批次上限：模型偶尔只吐出 1~2 道（没按要求的条数来），所以要允许比理论批数多跑几批； // 但必须有上限，否则模型一直吐空结果就会无限调用下去。 List<SysExamQuestion> result = new ArrayList<>(want); List<String> failures = new ArrayList<>(); int maxBatches = (want + BATCH_SIZE - 1) / BATCH_SIZE + 3; int batchIndex = 0; while (result.size() < want && batchIndex < maxBatches) { int batchCount = Math.min(want - result.size(), BATCH_SIZE); batchIndex++; // 每批重新随机取切片：上下文长度恒定，不同批次覆盖不同章节 List<String> chunks = pickChunks(knowledge.getId(), usedChunks); String context = joinContext(chunks); if (context.isEmpty()) { failures.add("第 " + batchIndex + " 批：未取到原文片段"); logger.warn("出题批次 {} 未取到原文片段，停止出题", batchIndex); break; } report(listener, progress(result.size(), want), "调用大模型出题", "已生成 " + result.size() + "/" + want + " 道（第 " + batchIndex + " 批，依据 " + chunks.size() + " 片，原文约 " + context.length() + " 字）"); logger.info("出题批次 {}：随机取到 {} 片原文，上下文 {} 字", batchIndex, chunks.size(), context.length()); String promptText = buildPrompt(knowledge.getKnowledgeName(), type, level, batchCount, context, result); try { // 出题固定用「增强检索」里配置的对话模型：与学伴问答（会话模型）完全解耦 String raw = ragConfigHolder.chatClient().prompt(new Prompt(promptText)).call().content(); List<SysExamQuestion> batch = parseQuestions(raw, type, level); if (batch.isEmpty()) { failures.add("第 " + batchIndex + " 批未解析出题目"); logger.warn("出题批次 {} 未解析出题目，模型原始输出：{}", batchIndex, abbreviate(raw, 500)); } else { for (SysExamQuestion question : batch) { SysExamQuestion saved = persist(question, knowledge, bankId, type, level, operator); result.add(saved); if (result.size() >= want) { break; } } } } catch (Exception e) { failures.add("第 " + batchIndex + " 批：" + shortMessage(e)); logger.error("出题批次 {} 失败", batchIndex, e); } } // 3. 收尾：一道都没出成要把原因带出去 if (result.isEmpty()) { throw new IllegalStateException("出题失败：" + String.join("；", failures)); } report(listener, 100, "完成", "共生成 " + result.size() + " 道题"); logger.info("资料 [{}]（{}）出题完成：题型 {}，难度 {}，请求 {} 道，实际 {} 道", knowledge.getKnowledgeName(), knowledge.getId(), type, level, want, result.size()); if (!failures.isEmpty()) { logger.warn("出题存在失败批次：{}", String.join("；", failures)); } return new GenResult(result, failures); }

/** * 组装命题 Prompt（用字符串拼接，避免与 JSON 里的大括号冲突） */ private String buildPrompt(String knowledgeName, String type, String level, int batchCount, String context, List<SysExamQuestion> generated) { StringBuilder sb = new StringBuilder(4096); sb.append("你是一位中医针灸学专业的命题专家，正在为《").append(knowledgeName).append("》命制练习题。\n\n"); sb.append("出题要求：\n"); sb.append("1. 题目必须严格依据下面提供的资料片段，考查资料中确实出现的知识点，不得编造资料之外的内容。\n"); sb.append("2. 题干表述严谨、完整、无歧义；选项之间要有区分度，错误选项要合理但确实不对，如引用切片或片段内容，不要说来自XX切片或片段，要引用切片或片段的相关内容。\n"); sb.append("3. 本次共出 ").append(batchCount).append(" 道题，难度为：").append(difficultyText(level)).append("。\n"); sb.append("4. 只输出一个 JSON 数组，不要输出任何解释性文字，不要用 markdown 代码块包裹，不要输出数组以外的内容。\n\n"); sb.append("5. 题目解析清晰明了，如引用切片或片段内容，不要说来自XX切片或片段，要引用切片或片段相关内容并说明正确答案的依据。\n\n"); sb.append("6. 返回内容中不要出现片段XX中、切片XX中等含义模糊的词语。\n\n"); sb.append("JSON 数组里每个元素的结构如下：\n"); sb.append("{\"stem\": \"题干\", \"options\": [{\"key\": \"A\", \"content\": \"选项内容\"}, ") .append("{\"key\": \"B\", \"content\": \"选项内容\"}], \"answer\": \"A\", ") .append("\"analysis\": \"解析：说明正确答案的依据，并简要说明其它选项为什么不对\", ") .append("\"source\": \"本题依据的资料原文片段（40 字以内）\"}\n\n"); sb.append("题型要求：").append(answerRule(type)).append("\n\n"); //加了这个，上下文会超出模型限制 /*if (!generated.isEmpty()) { sb.append("已经出过的题目如下，请不要重复出相同的考点：\n"); for (SysExamQuestion question : generated) { sb.append("- ").append(abbreviate(question.getStem(), 60)).append("\n"); } sb.append("\n"); }*/ sb.append("资料片段：\n").append(context).append("\n"); return sb.toString(); } /** 各题型的答题规则说明 */ private String answerRule(String type) { switch (type) { case TYPE_MULTIPLE: return "本批全部是多选题。options 给出 A/B/C/D 四个选项；answer 填 2~4 个正确选项的字母，" + "用英文逗号分隔，例如 \"A,C\"（不要加空格）。"; case TYPE_JUDGE: return "本批全部是判断题。options 固定为空数组 []；answer 只能填 \"正确\" 或 \"错误\"。"; case TYPE_SINGLE: default: return "本批全部是单选题。options 给出 A/B/C/D 四个选项；answer 只填一个正确选项的字母，例如 \"A\"。"; } }

调用大模型出题是generate函数，分批次查询随机的分片内容给大模型当作参考资料，模型根据提示词要求，返回对应的结果。

演示地址：针灸推拿学数字教学系统。