Qwen2.5-32B-Instruct与SpringBoot集成：构建智能微服务-洪萨配资

Qwen2.5-32B-Instruct与SpringBoot集成：构建智能微服务

最近在做一个内部工具平台，需要给现有的业务系统加上智能问答和文档生成的能力。团队之前用了一些在线API，成本高不说，数据安全也是个问题。后来我们盯上了开源的Qwen2.5-32B-Instruct，想把它集成到现有的SpringBoot微服务架构里，做成一个本地化的智能服务。

试了大概两周，效果比预想的好。32B的模型在代码生成、文档整理这些任务上表现很稳，响应速度也能接受。最关键的是，数据都在自己服务器上跑，安全这块心里踏实多了。

今天就把我们这套集成方案整理出来，如果你也在考虑给SpringBoot项目加AI能力，特别是代码辅助、智能客服这类场景，可以参考一下。

1. 为什么选Qwen2.5-32B-Instruct？

选模型的时候我们对比了好几个选项。7B的版本轻量但能力有限，72B的效果更好但资源要求太高。32B这个尺寸在效果和成本之间找到了不错的平衡点。

用下来发现几个挺实用的特点：

指令跟随能力强：你让它“用Markdown表格列出问题、原因、解决方案”，它真能按这个格式输出，不会自己乱发挥。这对生成结构化文档特别有用。

代码能力扎实：我们试过让它写SpringBoot的Controller、Service层代码，虽然不能直接拿来用，但框架搭得挺像样，省了不少打字的功夫。修复简单bug、写单元测试这些也都能做。

上下文够长：支持128K的上下文，意味着它能记住比较长的对话历史。比如你让它分析一个复杂的业务逻辑，它可以参考前面讨论过的内容，不会每次都从头开始。

多语言支持：虽然我们主要用中文，但团队里有海外同事，偶尔需要英文文档，它切换起来很自然。

不过也有需要注意的地方：模型偶尔会“自信地胡说”，特别是遇到它不太确定的知识点。所以我们在实际用的时候，会加一层结果校验，不会完全相信它的输出。

2. 整体架构设计

我们的目标是把Qwen2.5-32B-Instruct做成一个独立的AI服务，然后通过REST API的方式提供给其他业务模块调用。这样有几个好处：

解耦：AI服务独立部署，不影响现有业务
弹性伸缩：可以根据负载单独扩缩容
统一管理：所有AI相关的配置、监控都集中在一个服务里

这是我们的架构示意图：

[业务服务A] --> [API Gateway] --> [AI服务 (SpringBoot + Qwen2.5)] [业务服务B] --> | [业务服务C] --> | v [模型推理引擎] [GPU资源池]

AI服务本身又分了几层：

API层：提供统一的REST接口，处理认证、限流、日志
业务层：封装具体的AI能力，比如代码生成、文档总结、问答
模型层：对接底层的模型推理，处理prompt构建、结果解析
基础设施层：监控、缓存、配置管理

3. 环境准备与模型部署

3.1 硬件要求

32B的模型对资源要求不低。我们测试下来，比较舒服的配置是：

GPU：至少24GB显存（A10/A100的24G版本够用）
内存：64GB以上，模型加载需要不少内存
磁盘：100GB可用空间，模型文件大概60GB

如果显存不够，可以考虑用量化版本（比如INT8），效果会有点损失，但能省不少显存。

3.2 模型下载与准备

从Hugging Face下载模型：

# 安装huggingface-cli pip install huggingface-hub # 下载模型（需要先登录） huggingface-cli download Qwen/Qwen2.5-32B-Instruct --local-dir ./qwen2.5-32b-instruct

或者用git直接clone：

git lfs install git clone https://huggingface.co/Qwen/Qwen2.5-32B-Instruct

下载完检查一下文件结构，主要需要这几个：

config.json- 模型配置
model.safetensors- 模型权重
tokenizer.json- 分词器
generation_config.json- 生成参数

3.3 用vLLM加速推理

直接跑原生的transformers代码，吞吐量上不去。我们用了vLLM做推理加速，效果挺明显的。

先安装vLLM：

pip install vllm

