基于 DashScope Java SDK 实现通义千问多轮对话与流式输出

背景

在大模型的浪潮中，阿里云推出的通义千问（Qwen）以强大的中文理解能力和开放生态脱颖而出。如果你是一名 Java 开发者，希望快速体验 AI 问答、聊天、知识问答等功能，那么官方提供的 DashScope Java SDK 无疑是最便捷的入口。

本文将带你从零实现一个控制台版 AI 多轮对话 Demo，支持通义千问模型（Qwen）的流式输出，实现类似 ChatGPT 的实时回复体验。

准备工作

1. 注册与获取 API Key

• 访问阿里云 DashScope 平台。
• 登录后进入「控制台」 -> 「API Key 管理」，创建并复制你的 API Key。
• 请妥善保管此 Key，不要上传到公共仓库。

2. 创建 Java 项目并引入依赖

如果你使用 Maven 构建项目，只需在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dashscope-sdk-java</artifactId>
    <version>2.21.12</version>
    <!--如果有冲突请排除掉slf4j-simple-->
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
        </exclusion>
    </exclusions>
</dependency>

提示：版本号可到 DashScope SDK 官方仓库查看最新版本。

代码实现

接下来我们实现一个完整的控制台应用：

• 支持用户多轮输入；
• 每轮对话都带上下文记忆；
• 采用通义千问的流式输出模式（边生成边显示）。

核心代码

public   {
    
          ;

    
      GenerationParam  {
         GenerationParam.builder()
                .apiKey(API_KEY)
                .model() 
                .messages(messages)
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .incrementalOutput() 
                .build();
    }

    
      Flowable<GenerationResult>   ApiException, NoApiKeyException, InputRequiredException {
            ();
         gen.streamCall(param); 
    }

    
      Message  {
         Message.builder().role(role.getValue()).content(content).build();
    }

        {
         {
            List<Message> messages =  <>();
            
            messages.add(createMessage(Role.SYSTEM, ));

            
             (   ; i < ; i++) {
                    (System.in);
                System.out.print();
                   scanner.nextLine();
                 (.equalsIgnoreCase(userInput)) {
                    ;
                }
                
                messages.add(createMessage(Role.USER, userInput));

                
                   createGenerationParam(messages);

                
                    (); 
                    ();

                Flowable<GenerationResult> resultFlowable = callGenerationWithMessages(param);
                System.out.print();
                resultFlowable
                        .subscribeOn(Schedulers.io()) 
                        .observeOn(Schedulers.computation()) 
                        .subscribe(result -> {
                               result.getOutput().getChoices().get().getMessage().getContent();
                               result.getOutput().getChoices().get().getFinishReason();
                            System.out.print(content);
                            fullContent.append(content);

                            
                             (finishReason !=  && !.equals(finishReason)) {
                                System.out.println();
                                System.out.println( + result.getUsage().getInputTokens());
                                System.out.println( + result.getUsage().getOutputTokens());
                                System.out.print( + result.getUsage().getTotalTokens());
                            }
                            System.out.flush(); 
                        }, 
                        
                        error -> {
                            System.err.println( + error.getMessage());
                            latch.countDown();
                        }, 
                        
                        () -> {
                            System.out.println(); 
                            
                            latch.countDown();
                        });
                latch.await();
                messages.add(createMessage(Role.SYSTEM, fullContent.toString()));
            }
        }  (ApiException | NoApiKeyException | InputRequiredException e) {
            e.printStackTrace();
        }  (InterruptedException e) {
              (e);
        }
        System.exit();
    }
}