今天的核心目标的是：用 Java 代码调用 Kimi API，实现与大模型的完整对话。全程基于 Spring Boot 框架，搭配 OkHttp 发起请求、FastJSON2 解析响应，代码可直接复制运行
一、前期准备（必做）
-
注册 Kimi 开放平台(搜Kimi就可以搜到)，申请 API Key（需完成实名认证，申请后妥善保存，后续用于接口鉴权）；
-
搭建 Java 开发环境（JDK 17+，推荐 17，与 Spring Boot 3.1.5 适配）；
-
创建 Maven 项目，引入所需依赖（Spring Boot 核心、OkHttp、JSON 解析等）。
二、第一步：引入 Maven 依赖
核心依赖包含 Spring Boot 启动器、OkHttp（HTTP 客户端，用于调用 Kimi API）、FastJSON2（JSON 序列化/反序列化）、Lombok（简化实体类代码），版本均选用稳定兼容版，无需额外调整。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.yyf</groupId>
<artifactId>AI-firsttry</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- Spring Boot 核心启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>3.1.5</version>
</dependency>
<!-- OkHttp 客户端：用于发起 HTTP 请求调用 Kimi API -->
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>4.12.0</version>
</dependency>
<!-- FastJSON2：JSON 序列化与反序列化，解析 API 请求/响应数据 -->
<dependency>
<groupId>com.alibaba.fastjson2</groupId>
<artifactId>fastjson2</artifactId>
<version>2.0.32</version>
</dependency>
<!-- Lombok：简化实体类 getter/setter，减少冗余代码 -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<optional>true</optional>
</dependency>
</dependencies>
</project>
三、第二步：创建配置文件（application.yaml）
将 Kimi API 相关配置（API Key、接口地址、模型名称）、请求超时时间等抽离到配置文件，便于后续修改维护，无需改动代码。
注意：api-key 需替换为你在 Kimi 开放平台申请的真实 Key，模型名称可根据需求调整（此处使用 moonshot-v1-8k，轻量且响应较快）。
llm:
kimi:
api-key: 替换为你在Kimi官网申请的真实API Key
api-url: https://api.moonshot.cn/v1/chat/completions
model: moonshot-v1-8k
# 温度控制：0-1之间，值越大回复越具创新性，值越小回复越严谨（0.7为均衡值）
temperature: 0.7
# 请求超时时间（单位：秒），避免因网络问题导致请求卡顿
timeout: 60
四、第三步：创建配置类（读取配置文件）
通过 Spring Boot 的 @ConfigurationProperties 注解，将 yaml 配置文件中的参数映射到 Java 实体类，方便在业务代码中直接调用，无需手动读取配置。
package com.yyf.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* LLM 大模型配置类，读取 application.yaml 中的配置
*/
@Data
@Component
@ConfigurationProperties(prefix = "llm")
public class LlmProperties {
// Kimi 大模型相关配置
private Kimi kimi;
// 温度控制参数（控制回复随机性）
private Double temperature;
// 请求超时时间（单位：秒）
private Integer timeout;
/**
* Kimi 模型配置内部类
*/
@Data
public static class Kimi {
private String apiKey; // Kimi API Key
private String apiUrl; // Kimi API 接口地址
private String model; // Kimi 模型名称
}
}
五、第四步：创建请求/响应相关实体类
根据 Kimi API 的请求格式和响应格式，创建对应的实体类，用于封装请求参数、接收响应数据，避免直接操作 JSON 字符串，提升代码可读性和可维护性。
5.1 对话消息实体（ChatMessage）
封装单条对话消息，包含角色（role）和内容（content）：角色支持 system（系统提示）、user（用户提问）、assistant（AI 回复）。
package com.yyf.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* 对话消息实体：封装单条对话的角色和内容
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChatMessage {
private String role; // 消息角色（system/user/assistant）
private String content; // 消息内容（系统提示/用户提问/AI回复）
}
5.2 对话请求实体（ChatCompletionRequest）
封装调用 Kimi API 所需的请求参数，对应 API 要求的格式，核心参数为模型名称、对话消息列表、温度控制。
package com.yyf.entity.request;
import com.yyf.entity.ChatMessage;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* Kimi API 对话请求实体：封装请求参数
*/
@Data
@NoArgsConstructor
@AllArgsConstructor
public class ChatCompletionRequest {
private String model; // 模型名称（与配置文件中一致）
private List<ChatMessage> messages; // 对话消息列表（可包含多条历史对话）
private Double temperature; // 温度控制：控制回复的随机性（0-1之间）
}
5.3 对话响应实体（ChatCompletionResponse）
package com.yyf.entity.response;
import com.yyf.entity.ChatMessage;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.awt.*;
import java.util.List;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChatCompletionResponse {
private String id;//响应唯一id
private String object;//响应对象类型
private Long created;//创建响应时间戳
private String model;//使用的模型
private List<Choice> choices;//回复内容列表，包含多个Choice对象
private Usage usage;
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class Choice {
private int index;
private ChatMessage message;
private String finishReason;
}
@Data
@NoArgsConstructor
@AllArgsConstructor
public static class Usage {
private int promptTokens;
private int completionTokens;
private int totalTokens;
}
}
六、第五步：编写核心业务代码（调用 Kimi API）
这是整个案例的核心，封装 Kimi API 调用逻辑，通过 OkHttp 发起 POST 请求，处理请求参数序列化、响应数据解析，同时添加异常处理，避免因网络、API 异常导致程序崩溃。
package com.yyf.service;
import com.alibaba.fastjson2.JSON;
import com.yyf.config.LlmProperties;
import com.yyf.entity.ChatMessage;
import com.yyf.entity.request.ChatCompletionRequest;
import com.yyf.entity.response.ChatCompletionResponse;
import jakarta.annotation.PostConstruct;
import jakarta.annotation.Resource;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* LLM 大模型 API 客户端：封装 Kimi API 调用逻辑
*/
@Component
public class LlmApiClient {
@Resource
private LlmProperties llmProperties; // 注入配置类，获取 Kimi 相关配置
private OkHttpClient httpClient; // OkHttp 客户端对象
/**
* 初始化 OkHttp 客户端：在对象创建后执行，设置超时时间
*/
@PostConstruct
public void init() {
this.httpClient = new OkHttpClient.Builder()
.readTimeout(llmProperties.getTimeout(), TimeUnit.SECONDS) // 读取超时
.build();
}
/**
* 调用 Kimi API 实现对话
* @param question 用户提问内容
* @return AI 回复内容
* @throws Exception 异常（请求失败、响应解析失败等）
*/
public String chatKimi(String question) throws Exception {
// 1. 构建请求参数：设置模型、对话消息（系统提示 + 用户提问）、温度
ChatCompletionRequest request = new ChatCompletionRequest(
llmProperties.getKimi().getModel(),
List.of(
new ChatMessage("system", "你是yyf的专属AI助手，回答简洁明了，贴合技术场景"), // 系统提示，定义AI角色
new ChatMessage("user", question) // 用户提问
),
llmProperties.getTemperature()
);
// 2. 将请求实体序列化为 JSON 字符串
String json = JSON.toJSONString(request);
// 3. 构建 OkHttp 请求：设置请求地址、请求头（鉴权）、请求体
Request okRequest = new Request.Builder()
.url(llmProperties.getKimi().getApiUrl()) // Kimi API 接口地址
// 鉴权：Bearer + API Key（固定格式，不可修改）
.header("Authorization", "Bearer " + llmProperties.getKimi().getApiKey())
// POST 请求，请求体为 JSON 格式
.post(RequestBody.create(json, MediaType.get("application/json")))
.build();
// 4. 发起请求并处理响应
try (Response response = httpClient.newCall(okRequest).execute()) {
// 校验响应是否成功
if (!response.isSuccessful()) throw new RuntimeException("Kimi API 请求失败，响应码：" + response.code());
// 读取响应体 JSON 字符串
String respJson = response.body().string();
if (respJson.isEmpty()) {
throw new RuntimeException("Kimi API 响应为空，响应码：" + response.code());
}
// 5. 解析响应 JSON 为实体类
ChatCompletionResponse chatCompletionResponse = JSON.parseObject(respJson, ChatCompletionResponse.class);
// 校验响应中是否包含 AI 回复（choices 不为空）
if (CollectionUtils.isEmpty(chatCompletionResponse.getChoices())) {
throw new RuntimeException("Kimi API 响应中缺失 choices 数据，响应内容：" + respJson);
}
// 6. 返回 AI 回复内容（取第一个选项的消息内容）
return chatCompletionResponse.getChoices().get(0).getMessage().getContent();
}
}
}
七、第六步：创建启动类（测试运行）
创建 Spring Boot 启动类，实现 CommandLineRunner 接口，在项目启动后自动执行 Kimi API 调用，测试对话功能是否正常。
package com.yyf;
import com.yyf.service.LlmApiClient;
import jakarta.annotation.Resource;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* 项目启动类：测试 Kimi API 调用
*/
@SpringBootApplication
public class LlmApplication implements CommandLineRunner {
@Resource
private LlmApiClient llmApiClient; // 注入 API 客户端
@Override
public void run(String... args) throws Exception {
// 测试提问：查询 Agent 相关知识（贴合 AI 开发场景）
String answer = llmApiClient.chatKimi("介绍一下Agent是什么");
// 打印 AI 回复结果
System.out.println("=====KIMI 大模型回复=====");
System.out.println(answer);
}
public static void main(String[] args) {
// 启动 Spring Boot 项目
SpringApplication.run(LlmApplication.class);
}
}
八、运行效果 & 注意事项
8.1 运行效果
启动项目后，控制台会自动输出 AI 回复，类似如下格式：
=====KIMI 大模型回复===== Agent（智能体）是具备自主决策、目标拆解、工具调用能力的 AI 实体，能够根据用户的初始需求，自动规划执行步骤、调用相关工具（如 API、数据库、代码解释器等），逐步完成复杂任务，无需人类持续干预。 在 AI 应用开发中，Agent 常被用于自动化办公、智能问答、代码生成等场景，核心是“自主能力”，区别于普通的 prompt 问答（需要人类明确指令）。
8.2 注意事项
- API Key 必须替换为你自己申请的真实 Key，否则会出现鉴权失败；
- JDK 版本需为 17+，否则 Spring Boot 3.1.5 无法正常启动；
- 若出现 “link dead” 报错，大概率是 Kimi API 接口地址错误或网络问题，检查配置文件中的 api-url 是否为 api.moonshot.cn/v1/chat/com…
- 若响应为空或解析失败，可打印 respJson 查看具体响应内容，排查 API 调用异常原因。