然后写个简单的启动脚本：

# start_vllm.py from vllm import LLM, SamplingParams # 初始化模型 llm = LLM( model="Qwen/Qwen2.5-32B-Instruct", tensor_parallel_size=2, # 如果用多卡可以调这个 gpu_memory_utilization=0.9, max_model_len=32768, # 根据需要调整 trust_remote_code=True ) # 采样参数 sampling_params = SamplingParams( temperature=0.7, top_p=0.9, max_tokens=1024, ) # 启动服务 from vllm.entrypoints.openai import api_server api_server.serve(llm, host="0.0.0.0", port=8000)

启动服务：

python start_vllm.py

这样就有了一个兼容OpenAI API的推理服务，后面SpringBoot直接调用就行。

4. SpringBoot服务搭建

4.1 项目初始化

用Spring Initializr创建一个新项目，主要依赖：

<dependencies> <!-- Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- 配置管理 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId> </dependency> <!-- 监控 --> <dependency> <groupId>io.micrometer</groupId> <artifactId>micrometer-core</artifactId> </dependency> <!-- 工具类 --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <!-- HTTP客户端 --> <dependency> <groupId>org.apache.httpcomponents.client5</groupId> <artifactId>httpclient5</artifactId> </dependency> <!-- JSON处理 --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> </dependency> </dependencies>

4.2 配置管理

在application.yml里配置模型服务地址和参数：

ai: model: # vLLM服务地址 base-url: http://localhost:8000/v1 # 模型名称（vLLM里用的） model-name: Qwen/Qwen2.5-32B-Instruct # 默认生成参数 generation: temperature: 0.7 top-p: 0.9 max-tokens: 1024 frequency-penalty: 0.0 presence-penalty: 0.0 # 超时设置 timeout: connect: 10s read: 60s # 重试策略 retry: max-attempts: 3 backoff-delay: 1000ms # 服务配置 server: port: 8080 # 监控端点 management: endpoints: web: exposure: include: health,metrics,prometheus

对应的配置类：

@Configuration @ConfigurationProperties(prefix = "ai.model") @Data public class ModelConfig { private String baseUrl; private String modelName; private GenerationConfig generation; private TimeoutConfig timeout; private RetryConfig retry; @Data public static class GenerationConfig { private Double temperature; private Double topP; private Integer maxTokens; private Double frequencyPenalty; private Double presencePenalty; } @Data public static class TimeoutConfig { private Duration connect; private Duration read; } @Data public static class RetryConfig { private Integer maxAttempts; private Duration backoffDelay; } }

4.3 模型客户端封装

封装一个调用vLLM服务的客户端：

