Java集成ChatGPT：使用ChatGPT-Java-API构建智能应用实践

1. 项目概述与核心价值

最近在折腾一个需要集成AI对话能力的Java后端项目，自然就想到了ChatGPT的API。官方提供了Python库，用起来确实方便，但Java这边呢？我翻了一圈，发现要么是封装得不够彻底，要么是功能不全，要么就是文档写得云里雾里。直到我遇到了CJCrafter/ChatGPT-Java-API这个开源项目，才算是找到了一个在Java世界里优雅调用ChatGPT的“瑞士军刀”。

简单来说，ChatGPT-Java-API是一个非官方的、功能全面的Java客户端库，它把OpenAI的Chat Completions API（也就是我们常说的ChatGPT模型接口）以及相关的辅助功能，用纯Java的方式封装了起来。对于Java开发者而言，它的价值在于让你能用最熟悉的语言和编程范式，去调用最前沿的AI能力，而不用去操心HTTP请求的细节、JSON的序列化反序列化、流式响应的处理这些底层琐事。

这个项目解决的痛点非常明确：降低在Java应用中集成ChatGPT的技术门槛和开发成本。无论是你想做一个智能客服机器人、一个代码辅助工具、一个内容生成服务，还是仅仅想在后台日志分析里加一点AI摘要，这个库都能让你快速上手。它支持同步和异步调用，处理流式响应（就是那种一个字一个字往外蹦的效果），内置了简单的对话历史管理，甚至还能帮你算算用了多少Token（这直接关系到API费用）。对于我这种主要技术栈在JVM生态的开发者来说，它几乎是把ChatGPT API“翻译”成了Java开发者能直接理解的语言。

2. 核心功能与设计思路拆解

2.1 核心功能全景

这个库的核心是围绕OpenAI的Chat Completions API构建的，但做得比直接调用REST API要贴心得多。我们来拆解一下它的主要能力：

1. 完整的Chat Completions支持：这是基石。你可以创建对话请求，指定模型（如gpt-3.5-turbo, gpt-4），设置系统指令（system message），添加用户消息（user message），并获取AI的回复（assistant message）。所有官方支持的参数，如温度（temperature）、最大token数（max_tokens）、top_p等，都提供了对应的Java Bean属性进行配置。

2. 流式响应处理：这是提升用户体验的关键。当AI生成较长内容时，流式响应可以让回复像真人打字一样逐步显示。这个库提供了Stream和Callback两种方式来消费流式数据。Stream方式返回一个Java 8的Stream<ChatCompletionChunk>对象，你可以用函数式编程的方式优雅地处理每一个数据块；Callback方式则更传统，你需要实现一个回调接口来接收数据。两种方式都帮你处理好了底层的SSE（Server-Sent Events）连接和解析。

3. 同步与异步调用：兼顾了简单和性能。complete方法用于同步调用，它会阻塞直到收到完整响应，适合快速原型或简单的交互。stream方法用于发起流式请求，而streamAsync和completeAsync则提供了基于CompletableFuture的异步接口，让你能在不阻塞主线程的情况下发起请求，这对于高并发服务端应用至关重要。

4. 对话历史管理：虽然功能相对基础，但非常实用。库里的ChatCompletionMessage对象天然构成了一个消息链。通常，我们会维护一个List<ChatCompletionMessage>作为会话历史。每次新的用户提问，就把历史消息和新的用户消息一起发给API，这样AI就能拥有上下文记忆。项目示例和工具类通常会展示如何维护这个列表。

5. Token计算与费用估算：这是一个隐藏的宝藏功能。OpenAI API按Token收费，而Token不等于单词或汉字。这个库内部通常依赖tiktoken库的Java绑定或类似实现，提供了计算消息列表中Token数量的方法。在发送请求前估算一下Token用量，可以有效避免因超出模型上下文限制而导致的请求失败，也能帮你更好地控制成本。

