public class CandidateInfo {
    private String name;
    private int age;
    private String currentCompany;
    private List<String> skills;
    private int yearsOfExperience;

    // getter/setter 省略
}

@BeanOutputConverter<CandidateInfo> converter =
    new BeanOutputConverter<>(CandidateInfo.class);

String prompt = """
    请从以下简历文本中提取候选人信息：
    "张三，28岁，目前在字节跳动担任高级Java开发工程师，
     有5年工作经验，精通Spring Boot、微服务架构、Kafka和Redis。"

    {format}
    """;

PromptTemplate template = new PromptTemplate(prompt);
PromptTemplate.add("format", converter.getFormat());

String response = chatModel.call(
    template.create()
).getResult().getOutput().getContent();

CandidateInfo candidate = converter.convert(response);
System.out.println(candidate.getName());        // 张三
System.out.println(candidate.getSkills());      // [Spring Boot, 微服务架构, Kafka, Redis]

enum Sentiment {
    POSITIVE, NEGATIVE, NEUTRAL, URGENT
}

// 直接在ChatClient上用
String sentiment = chatClient.prompt()
    .user("我等了三天了还没发货，你们到底在搞什么！")
    .call()
    .content(Sentiment.class);  // 返回 URGENT

List<String> keywords = chatClient.prompt()
    .user("从这段文本中提取5个关键词：Spring AI是一个用于构建AI应用的Java框架...")
    .call()
    .content(new ListOutputConverter(new DefaultConversionService()));
// [Spring AI, Java框架, AI应用, 构建, 开发]

@Bean
@Description("查询指定城市的天气")
public WeatherInfo getWeather(
    @Description("城市名称，如：北京") String city,
    @Description("日期，格式：yyyy-MM-dd") String date
) {
    return weatherService.query(city, date);
}

// 第一步：分析用户意图
record UserIntent(String action, Map<String, String> parameters) {}

UserIntent intent = chatClient.prompt()
    .user(userMessage)
    .call()
    .content(UserIntent.class);

// 第二步：根据意图执行对应操作
switch (intent.action()) {
    case "query_order" -> orderService.query(intent.parameters().get("orderId"));
    case "refund" -> orderService.refund(intent.parameters().get("orderId"));
    // ...
}

public class OrderAnalysis {
    @Description("订单状态异常的具体原因，如：超时未发货、商品缺货、物流停滞")
    private String issueReason;

    @Description("建议的处理方式，取值范围：退款、补发、催促、升级处理")
    private String suggestedAction;

    @Description("问题严重程度，1-10分，10为最紧急")
    private int severity;
}

// 简化后的核心逻辑
public class BeanOutputConverter<T> implements StructuredOutputConverter<T> {
    
    private final Class<T> targetClass;
    private final JsonSchemaGenerator schemaGenerator;
    
    @Override
    public String getFormat() {
        // 1. 根据目标 Class 生成 JSON Schema
        JsonSchema schema = schemaGenerator.generate(targetClass);
        
        // 2. 构造提示词模板
        return """
            Your response should be in JSON format conforming to the following schema:
            ```json
            %s

// LangChain4j 用 AiServices 实现结构化输出
interface ResumeParser {
    @SystemMessage("从简历文本中提取候选人信息")
    CandidateInfo parse(String resumeText);
}

// 使用
ResumeParser parser = AiServices.create(ResumeParser.class, chatLanguageModel);
CandidateInfo info = parser.parse(resumeText);

// 缓存 Schema 生成结果（避免每次调用都重新生成）
@Bean
public BeanOutputConverter<CommonResponse> cachedConverter() {
    // BeanOutputConverter 内部会缓存 schema，不用重复创建
    return new BeanOutputConverter<>(CommonResponse.class);
}

@Component
public class StructuredOutputMetrics {
    
    private final MeterRegistry meterRegistry;
    
    public <T> T convertWithMetrics(StructuredOutputConverter<T> converter, 
                                     String response, 
                                     String schemaName) {
        try {
            T result = converter.convert(response);
            meterRegistry.counter("structured.output.success", 
                "schema", schemaName).increment();
            return result;
        } catch (Exception e) {
            meterRegistry.counter("structured.output.failure", 
                "schema", schemaName,
                "error", e.getClass().getSimpleName()).increment();
            throw e;
        }
    }
}

@Service
public class HybridParserService {
    
    @Value("${feature.use-structured-output:false}")
    private boolean useStructuredOutput;
    
    public CandidateInfo parseCandidate(String resume) {
        if (useStructuredOutput) {
            // 新方案：Spring AI 结构化输出
            return springAiConverter.convert(
                chatClient.prompt().user(resume).call().content()
            );
        } else {
            // 旧方案：手动 JSON 解析
            return legacyParser.parse(resume);
        }
    }
}