@Service @Slf4j public class ModelClient { private final RestTemplate restTemplate; private final ModelConfig config; private final ObjectMapper objectMapper; public ModelClient(ModelConfig config, ObjectMapper objectMapper) { this.config = config; this.objectMapper = objectMapper; this.restTemplate = createRestTemplate(); } private RestTemplate createRestTemplate() { RestTemplate restTemplate = new RestTemplate(); // 设置超时 SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory(); factory.setConnectTimeout((int) config.getTimeout().getConnect().toMillis()); factory.setReadTimeout((int) config.getTimeout().getRead().toMillis()); restTemplate.setRequestFactory(factory); return restTemplate; } public String generate(String prompt, String systemPrompt) { return generate(prompt, systemPrompt, config.getGeneration()); } public String generate(String prompt, String systemPrompt, ModelConfig.GenerationConfig generationConfig) { try { // 构建请求 ChatCompletionRequest request = new ChatCompletionRequest(); request.setModel(config.getModelName()); request.setMessages(List.of( new ChatMessage("system", systemPrompt), new ChatMessage("user", prompt) )); request.setTemperature(generationConfig.getTemperature()); request.setTopP(generationConfig.getTopP()); request.setMaxTokens(generationConfig.getMaxTokens()); request.setFrequencyPenalty(generationConfig.getFrequencyPenalty()); request.setPresencePenalty(generationConfig.getPresencePenalty()); request.setStream(false); // 调用API String url = config.getBaseUrl() + "/chat/completions"; HttpHeaders headers = new HttpHeaders(); headers.setContentType(MediaType.APPLICATION_JSON); HttpEntity<ChatCompletionRequest> entity = new HttpEntity<>(request, headers); ResponseEntity<ChatCompletionResponse> response = restTemplate.exchange( url, HttpMethod.POST, entity, ChatCompletionResponse.class); if (response.getStatusCode().is2xxSuccessful() && response.getBody() != null && !response.getBody().getChoices().isEmpty()) { return response.getBody().getChoices().get(0).getMessage().getContent(); } throw new RuntimeException("模型调用失败: " + response.getStatusCode()); } catch (Exception e) { log.error("调用模型服务失败", e); throw new RuntimeException("模型服务调用异常", e); } } // 流式生成（适合长文本） public Flux<String> generateStream(String prompt, String systemPrompt) { return Flux.create(sink -> { try { ChatCompletionRequest request = new ChatCompletionRequest(); request.setModel(config.getModelName()); request.setMessages(List.of( new ChatMessage("system", systemPrompt), new ChatMessage("user", prompt) )); request.setStream(true); // 这里简化处理，实际可以用WebClient做流式响应 String response = generate(prompt, systemPrompt); sink.next(response); sink.complete(); } catch (Exception e) { sink.error(e); } }); } // 请求响应DTO @Data @AllArgsConstructor @NoArgsConstructor public static class ChatCompletionRequest { private String model; private List<ChatMessage> messages; private Double temperature; private Double topP; private Integer maxTokens; private Double frequencyPenalty; private Double presencePenalty; private Boolean stream; } @Data @AllArgsConstructor @NoArgsConstructor public static class ChatMessage { private String role; private String content; } @Data @AllArgsConstructor @NoArgsConstructor public static class ChatCompletionResponse { private String id; private String object; private Long created; private String model; private List<Choice> choices; @Data @AllArgsConstructor @NoArgsConstructor public static class Choice { private Integer index; private ChatMessage message; private String finishReason; } } }

4.4 业务服务层

根据不同的使用场景，封装具体的业务能力：

@Service @Slf4j public class CodeGenerationService { private final ModelClient modelClient; // 代码生成的系统提示词 private static final String CODE_SYSTEM_PROMPT = """ 你是一个专业的软件开发助手，擅长编写高质量、可维护的代码。 请根据用户需求生成相应的代码，并遵循以下原则： 1. 代码要有清晰的注释 2. 遵循行业最佳实践 3. 考虑错误处理和边界情况 4. 如果是Java代码，请遵循SpringBoot和Java开发规范 5. 输出只包含代码，不要有额外的解释 """; public String generateSpringBootController(String requirement) { String prompt = String.format(""" 请生成一个SpringBoot的REST Controller，要求如下： %s 要求： 1. 使用@RestController注解 2. 包含基本的CRUD操作 3. 有合适的请求映射 4. 包含必要的参数校验 5. 统一异常处理 6. 使用Swagger文档注解 """, requirement); return modelClient.generate(prompt, CODE_SYSTEM_PROMPT); } public String generateServiceClass(String className, String functionality) { String prompt = String.format(""" 请生成一个SpringBoot Service类，类名：%s 功能要求：%s 要求： 1. 使用@Service注解 2. 包含必要的业务逻辑方法 3. 考虑事务管理 4. 包含日志记录 5. 有合适的单元测试示例 """, className, functionality); return modelClient.generate(prompt, CODE_SYSTEM_PROMPT); } public String refactorCode(String code, String requirements) { String prompt = String.format(""" 请重构以下代码，要求：%s 代码： ```java %s ``` 请输出重构后的完整代码。 """, requirements, code); return modelClient.generate(prompt, CODE_SYSTEM_PROMPT); } } @Service @Slf4j public class DocumentService { private final ModelClient modelClient; private static final String DOC_SYSTEM_PROMPT = """ 你是一个专业的文档工程师，擅长编写清晰、准确的技术文档。 请根据用户需求生成相应的文档，并遵循以下原则： 1. 结构清晰，层次分明 2. 语言简洁准确 3. 技术术语使用恰当 4. 包含必要的示例和说明 5. 如果是API文档，请包含请求示例和响应示例 """; public String generateApiDocumentation(String code) { String prompt = String.format(""" 请为以下代码生成API文档： ```java %s ``` 要求： 1. 使用Markdown格式 2. 包含API端点说明 3. 包含请求参数说明 4. 包含响应示例 5. 包含错误码说明 6. 包含使用示例 """, code); return modelClient.generate(prompt, DOC_SYSTEM_PROMPT); } public String summarizeMeetingNotes(String notes) { String prompt = String.format(""" 请总结以下会议纪要，提取关键信息： %s 要求： 1. 提取会议主题 2. 列出参会人员 3. 总结讨论要点 4. 列出决策事项 5. 列出待办任务（包含负责人和截止时间） 6. 输出为Markdown格式 """, notes); return modelClient.generate(prompt, DOC_SYSTEM_PROMPT); } }

4.5 REST API接口

提供对外的API接口：

@RestController @RequestMapping("/api/ai") @Slf4j public class AiController { private final CodeGenerationService codeService; private final DocumentService docService; @PostMapping("/code/generate") public ResponseEntity<ApiResponse<String>> generateCode( @RequestBody CodeGenerationRequest request) { try { String code = codeService.generateSpringBootController( request.getRequirement()); return ResponseEntity.ok(ApiResponse.success(code)); } catch (Exception e) { log.error("代码生成失败", e); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) .body(ApiResponse.error("代码生成失败: " + e.getMessage())); } } @PostMapping("/code/refactor") public ResponseEntity<ApiResponse<String>> refactorCode( @RequestBody CodeRefactorRequest request) { try { String refactoredCode = codeService.refactorCode( request.getCode(), request.getRequirements()); return ResponseEntity.ok(ApiResponse.success(refactoredCode)); } catch (Exception e) { log.error("代码重构失败", e); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) .body(ApiResponse.error("代码重构失败: " + e.getMessage())); } } @PostMapping("/doc/api") public ResponseEntity<ApiResponse<String>> generateApiDoc( @RequestBody ApiDocRequest request) { try { String documentation = docService.generateApiDocumentation( request.getCode()); return ResponseEntity.ok(ApiResponse.success(documentation)); } catch (Exception e) { log.error("API文档生成失败", e); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) .body(ApiResponse.error("API文档生成失败: " + e.getMessage())); } } @PostMapping("/doc/summarize") public ResponseEntity<ApiResponse<String>> summarizeNotes( @RequestBody SummarizeRequest request) { try { String summary = docService.summarizeMeetingNotes( request.getContent()); return ResponseEntity.ok(ApiResponse.success(summary)); } catch (Exception e) { log.error("文档总结失败", e); return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) .body(ApiResponse.error("文档总结失败: " + e.getMessage())); } } // 请求DTO @Data @AllArgsConstructor @NoArgsConstructor public static class CodeGenerationRequest { @NotBlank private String requirement; private String language = "java"; private String framework = "springboot"; } @Data @AllArgsConstructor @NoArgsConstructor public static class CodeRefactorRequest { @NotBlank private String code; @NotBlank private String requirements; } @Data @AllArgsConstructor @NoArgsConstructor public static class ApiDocRequest { @NotBlank private String code; } @Data @AllArgsConstructor @NoArgsConstructor public static class SummarizeRequest { @NotBlank private String content; } // 统一响应DTO @Data @AllArgsConstructor @NoArgsConstructor public static class ApiResponse<T> { private boolean success; private String message; private T data; private Long timestamp; public static <T> ApiResponse<T> success(T data) { return new ApiResponse<>(true, "success", data, System.currentTimeMillis()); } public static <T> ApiResponse<T> error(String message) { return new ApiResponse<>(false, message, null, System.currentTimeMillis()); } } }