6. 灵活的配置与扩展：支持通过环境变量、配置文件或代码直接设置API Key、代理、超时时间等。其HTTP客户端层通常基于OkHttp或Apache HttpClient构建，允许你注入自定义的配置，比如设置特定的代理服务器以适应不同的网络环境。

2.2 设计哲学：封装与简化

这个项目的设计思路非常“Java”——强调封装、强类型和易用性。

首先，它用纯粹的Java对象（POJO）来映射API的请求和响应。比如，ChatCompletionRequest类包含了model,messages,temperature等字段，你只需要像操作普通Java对象一样设置它们，库会在背后帮你转换成正确的JSON。这比手动拼接JSON字符串或者用Map来构建请求要安全、清晰得多，IDE的代码补全和编译期检查都能派上用场。

其次，它隐藏了网络通信的复杂性。你不需要知道HTTP端点是什么，不需要手动设置Authorization头，不需要处理不同的HTTP状态码（除非是特定的错误情况）。库的作者已经把这些样板代码打包好了。对于流式响应这种稍微复杂一点的模式，库也提供了高层次的抽象，让你关注业务逻辑（处理每一个回复块），而不是网络协议。

再者，它保持了适度的灵活性。虽然封装得很彻底，但并没有把所有的路都堵死。例如，它允许你自定义HTTP客户端，这意味着你可以设置连接池、超时、拦截器（比如用于日志记录），甚至使用代理。这种在“开箱即用”和“深度定制”之间的平衡，是一个优秀库的标志。

注意：使用任何第三方API客户端库，尤其是涉及敏感信息（API Key）和产生费用的服务时，务必从官方仓库（如GitHub）获取，并检查其依赖是否安全。不要使用来历不明的JAR包。

3. 快速上手指南：从零到第一次对话

理论说了不少，我们来点实际的。假设你有一个Spring Boot项目，想快速集成这个库，看看ChatGPT到底能干啥。

3.1 环境准备与依赖引入

首先，你需要一个OpenAI的API Key。去OpenAI平台注册并获取它，这是调用服务的通行证。

接下来，在你的Maven项目的pom.xml中添加依赖。由于这个库可能不在中央仓库，你需要先添加它的仓库地址，然后再添加依赖。具体坐标需要去项目GitHub主页查看最新版本。

<!-- 在pom.xml的<repositories>部分添加 --> <repository> <id>jitpack.io</id> <url>https://jitpack.io</url> </repository> <!-- 在<dependencies>部分添加 --> <dependency> <groupId>com.github.CJCrafter</groupId> <artifactId>ChatGPT-Java-API</artifactId> <version>最新的版本号</version> <!-- 例如 v1.0.0 --> </dependency>

如果是Gradle，配置也类似。添加完依赖后，刷新你的项目，确保库被成功下载。

3.2 创建客户端与发起第一次请求

一切就绪，我们可以写代码了。最核心的对象是ChatGPT客户端。

