Java 调用国内主流 AI 大语言模型实战指南

默认输出为 JSON 格式，包含完整的元数据。如果只需要纯文本回复，可提取 choices[0].message.content 字段：

String content = result.getOutput().getChoices().get(0).getMessage().getContent();
System.out.println(content);

2. Java 调用 DeepSeek

DeepSeek-R1 等模型具备推理能力，返回结果中包含 reasoning_content（思考过程）。注意： 若要获取该字段，SDK 版本需不低于 2.18.2。

2.1 快速开始

调用逻辑与通义千问类似，但需注意模型名称及参数配置：

// 确保 dashscope SDK 版本 >= 2.18.2
import java.util.Arrays;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        Generation gen = new Generation();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("你是谁？")
                .build();

        GenerationParam param = GenerationParam.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("deepseek-r1")
                .messages(Arrays.asList(userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE) // 必须设置为 MESSAGE，否则无法获取 reasoning_content
                .build();
        return gen.call(param);
    }

    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println("思考过程：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getReasoningContent());
            System.out.println("回复内容：");
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            System.err.println("An error occurred while calling the generation service: " + e.getMessage());
        }
    }
}

2.2 多轮对话实现

API 默认不保留历史上下文。如需模拟'记忆'，需在每次请求时将之前的对话记录拼接到 messages 列表中：

// 构建包含历史记录的对话列表
Message userMsg1 = Message.builder().role(Role.USER.getValue()).content("你好").build();
Message assistantMsg = Message.builder().role(Role.ASSISTANT.getValue()).content("你好！很高兴见到你，有什么我可以帮忙的吗？").build();
Message userMsg2 = Message.builder().role(Role.USER.getValue()).content("你是谁").build();

GenerationParam param = GenerationParam.builder()
        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
        .model("deepseek-r1")
        .messages(Arrays.asList(userMsg1, assistantMsg, userMsg2))
        .resultFormat(GenerationParam.ResultFormat.MESSAGE)
        .build();

2.3 流式输出优化

DeepSeek-R1 的思考过程可能较长，同步等待容易触发超时。使用流式输出（Streaming）可以实时接收片段，提升体验并降低超时风险。

import io.reactivex.Flowable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Main {
    private static final Logger logger = LoggerFactory.getLogger(Main.class);
    private static StringBuilder reasoningContent = new StringBuilder();
    private static StringBuilder finalContent = new StringBuilder();
    private static boolean isFirstPrint = true;

    private static void handleGenerationResult(GenerationResult message) {
        String reasoning = message.getOutput().getChoices().get(0).getMessage().getReasoningContent();
        String content = message.getOutput().getChoices().get(0).getMessage().getContent();

        if (!reasoning.isEmpty()) {
            reasoningContent.append(reasoning);
            if (isFirstPrint) {
                System.out.println("====================思考过程====================");
                isFirstPrint = false;
            }
            System.out.print(reasoning);
        }
        if (!content.isEmpty()) {
            finalContent.append(content);
            if (!isFirstPrint) {
                System.out.println("\n====================完整回复====================");
                isFirstPrint = true;
            }
            System.out.print(content);
        }
    }

    private static GenerationParam buildGenerationParam(Message userMsg) {
        return GenerationParam.builder()
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .model("deepseek-r1")
                .messages(Arrays.asList(userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .incrementalOutput(true) // 开启流式输出
                .build();
    }

    public static void streamCallWithMessage(Generation gen, Message userMsg) throws NoApiKeyException, ApiException, InputRequiredException {
        GenerationParam param = buildGenerationParam(userMsg);
        Flowable<GenerationResult> result = gen.streamCall(param);
        result.blockingForEach(message -> handleGenerationResult(message));
    }

    public static void main(String[] args) {
        try {
            Generation gen = new Generation();
            Message userMsg = Message.builder().role(Role.USER.getValue()).content("你是谁？").build();
            streamCallWithMessage(gen, userMsg);
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            logger.error("An exception occurred: {}", e.getMessage());
        }
    }
}

通过上述方式，我们可以在 Java 应用中灵活集成国内主流大模型，并根据业务需求选择同步或流式交互模式。