5. 性能优化实践

5.1 请求批处理

单个请求处理效率不高，我们实现了批处理功能：

@Service @Slf4j public class BatchProcessingService { private final ModelClient modelClient; private final ExecutorService executorService; public BatchProcessingService(ModelClient modelClient) { this.modelClient = modelClient; this.executorService = Executors.newFixedThreadPool(10); } public List<String> batchGenerate(List<String> prompts, String systemPrompt) { List<Future<String>> futures = new ArrayList<>(); for (String prompt : prompts) { futures.add(executorService.submit(() -> modelClient.generate(prompt, systemPrompt))); } List<String> results = new ArrayList<>(); for (Future<String> future : futures) { try { results.add(future.get()); } catch (Exception e) { log.error("批处理任务执行失败", e); results.add("生成失败: " + e.getMessage()); } } return results; } // 带优先级的批处理 public Map<String, String> batchGenerateWithPriority( Map<String, String> promptMap, String systemPrompt) { List<Map.Entry<String, String>> entries = new ArrayList<>(promptMap.entrySet()); // 按优先级排序（这里简单按key排序，实际可按业务逻辑） entries.sort(Map.Entry.comparingByKey()); Map<String, String> results = new ConcurrentHashMap<>(); entries.parallelStream().forEach(entry -> { try { String result = modelClient.generate(entry.getValue(), systemPrompt); results.put(entry.getKey(), result); } catch (Exception e) { log.error("处理任务失败: {}", entry.getKey(), e); results.put(entry.getKey(), "处理失败: " + e.getMessage()); } }); return results; } }

5.2 结果缓存

对于重复的请求，使用缓存避免重复计算：

@Service @Slf4j public class CacheService { private final Cache<String, String> responseCache; public CacheService() { this.responseCache = Caffeine.newBuilder() .maximumSize(1000) // 最多缓存1000条 .expireAfterWrite(1, TimeUnit.HOURS) // 1小时过期 .recordStats() .build(); } public String getOrGenerate(String key, Supplier<String> generator) { String cached = responseCache.getIfPresent(key); if (cached != null) { log.debug("缓存命中: {}", key); return cached; } String result = generator.get(); responseCache.put(key, result); return result; } public void invalidate(String key) { responseCache.invalidate(key); } public void invalidateAll() { responseCache.invalidateAll(); } // 在业务服务中使用缓存 public String generateWithCache(String prompt, String systemPrompt, ModelClient modelClient) { String cacheKey = DigestUtils.md5DigestAsHex( (prompt + systemPrompt).getBytes()); return getOrGenerate(cacheKey, () -> modelClient.generate(prompt, systemPrompt)); } }

5.3 监控与告警

集成Micrometer监控指标：

@Component public class ModelMetrics { private final MeterRegistry meterRegistry; private final Counter requestCounter; private final Timer responseTimer; private final DistributionSummary responseSizeSummary; public ModelMetrics(MeterRegistry meterRegistry) { this.meterRegistry = meterRegistry; // 请求计数器 this.requestCounter = Counter.builder("ai.model.requests") .description("模型请求总数") .tag("model", "qwen2.5-32b") .register(meterRegistry); // 响应时间计时器 this.responseTimer = Timer.builder("ai.model.response.time") .description("模型响应时间") .tag("model", "qwen2.5-32b") .register(meterRegistry); // 响应大小分布 this.responseSizeSummary = DistributionSummary.builder("ai.model.response.size") .description("模型响应大小") .baseUnit("characters") .register(meterRegistry); } public <T> T recordRequest(Supplier<T> supplier) { requestCounter.increment(); return responseTimer.record(() -> { T result = supplier.get(); if (result instanceof String) { responseSizeSummary.record(((String) result).length()); } return result; }); } public void recordError() { meterRegistry.counter("ai.model.errors", "model", "qwen2.5-32b").increment(); } } // 在ModelClient中使用监控 @Service @Slf4j public class MonitoredModelClient extends ModelClient { private final ModelMetrics metrics; public MonitoredModelClient(ModelConfig config, ObjectMapper objectMapper, ModelMetrics metrics) { super(config, objectMapper); this.metrics = metrics; } @Override public String generate(String prompt, String systemPrompt) { try { return metrics.recordRequest(() -> super.generate(prompt, systemPrompt)); } catch (Exception e) { metrics.recordError(); throw e; } } }

6. 实际应用场景

6.1 代码审查助手

我们开发了一个代码审查插件，集成到GitLab CI/CD流程中：

@Service @Slf4j public class CodeReviewService { private final ModelClient modelClient; private static final String REVIEW_SYSTEM_PROMPT = """ 你是一个经验丰富的代码审查专家，请仔细审查以下代码， 从以下角度给出专业意见： 1. 代码规范（命名、格式、注释） 2. 潜在bug和安全隐患 3. 性能问题 4. 可维护性 5. 设计模式应用 6. 测试覆盖率 请用中文输出，格式如下： ## 总体评价 [简要评价] ## 主要问题 - [问题1]：描述 + 建议 - [问题2]：描述 + 建议 ## 改进建议 - [建议1] - [建议2] ## 优秀之处 - [优点1] - [优点2] """; public String reviewCode(String code, String language) { String prompt = String.format(""" 请审查以下%s代码： ```%s %s ``` 请给出详细的审查意见。 """, language, language.toLowerCase(), code); return modelClient.generate(prompt, REVIEW_SYSTEM_PROMPT); } public Map<String, Object> batchReview(List<CodeFile> files) { Map<String, Object> results = new HashMap<>(); for (CodeFile file : files) { try { String review = reviewCode(file.getContent(), file.getLanguage()); results.put(file.getPath(), Map.of( "status", "success", "review", review )); } catch (Exception e) { results.put(file.getPath(), Map.of( "status", "error", "message", e.getMessage() )); } } return results; } @Data @AllArgsConstructor @NoArgsConstructor public static class CodeFile { private String path; private String language; private String content; } }

6.2 智能客服集成

把AI能力集成到客服系统中，自动回答常见问题：

@Service @Slf4j public class CustomerServiceBot { private final ModelClient modelClient; private final KnowledgeBaseService knowledgeBase; private static final String CS_SYSTEM_PROMPT = """ 你是一个专业的客服助手，负责回答用户关于我们产品的问题。 公司产品信息： %s 回答要求： 1. 态度友好，专业 2. 回答准确，基于事实 3. 如果不确定，请说“我需要进一步确认” 4. 复杂问题可以建议联系人工客服 5. 用中文回答 """; public String answerQuestion(String question, String sessionId) { // 先从知识库查找 String context = knowledgeBase.findRelevantContext(question); String systemPrompt = String.format(CS_SYSTEM_PROMPT, context); // 添加上下文（最近几次对话） List<String> history = knowledgeBase.getConversationHistory(sessionId); String fullPrompt = buildPromptWithHistory(question, history); return modelClient.generate(fullPrompt, systemPrompt); } private String buildPromptWithHistory(String currentQuestion, List<String> history) { if (history.isEmpty()) { return currentQuestion; } StringBuilder prompt = new StringBuilder(); prompt.append("之前的对话历史：\n"); for (int i = 0; i < history.size(); i++) { prompt.append(String.format("%d. %s\n", i + 1, history.get(i))); } prompt.append("\n当前问题：").append(currentQuestion); return prompt.toString(); } // 自动分类问题 public String classifyQuestion(String question) { String prompt = String.format(""" 请将以下问题分类： 问题：%s 分类选项： 1. 产品功能 2. 技术问题 3. 价格咨询 4. 售后支持 5. 其他 请只输出分类编号。 """, question); String response = modelClient.generate(prompt, "你是一个问题分类助手，请准确分类用户问题。"); // 解析分类结果 return parseClassification(response); } private String parseClassification(String response) { // 简单解析，实际可以更复杂 if (response.contains("1")) return "产品功能"; if (response.contains("2")) return "技术问题"; if (response.contains("3")) return "价格咨询"; if (response.contains("4")) return "售后支持"; return "其他"; } }

6.3 文档自动生成

自动为代码库生成文档：

@Service @Slf4j public class AutoDocumentationService { private final ModelClient modelClient; private final GitService gitService; public void generateProjectDocumentation(String repoUrl, String branch) { // 克隆代码库 File projectDir = gitService.cloneRepository(repoUrl, branch); // 分析项目结构 List<CodeFile> javaFiles = findJavaFiles(projectDir); // 为每个文件生成文档 Map<String, String> documentation = new HashMap<>(); for (CodeFile file : javaFiles) { String doc = generateFileDocumentation(file); documentation.put(file.getPath(), doc); } // 生成项目概览 String overview = generateProjectOverview(javaFiles); documentation.put("README.md", overview); // 保存文档 saveDocumentation(projectDir, documentation); // 可选：提交到仓库 gitService.commitDocumentation(projectDir, documentation); } private String generateFileDocumentation(CodeFile file) { String prompt = String.format(""" 请为以下Java文件生成详细文档： 文件路径：%s 代码内容： ```java %s ``` 请包含： 1. 类/接口说明 2. 主要方法说明 3. 使用示例 4. 注意事项 5. 相关类链接 使用Markdown格式。 """, file.getPath(), file.getContent()); return modelClient.generate(prompt, "你是一个Java文档专家，请生成专业的技术文档。"); } private String generateProjectOverview(List<CodeFile> files) { String prompt = String.format(""" 请根据以下文件列表生成项目概览： 文件列表： %s 请生成包含以下内容的README： 1. 项目简介 2. 主要功能 3. 技术栈 4. 项目结构说明 5. 快速开始指南 6. 构建和部署说明 使用Markdown格式。 """, files.stream() .map(f -> "- " + f.getPath()) .collect(Collectors.joining("\n"))); return modelClient.generate(prompt, "你是一个技术文档工程师，请生成专业的项目文档。"); } }

7. 遇到的问题和解决方案

7.1 模型响应慢

刚开始用的时候，发现模型响应时间波动很大，有时候要等十几秒。后来做了这些优化：

启用流式响应：对于长文本生成，改成流式输出，用户能先看到部分结果，体验好很多。

调整生成参数：把temperature调低（0.3-0.5），减少随机性，响应会快一些。

预热机制：服务启动后，先发几个简单的请求预热模型，避免第一个真实请求太慢。

7.2 结果质量不稳定

有时候模型会生成不准确的内容，我们加了这些校验：

结果验证：对于代码生成，会用编译工具检查语法；对于事实性问题，会从知识库做二次验证。

置信度评分：让模型对自己的回答打分，低分的答案会标记为“需要人工复核”。

多轮对话澄清：如果问题模糊，会主动追问，让用户提供更多上下文。

7.3 资源管理

32B模型挺吃资源的，我们做了这些控制：

请求队列：设置最大并发数，避免同时太多请求把GPU打满。

超时控制：根据请求复杂度设置不同的超时时间，简单的问答设短点，代码生成可以设长点。

降级策略：如果模型服务不可用，自动切换到规则引擎或者缓存结果。

7.4 安全性考虑

输入过滤：对用户输入做严格的过滤和转义，防止注入攻击。

输出审查：对模型生成的内容做安全检查，过滤敏感信息。

访问控制：基于角色的权限管理，不同用户能用的功能不一样。

审计日志：记录所有AI请求和响应，方便追溯和审计。

8. 总结

把Qwen2.5-32B-Instruct集成到SpringBoot微服务里，跑了一段时间下来，感觉这个方案还是挺实用的。模型能力足够强，能处理代码生成、文档整理、智能问答这些实际需求，而且因为部署在本地，数据安全有保障。

最大的收获是找到了效果和成本的平衡点。32B的模型在专业任务上表现不错，资源消耗也在可接受范围内。用vLLM做推理加速，加上SpringBoot的成熟生态，整套系统稳定性挺好。

当然也有需要继续优化的地方。比如怎么更好地利用长上下文，怎么降低响应延迟，怎么提高结果的准确性。我们准备接下来试试模型量化，看看能不能在效果损失不大的情况下，把资源占用再降一降。

如果你也在考虑类似的项目，建议先从简单的场景开始，比如代码审查或者文档生成，跑通了再扩展到更复杂的应用。过程中多关注监控指标，及时调整参数，慢慢就能找到最适合自己业务的配置。

获取更多AI镜像
想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。

Qwen2.5-32B-Instruct与SpringBoot集成：构建智能微服务