import live.cjcrafter.chatapi.ChatGPT; import live.cjcrafter.chatapi.ChatCompletionRequest; import live.cjcrafter.chatapi.ChatCompletionResult; import live.cjcrafter.chatapi.message.ChatMessage; import live.cjcrafter.chatapi.message.MessageType; public class QuickStartDemo { public static void main(String[] args) { // 1. 初始化客户端，传入你的API Key // 在实际项目中，API Key应该来自配置文件或环境变量，切勿硬编码！ String apiKey = "sk-你的真实API Key"; ChatGPT chatGpt = new ChatGPT(apiKey); // 2. 构建请求 ChatCompletionRequest request = ChatCompletionRequest.builder() .model("gpt-3.5-turbo") // 指定模型 .message(ChatMessage.of(MessageType.USER, "用Java写一个Hello World程序")) // 用户消息 .temperature(0.7) // 创造性，0-2之间，越高越随机 .maxTokens(100) // 限制回复长度 .build(); // 3. 发送同步请求并获取结果 ChatCompletionResult result = chatGpt.complete(request); // 4. 处理回复 if (result != null && result.getChoices() != null && !result.getChoices().isEmpty()) { String reply = result.getChoices().get(0).getMessage().getContent(); System.out.println("AI回复: " + reply); } else { System.out.println("未收到有效回复。"); } } }

运行这段代码，如果你的网络和API Key没问题，控制台就会打印出AI生成的Java Hello World代码。恭喜你，完成了第一次调用！

3.3 关键参数解析与调优

第一次调用成功了，但你可能对里面的参数有些疑问。我们来深入一下几个最常用的：

• model: 这是引擎。gpt-3.5-turbo性价比高，响应快，适合大多数对话和文本任务。gpt-4能力更强，尤其在推理和复杂指令遵循上表现更好，但价格更贵，速度也可能慢一些。根据你的需求和预算选择。
• messages: 消息列表，对话的核心。它是一个List<ChatMessage>。每个ChatMessage都有role（角色）和content（内容）。角色有三种：
  • SYSTEM: 系统消息，用于设定AI的上下文和行为指令，比如“你是一个专业的Java编码助手”。
  • USER: 用户消息，就是我们提的问题。
  • ASSISTANT: 助手消息，通常是AI之前的回复，用于维护对话历史。
• temperature: 温度参数，范围0~2。它控制输出的随机性。0意味着输出是确定性的，同样的输入每次得到同样的输出（对于模型来说，是选择概率最高的下一个token）。值越高（如0.8、1.2），输出越随机、有创造性，但也可能更不连贯。对于代码生成、事实问答，建议较低（0.2-0.5）；对于创意写作，可以调高（0.7-1.0）。
• max_tokens: 限制AI回复的最大长度（以Token计）。注意，这个限制是输入+输出的总和不能超过模型的上下文窗口（例如，gpt-3.5-turbo是16385个token）。你需要预留足够的token给输出。设置太小会导致回复被截断。

实操心得：对于temperature，我的经验是，在需要稳定、可靠输出的生产环境（如客服问答、代码补全），把它设低一点（0.1-0.3）。在探索性、创意性场景，可以调高。不妨写个循环，用不同的temperature值问同一个问题，直观感受一下区别。

4. 进阶应用：构建一个带记忆的对话机器人

一次性的问答没什么意思，真正的对话是有上下文的。接下来，我们构建一个简单的命令行对话机器人，它能记住我们之前说过的话。

4.1 维护对话历史

关键在于维护一个List<ChatMessage>作为会话历史。每次交互，我们都将整个历史发送给API。

import java.util.ArrayList; import java.util.List; import java.util.Scanner; public class SimpleChatBot { private final ChatGPT chatGpt; private final List<ChatMessage> conversationHistory; private final Scanner scanner; public SimpleChatBot(String apiKey) { this.chatGpt = new ChatGPT(apiKey); this.conversationHistory = new ArrayList<>(); this.scanner = new Scanner(System.in); // 可选：添加一个系统指令来设定AI的角色 conversationHistory.add(ChatMessage.of(MessageType.SYSTEM, "你是一个乐于助人且知识渊博的助手。")); } public void startChat() { System.out.println("聊天机器人已启动。输入‘退出’来结束对话。"); while (true) { System.out.print("\n你: "); String userInput = scanner.nextLine(); if ("退出".equalsIgnoreCase(userInput.trim())) { System.out.println("再见！"); break; } // 1. 将用户输入加入历史 conversationHistory.add(ChatMessage.of(MessageType.USER, userInput)); // 2. 构建请求，这次传入整个历史 ChatCompletionRequest request = ChatCompletionRequest.builder() .model("gpt-3.5-turbo") .messages(new ArrayList<>(conversationHistory)) // 传入历史副本是个好习惯 .temperature(0.7) .maxTokens(500) .build(); // 3. 发送请求 ChatCompletionResult result = chatGpt.complete(request); // 4. 处理回复并加入历史 if (result != null && !result.getChoices().isEmpty()) { String aiReply = result.getChoices().get(0).getMessage().getContent(); System.out.println("AI: " + aiReply); // 将AI的回复也加入历史，以便后续对话有上下文 conversationHistory.add(ChatMessage.of(MessageType.ASSISTANT, aiReply)); } else { System.out.println("AI: （似乎没有回应）"); } } scanner.close(); } public static void main(String[] args) { // 从环境变量获取API Key更安全 String apiKey = System.getenv("OPENAI_API_KEY"); if (apiKey == null || apiKey.isEmpty()) { System.err.println("请设置环境变量 OPENAI_API_KEY"); return; } new SimpleChatBot(apiKey).startChat(); } }

这个机器人已经具备了基本的上下文记忆能力。你可以问它“我上一句话说了什么？”，它大概率能回答上来，因为历史记录在conversationHistory里。

4.2 实现流式输出体验

上面的代码是等AI完全生成完再一次性打印出来。现在我们来升级一下，实现打字机效果的流式输出。这需要使用stream方法。

public void streamChatResponse(String userInput) throws Exception { conversationHistory.add(ChatMessage.of(MessageType.USER, userInput)); ChatCompletionRequest request = ChatCompletionRequest.builder() .model("gpt-3.5-turbo") .messages(new ArrayList<>(conversationHistory)) .temperature(0.7) .stream(true) // 关键：启用流式输出 .build(); System.out.print("AI: "); StringBuilder fullReply = new StringBuilder(); // 使用Stream API处理流式响应块 chatGpt.stream(request) .forEach(chunk -> { // 每个chunk包含回复的一部分 String deltaContent = chunk.getChoices().get(0).getDelta().getContent(); if (deltaContent != null) { System.out.print(deltaContent); System.out.flush(); // 确保及时输出 fullReply.append(deltaContent); } }); System.out.println(); // 流结束，换行 // 将完整的回复加入历史 conversationHistory.add(ChatMessage.of(MessageType.ASSISTANT, fullReply.toString())); }

把startChat方法中的同步调用chatGpt.complete替换成对这个streamChatResponse方法的调用，你就获得了一个能“逐字打印”回复的聊天机器人，体验瞬间提升。

注意事项：流式响应会持续占用HTTP连接，直到AI生成完毕或达到token限制。要确保设置合理的超时时间，并在网络不稳定的环境下做好异常处理（例如连接中断后的重试或友好提示）。

4.3 上下文长度管理与Token估算

随着对话轮次增加，conversationHistory会越来越长。所有模型的上下文窗口都有上限（比如gpt-3.5-turbo是16385 tokens）。超出这个限制，请求会失败。因此，一个健壮的机器人需要管理历史长度。

常见策略有：

1. 只保留最近N轮对话：简单粗暴，但可能丢失重要的早期上下文。
2. 基于Token数进行截断：更精确。在每次发送请求前，计算历史消息的Token总数，如果接近上限，就从最旧的消息开始移除，直到满足要求。

ChatGPT-Java-API库通常提供了Token计算工具。假设我们有一个TokenUtil类：

// 伪代码，实际方法名需查看库文档 int totalTokens = TokenUtil.countTokens(conversationHistory, “gpt-3.5-turbo”); int maxContextTokens = 16000; // 留出一些空间给本次生成 int maxTokensForReply = 500; if (totalTokens + maxTokensForReply > maxContextTokens) { // 需要清理历史 while (totalTokens + maxTokensForReply > maxContextTokens && conversationHistory.size() > 1) { // 移除最早的非系统消息（通常系统消息很重要，要保留） // 这里简单移除第一条用户或助手消息 for (int i = 0; i < conversationHistory.size(); i++) { ChatMessage msg = conversationHistory.get(i); if (msg.getRole() != MessageType.SYSTEM) { conversationHistory.remove(i); break; } } // 重新计算Token数 totalTokens = TokenUtil.countTokens(conversationHistory, “gpt-3.5-turbo”); } }

这个策略能保证对话在有限的上下文窗口内持续进行。在实际产品中，你可能需要设计更复杂的摘要机制（例如，让AI自己总结过长的历史），但上述方法对于大多数场景已经足够。

5. 集成到Spring Boot应用：构建一个AI服务

命令行工具只是玩具，我们最终是要把它集成到Web应用里的。下面演示如何在Spring Boot中创建一个简单的AI服务。

5.1 配置与Bean管理

首先，我们将ChatGPT客户端配置为Spring的Bean，方便依赖注入。

import live.cjcrafter.chatapi.ChatGPT; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class ChatGPTConfig { @Value("${openai.api.key}") private String apiKey; @Bean public ChatGPT chatGpt() { // 这里可以添加更多自定义配置，如超时、代理等 return new ChatGPT(apiKey); } }

在application.yml或application.properties中配置你的API Key：

openai: api: key: ${OPENAI_API_KEY} # 优先从环境变量读取

5.2 创建Service层

创建一个Service来处理具体的AI逻辑，这样Controller层就干净了。

import live.cjcrafter.chatapi.ChatGPT; import live.cjcrafter.chatapi.ChatCompletionRequest; import live.cjcrafter.chatapi.ChatCompletionResult; import live.cjcrafter.chatapi.message.ChatMessage; import live.cjcrafter.chatapi.message.MessageType; import org.springframework.stereotype.Service; import org.springframework.util.StringUtils; import java.util.ArrayList; import java.util.List; @Service public class AIChatService { private final ChatGPT chatGpt; // 为每个会话（如用户ID）维护独立的历史记录。生产环境应使用缓存（如Redis）。 private final ThreadLocal<List<ChatMessage>> sessionHistory = ThreadLocal.withInitial(ArrayList::new); public AIChatService(ChatGPT chatGpt) { this.chatGpt = chatGpt; // 初始化系统指令 resetSessionHistory(); } private void resetSessionHistory() { List<ChatMessage> history = sessionHistory.get(); history.clear(); history.add(ChatMessage.of(MessageType.SYSTEM, "你是一个专业的编程助手，擅长Java和Spring Boot。")); } public String sendMessage(String userMessage, String sessionId) { if (!StringUtils.hasText(userMessage)) { return "请输入有效内容。"; } List<ChatMessage> history = sessionHistory.get(); history.add(ChatMessage.of(MessageType.USER, userMessage)); ChatCompletionRequest request = ChatCompletionRequest.builder() .model("gpt-3.5-turbo") .messages(new ArrayList<>(history)) .temperature(0.5) // 代码相关，调低随机性 .maxTokens(800) .build(); try { ChatCompletionResult result = chatGpt.complete(request); if (result != null && !result.getChoices().isEmpty()) { String aiReply = result.getChoices().get(0).getMessage().getContent(); history.add(ChatMessage.of(MessageType.ASSISTANT, aiReply)); // 简单管理历史长度，防止过长 manageHistoryLength(history); return aiReply; } } catch (Exception e) { // 记录日志 e.printStackTrace(); return "抱歉，AI服务暂时不可用。"; } return "未收到回复。"; } private void manageHistoryLength(List<ChatMessage> history) { int maxRounds = 10; // 保留最近10轮对话（不含系统消息） long userAssistantMessageCount = history.stream() .filter(m -> m.getRole() == MessageType.USER || m.getRole() == MessageType.ASSISTANT) .count(); if (userAssistantMessageCount > maxRounds * 2) { // 一轮包含一问一答 // 移除最早的一对用户/助手消息（保留系统消息） int indexToRemove = -1; for (int i = 0; i < history.size(); i++) { if (history.get(i).getRole() != MessageType.SYSTEM) { indexToRemove = i; break; } } if (indexToRemove != -1) { history.remove(indexToRemove); // 如果移除的是用户消息，下一个很可能是助手消息，也一并移除以保持配对 if (indexToRemove < history.size() && history.get(indexToRemove).getRole() != MessageType.SYSTEM) { history.remove(indexToRemove); } } } } public void clearHistory() { resetSessionHistory(); } }

5.3 创建REST API端点

最后，暴露一个简单的HTTP接口。

import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/api/ai") public class AIChatController { private final AIChatService aiChatService; public AIChatController(AIChatService aiChatService) { this.aiChatService = aiChatService; } @PostMapping("/chat") public ApiResponse<String> chat(@RequestBody ChatRequest request, @RequestHeader(value = "X-Session-Id", required = false) String sessionId) { // sessionId可用于区分不同用户的对话历史，这里简化处理 String reply = aiChatService.sendMessage(request.getMessage(), sessionId); return ApiResponse.success(reply); } @PostMapping("/clear") public ApiResponse<Void> clearHistory(@RequestHeader(value = "X-Session-Id", required = false) String sessionId) { aiChatService.clearHistory(); return ApiResponse.success(null); } // 简单的请求响应对象 public static class ChatRequest { private String message; // getter and setter } public static class ApiResponse<T> { private int code; private String msg; private T data; // 静态success方法等 } }

现在，你的Spring Boot应用就拥有了一个具备上下文记忆的AI聊天接口。前端可以通过发送POST请求到/api/ai/chat进行交互。

6. 生产环境考量与最佳实践

把库用起来是一回事，用到生产环境是另一回事。下面分享一些在真实项目中踩过坑后总结的经验。

6.1 稳定性与容错

OpenAI的API并非100%可用，网络也可能波动。你的代码必须健壮。

• 设置合理的超时：在创建ChatGPT客户端时，务必配置连接超时和读取超时。对于同步调用，建议总超时时间设置得稍长，比如30-60秒，因为AI生成长文本需要时间。对于流式调用，可以设置更长的读取超时，或者使用心跳机制。

  // 伪代码，具体配置方式取决于库的构造函数或Builder ChatGPT client = new ChatGPT(apiKey, timeoutConfig);

• 实现重试机制：对于可重试的错误（如网络超时、5xx服务器错误），应该实现指数退避重试。注意，并非所有错误都应重试（如认证失败、超过配额、请求格式错误等）。

  public ChatCompletionResult callWithRetry(ChatCompletionRequest request, int maxRetries) { int attempt = 0; while (attempt <= maxRetries) { try { return chatGpt.complete(request); } catch (IOException e) { // 假设库抛出的是IOException attempt++; if (attempt > maxRetries) { throw new RuntimeException("调用API失败，已达最大重试次数", e); } long waitTime = (long) (Math.pow(2, attempt) * 1000 + Math.random() * 1000); // 指数退避加抖动 try { Thread.sleep(waitTime); } catch (InterruptedException ie) { Thread.currentThread().interrupt(); throw new RuntimeException("重试被中断", ie); } } } return null; }

• 优雅降级：当AI服务完全不可用时，你的应用应该有一个备选方案。比如，返回一个预设的友好提示，或者切换到一个更简单的基于规则的回复系统。

6.2 性能与成本优化

API调用是按Token收费的，而且有速率限制。优化这两点能省下真金白银。

• 缓存：对于常见、重复的问题（例如“你是谁？”、“怎么用？”），可以将AI的回复缓存起来（使用Redis或本地缓存如Caffeine），下次直接返回缓存结果，避免重复调用。注意，只有当问题完全相同时才适用。
• 精简输入：在构建messages时，避免发送不必要的信息。例如，如果历史对话很长，可以考虑只发送最近几轮，或者让AI先对历史做一个摘要再发送。这能显著减少Token消耗。
• 异步与非阻塞：在高并发场景下，务必使用异步客户端（如completeAsync）或配合Spring WebFlux等响应式框架，避免阻塞业务线程池。
• 监控与告警：监控API调用的成功率、延迟、Token消耗量。设置告警，当失败率升高、延迟激增或Token消耗异常时及时通知。

6.3 安全与合规

这是最容易忽视也最重要的一环。

• API Key管理：绝对不要将API Key硬编码在代码中或提交到版本控制系统。使用环境变量、配置中心（如Spring Cloud Config）或密钥管理服务（如AWS KMS, HashiCorp Vault）。
• 输入输出审查：不要盲目信任用户的输入和AI的输出。用户输入可能包含恶意提示（Prompt Injection），诱导AI说出不当内容。AI的输出也可能包含偏见、错误信息或不安全代码。建立审查机制，对敏感内容进行过滤。
• 数据隐私：明确告知用户对话数据会被发送给第三方（OpenAI）进行处理。根据你的业务所在地法规（如GDPR），可能需要提供数据删除的途径。避免在请求中发送个人可识别信息（PII）。
• 使用限制：在服务端对用户进行限流，防止恶意用户刷爆你的API配额。

7. 常见问题与排查技巧实录

在实际使用中，你肯定会遇到各种各样的问题。这里整理了一份速查表。

独家避坑技巧：

• 代理配置：如果你所在网络环境需要代理才能访问OpenAI，这个库通常支持通过OkHttpClient.Builder或系统属性来设置代理。一个更通用的方法是在启动JVM时设置全局代理参数：-Dhttps.proxyHost=your.proxy.com -Dhttps.proxyPort=8080。注意，这需要代理服务器支持HTTPS流量。
• 日志调试：启用HTTP客户端的详细日志（例如，为OkHttp设置HttpLoggingInterceptor），可以清晰地看到发出的请求和收到的响应，对于排查序列化、网络问题非常有帮助。但注意在生产环境关闭，以免日志泄露API Key。
• Token计算差异：不同版本的tiktoken编码库或不同的计算方式，可能导致Token计数与OpenAI后端有细微差异。在设置max_tokens时，最好留出10%左右的余量，避免因计数误差导致请求失败。
• 处理流式响应的“思考”过程：在某些模型（如GPT-4）的流式响应中，你可能会先收到一个包含reasoning（推理内容）的块，然后才是实际的content。如果你的代码只处理content，可能会错过这部分信息。根据你的需求，决定是否要捕获和展示这些“思考过程”。

8. 扩展思路：超越简单对话

掌握了基础用法，我们可以玩点更花的。ChatGPT-Java-API不只是用来聊天的。

1. 构建代码审查助手你可以将Git diff或代码片段发送给AI，让它以“资深程序员”的角色进行审查，指出潜在bug、性能问题或代码风格改进建议。关键在于设计好的system提示词：“你是一个经验丰富的Java/Go/Python代码审查专家。请分析以下代码，指出其中的bug、安全漏洞、性能瓶颈、不规范的写法，并给出改进建议。”

2. 实现智能日志分析在运维场景，当日志量巨大时，可以将错误日志摘要发送给AI，让它帮你分析可能的原因和排查步骤。这需要你先对日志进行一些预处理（如提取关键错误信息、时间戳、关联请求ID），然后构造一个分析性的提问。

3. 创建内容生成流水线结合模板引擎（如Thymeleaf, FreeMarker），你可以用AI动态生成邮件、报告、产品描述甚至营销文案。例如，定义一个邮件模板，其中某些部分由AI根据用户数据填充。这需要你精心设计提示词，并可能进行多轮对话（第一轮生成大纲，第二轮润色等）。

4. 开发AI驱动的单元测试生成器这是一个高级应用。将你的方法签名、类定义和一些上下文信息（比如这个方法是干什么的）发给AI，提示它“为以下Java方法生成JUnit 5单元测试，覆盖正常情况和边界情况”。虽然生成的测试用例不一定完美，但能极大提升开发效率，尤其是对于边界条件复杂的逻辑。

这些扩展的核心，都在于精心设计提示词（Prompt Engineering）和将AI能力嵌入到你现有的业务流程中。ChatGPT-Java-API为你提供了稳定可靠的Java调用层，让你可以专注于业务逻辑和提示词优化，而不必担心底层的通信细节。