SpringAI 之AI 模型输出与 POJO 映射
在使用 AI 模型时，返回的结果通常以 JSON 格式呈现，或者是一组键值对的结构化数据。为了便于在 Java 中进行后续处理与存储，通常需要将这些输出映射到 Java 的 POJO（Plain Old Java Object）对象中。这一过程可以通过 Spring 的工具或常见的 JSON 序列化/反序列化库（如 Jackson、Gson）轻松实现。
以下将介绍如何将 AI 模型的输出映射到 POJO，并结合具体示例讲解常见的实现步骤。
1. 为什么需要 POJO 映射？
- 简化后续处理：将 AI 模型的输出映射到 POJO 后，可以直接通过对象的字段访问数据，而无需手动解析 JSON，提高代码可读性与可维护性。
- 与数据库交互：映射到 POJO 后，可以直接将数据存储到数据库中，例如通过 JPA 或 MyBatis 进行持久化。
- 便于扩展：当需要扩展数据处理逻辑时，POJO 结构可以很好地适配新的需求。
2. 实现步骤
(1) 定义 POJO 类
根据 AI 模型的输出结构，定义相应的 POJO 类。
假设 AI 模型返回的 JSON 输出如下：
{
"id": "response-1",
"prompt": "Describe a sunset",
"generated_text": "A breathtaking view of the sun setting over the mountains.",
"confidence": 0.95
}
对应的 POJO 类可以定义为：
package com.example.springaidemo.model;
public class AiResponse {
private String id;
private String prompt;
private String generatedText;
private double confidence;
// Getters and Setters
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getPrompt() {
return prompt;
}
public void setPrompt(String prompt) {
this.prompt = prompt;
}
public String getGeneratedText() {
return generatedText;
}
public void setGeneratedText(String generatedText) {
this.generatedText = generatedText;
}
public double getConfidence() {
return confidence;
}
public void setConfidence(double confidence) {
this.confidence = confidence;
}
@Override
public String toString() {
return "AiResponse{" +
"id='" + id + '\'' +
", prompt='" + prompt + '\'' +
", generatedText='" + generatedText + '\'' +
", confidence=" + confidence +
'}';
}
}
(2) AI 输出的 JSON 结构
假设使用 OpenAI 的 API，返回的结果为：
{
"id": "response-123",
"object": "text_completion",
"choices": [
{
"text": "This is a generated text.",
"index": 0,
"logprobs": null,
"finish_reason": "stop"
}
],
"created": 1672345678,
"usage": {
"prompt_tokens": 5,
"completion_tokens": 10,
"total_tokens": 15
}
}
可以将 choices 中的内容映射到一个嵌套 POJO。
(3) 定义嵌套 POJO
定义用于存储 choices 和 usage 数据的嵌套对象：
package com.example.springaidemo.model;
import java.util.List;
public class OpenAiResponse {
private String id;
private String object;
private List<Choice> choices;
private Usage usage;
public static class Choice {
private String text;
private int index;
private String finishReason;
// Getters and Setters
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public String getFinishReason() {
return finishReason;
}
public void setFinishReason(String finishReason) {
this.finishReason = finishReason;
}
}
public static class Usage {
private int promptTokens;
private int completionTokens;
private int totalTokens;
// Getters and Setters
public int getPromptTokens() {
return promptTokens;
}
public void setPromptTokens(int promptTokens) {
this.promptTokens = promptTokens;
}
public int getCompletionTokens() {
return completionTokens;
}
public void setCompletionTokens(int completionTokens) {
this.completionTokens = completionTokens;
}
public int getTotalTokens() {
return totalTokens;
}
public void setTotalTokens(int totalTokens) {
this.totalTokens = totalTokens;
}
}
// Getters and Setters for OpenAiResponse
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getObject() {
return object;
}
public void setObject(String object) {
this.object = object;
}
public List<Choice> getChoices() {
return choices;
}
public void setChoices(List<Choice> choices) {
this.choices = choices;
}
public Usage getUsage() {
return usage;
}
public void setUsage(Usage usage) {
this.usage = usage;
}
}
(4) 使用 Jackson 进行映射
使用 Jackson 将 AI 模型返回的 JSON 数据映射到 POJO。
package com.example.springaidemo;
import com.example.springaidemo.model.OpenAiResponse;
import com.fasterxml.jackson.databind.ObjectMapper;
public class AiResponseMapper {
public static OpenAiResponse mapJsonToPojo(String json) {
try {
ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.readValue(json, OpenAiResponse.class);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
在控制器中调用 AiResponseMapper 进行测试：
@GetMapping("/ai-output")
public OpenAiResponse getAiOutput() {
String jsonResponse = "{\"id\":\"response-123\",...}"; // 模拟的 AI 输出 JSON
return AiResponseMapper.mapJsonToPojo(jsonResponse);
}
3. 存储到数据库
使用 JPA 将映射后的 POJO 存储到数据库中。
定义实体类
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class AiRecord {
@Id
private String id;
private String prompt;
private String response;
private double confidence;
// Getters, Setters, and toString
}
存储到数据库
在服务类中注入 JPA 的 CrudRepository：
@Service
public class AiDatabaseService {
@Autowired
private AiRecordRepository repository;
public void saveAiRecord(AiRecord record) {
repository.save(record);
}
}
4. 总结
通过以下步骤：
- 定义 POJO：基于 AI 输出定义对应的 Java 对象。
- 使用 Jackson 映射：利用 Jackson 将 JSON 转换为 POJO。
- 存储与处理：将 POJO 持久化到数据库，便于后续处理和分析。
这种方式实现了 AI 输出的结构化处理，并增强了系统的可维护性和可扩展性。
原文地址：https://blog.csdn.net/u012561308/article/details/145297764
免责声明：本站文章内容转载自网络资源，如侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！