引言：我是把三个AI助手整合到一起玩的，你们也可以只调用一个助手，比如想用豆包的，就只看豆包的流程就行

一、豆包、kimi、千问

为什么没有deepseek？因为我尝试了，deepseek需要收费，并且因为资源紧张已经关闭收费平台了，我是没办法用的所以尝试了豆包、kimi、千问这些平台，虽然没有deepseek这么好用，但是日常问点问题还是可以的。

1、豆包API-key

豆包是跳动字节开发的，日常编写程序问问题什么的也算是比较好用

要接入豆包，需要做一些准备工作

        注册火山引擎账号

浏览器搜索火山引擎，点击注册，导航到火山引擎控制台（火山引擎控制台），点击创建API Key，名字可以随便起，也可以默认

之后你就会得到一个API Key

点击这个小眼睛，你就可以看到你的API Key（注：API Key要妥善保管，因为豆包大模型是赠送了一定数量的Token，用完了就是没了，需要充钱，如果你不造，自己用还是够用的）

（建议在桌面创建一个文本，把apikey复制粘贴到文本中，因为kimi的apikey只显示一次，要及时复制下来）

 2、kimi API-Key

kimi是由月之暗面科技有限公司开发的，想要使用kimi，同理，得先注册一个账号

        注册MoonShot账号

浏览器搜索Moonshot Ai，点击kimi开放平台（Moonshot AI 开放平台），点击登录注册，然后点击用户中心

点击右边的导航栏里面的API Key管理新建APIKey

点击新建，名字随便起，你就会获得一个自己的APIKey

（注：kimi新注册的apikey只会出现一次，要记得及时保存下来！！！！保存在创建豆包apikey的时候叫你们创建的桌面文本里）

（新用户能获得15元的赠送金额，我用了两三天，每天问那么四五个小问题，才用了0.05）

3、千问API-key

千问全名是通义千问，是阿里旗下的，同理，要想使用也要注册阿里云账号

        注册阿里云百炼模型服务

访问阿里云百炼模型服务官网地址：阿里云登录 - 欢迎登录阿里云，安全稳定的云计算服务平台，点击“管理控制台”，并同意服务协议。

如果是新用户，可以免费领取每个模型100万tokens的额度。点击“领取免费额度”，并确认开通服务。

创建API Key

在阿里云百炼控制台的右上角，把鼠标放到自己头像上，点击API-KEY

点击创建API-KEY，名字可以随便起

同样把它复制到之前桌面创建的那个文本中

二、准备工作

1、关于idea、jdk

我的idea版本是2024.3.3，jdk版本是jdk17.0.14，其它版本的也是可以的，版本号不能过低就行了，至于低于多少我也不清楚，但是jdk版本不能低于7（好像是？），如果你们发现有些问题解决不了的就要考虑是否是自己的版本过低。

查看自己jdk版本：

按下 Win + R 组合键，输入cmd并回车，在命令提示符窗口中输入java -version回车就可以查看自己的jdk版本

2、添加依赖

编写程序需要添加jar包，也可以用maven，但是我用的是jar包，所以这里以jar包为例

因为我用的是http请求和json数据格式的，所以需要下载关于http和Gson的java包

Http可以去官网下载对应的包（Apache HttpComponents – HttpComponents Downloads），同理，Gson也可以去官网下载对应的包（http://code.google.com/p/google-gson/）比较难进，不想去的话也可以通过我的百度网盘分享的文件下载：
链接：我的百度网盘
提取码：1688

至此，准备工作就差不多了。

3、编写程序

1、打开idea，新建一个项目，名字你随便命名，如我的叫AiAssistant

2、导入包：点击文件---项目结构---找到库---点击上面的+号---选择java---找到刚才下载的JAR包，全选，导入

结果

点击java文件，分别创建doubao、kimi、qianwen的文件夹

首先，在doubao文件夹上右键，点击新建java类，命名为DouBaoAssistant，kimi，千问同理

 豆包代码（注：API_KEY换成你自己的豆包Api-key，就是上面注册申请的API-key）

package doubao;

import com.google.gson.Gson;
import com.google.gson.JsonObject;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DouBaoAssistant {
    private static final String API_URL = "https://ark.cn-beijing.volces.com/api/v3/chat/completions";
    private static final String API_KEY = "85216578********************";//换成你自己的APIKey
    private static final String MODEL_NAME = "doubao-pro-32k-240615"; //模型名称

    public static void GetAssistantResponse(){
        List<JsonObject> messages = new ArrayList<>();
        JsonObject systemMessage = new JsonObject();
        systemMessage.addProperty("role", "system");
        systemMessage.addProperty("content", "你是豆包，是由字节跳动开发的 AI 人工智能助手");
        messages.add(systemMessage);

        while (true) {
            System.out.print("你（输入“退出”退出豆包）：");
            String userInput = new java.util.Scanner(System.in).nextLine();
            if ("退出".equalsIgnoreCase(userInput)) {
                break;
            }

            JsonObject userMessage = new JsonObject();
            userMessage.addProperty("role", "user");
            userMessage.addProperty("content", userInput);
            messages.add(userMessage);

            String response = sendRequest(messages);
            JsonObject assistantMessage = new JsonObject();
            assistantMessage.addProperty("role", "assistant");
            assistantMessage.addProperty("content", response);
            messages.add(assistantMessage);

            System.out.println("豆包： " + response);
        }
    }

    private static String sendRequest(List<JsonObject> messages) {
        HttpClient client = HttpClients.createDefault();
        HttpPost post = new HttpPost(API_URL);
        post.setHeader("Authorization", "Bearer " + API_KEY);
        post.setHeader("Content-Type", "application/json");

        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("model", MODEL_NAME);
        requestBody.add("messages", new Gson().toJsonTree(messages));

        post.setEntity(new StringEntity(requestBody.toString(), "UTF-8"));

        String response = null;
        try {
            response = EntityUtils.toString(client.execute(post).getEntity());
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        JsonObject jsonResponse = new Gson().fromJson(response, JsonObject.class);

        return jsonResponse.getAsJsonArray("choices").get(0).getAsJsonObject().get("message").getAsJsonObject().get("content").getAsString();
    }
}

kimi代码 （注：API_KEY换成你自己的Kimi Api-key，就是上面注册申请的API-key）

package kimi;
import com.google.gson.Gson;
import org.apache.http.*;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.io.IOException;
import java.util.*;

class ChatCompletionResponse {
    String id;
    String object;
    long created;
    String model;
    List<Choice> choices;
    Usage usage;
}
class Choice {
    int index;
    Message message;
    String finish_reason;
}

class Message {
    String role;
    String content;
}

class Usage {
    int prompt_tokens;
    int completion_tokens;
    int total_tokens;
}

public  class KimiMultiTurnChat {
    private static final String API_URL = "https://api.moonshot.cn/v1/chat/completions";
   
    private final String apiKey ;
    private final HttpClient  httpClient;
    private final Gson gson;
    private final List<Map<String,String>> conversationHistory;

    public KimiMultiTurnChat(String apiKey){
        this.apiKey = apiKey;
        this.httpClient = HttpClients.createMinimal();
        this.gson = new Gson();
        this.conversationHistory = new ArrayList<>();
    }

    public String chatWithKimi(String model, String userMessage) throws IOException {

        //添加用户消息到对话历史
        Map<String,String> userMessageMap = new HashMap<>();
        userMessageMap.put("role", "user");
        userMessageMap.put("content", userMessage);
        conversationHistory.add(userMessageMap);

        // 构建请求体
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("model", model);
        requestBody.put("messages", conversationHistory);

        // 将请求体转换为 JSON 字符串
        String jsonBody = gson.toJson(requestBody);

        // 创建 HttpPost 请求
        HttpPost httpPost = new HttpPost(API_URL);
        httpPost.setHeader("Authorization", "Bearer " + apiKey);
        httpPost.setHeader("Content-Type", "application/json");

        //// 设置请求体为 JSON 数据
        StringEntity entity = new StringEntity(jsonBody.toString(), "UTF-8");
        httpPost.setEntity(entity);

        // 执行请求
        HttpResponse response = httpClient.execute(httpPost);

        //检查响应状态码
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode != 200){
            String responseBody = EntityUtils.toString(response.getEntity());
            throw new IOException("请求失败，状态码："+statusCode);
        }

        // 解析响应
        String responseBody = EntityUtils.toString(response.getEntity());
        ChatCompletionResponse chatResponse = gson.fromJson(responseBody, ChatCompletionResponse.class);
        String assistantMessage = chatResponse.choices.get(0).message.content;

        // 添加 Kimi 的回复到对话历史
        Map<String, String> assistantMessageMap = new HashMap<>();
        assistantMessageMap.put("role", "assistant");
        assistantMessageMap.put("content", assistantMessage);
        conversationHistory.add(assistantMessageMap);

        return assistantMessage;
    }

    public static void GetAssistantResponse(){
        //换成你自己的api-key
        String apiKey = "sk-lzo1mUJ******************************";
        KimiMultiTurnChat multiTurnChat = new KimiMultiTurnChat(apiKey);
        Scanner scanner = new Scanner(System.in);

        try{

            System.out.println("欢迎！");

            while (true){
                System.out.print("你（输入“退出”退出kimi）：");
                String userMessage = scanner.nextLine();

                if("退出".equals(userMessage)){
                    System.out.println("对话结束");
                    break;
                }

                String response = multiTurnChat.chatWithKimi("moonshot-v1-8k",userMessage);
                //model:moonshot-v1-8k
                System.out.println("kimi:"+response);
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            //scanner.close();
        }
    }

}

 千问代码（注：API_KEY换成你自己的千问Api-key，就是上面注册申请的API-key）

package qianwen;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class QianWenAssistant {

    
    private static final String API_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions";
    
    //换成你自己的api-key
    private static final String API_KEY = "sk-f3b0aa***********************";

    private static final String MODEL = "qwen-plus";

    public static String sendRequest(String question) {
        HttpClient httpClient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost(API_URL);

        // 设置请求头
        httpPost.setHeader("Authorization", "Bearer " + API_KEY);
        httpPost.setHeader("Content-Type", "application/json");

        // 构造请求体，添加 messages 参数
        List<Map<String, String>> messages = new ArrayList<>();
        Map<String, String> message = new HashMap<>();
        message.put("role", "user");
        message.put("content", question);
        messages.add(message);

        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("messages", messages);
        requestBody.put("model", MODEL);

        Gson gson = new Gson();
        String jsonBody = gson.toJson(requestBody);

        try {
            // 设置请求体为 JSON 数据
            StringEntity entity = new StringEntity(jsonBody, "UTF-8");
            httpPost.setEntity(entity);

            // 执行请求
            HttpResponse response = httpClient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();

            HttpEntity responseEntity = response.getEntity();
            String responseBody = EntityUtils.toString(responseEntity);

            if (statusCode == 200) {

                return responseBody;
            } else {
                if (responseBody != null && !responseBody.isEmpty()) {
                    try {
                        // 解析错误响应体，获取错误代码和错误描述
                        JsonObject errorJson = gson.fromJson(responseBody, JsonObject.class);
                        if (errorJson != null && errorJson.has("error") && errorJson.getAsJsonObject("error").has("code") && errorJson.getAsJsonObject("error").has("message")) {
                            String errorCode = errorJson.getAsJsonObject("error").get("code").getAsString();
                            String errorMessage = errorJson.getAsJsonObject("error").get("message").getAsString();
                            System.err.println("请求失败，状态码: " + statusCode + ", 错误代码: " + errorCode + ", 错误信息: " + errorMessage);
                        } else {
                            System.err.println("请求失败，状态码: " + statusCode + ", 响应体: " + responseBody);
                        }
                    } catch (JsonSyntaxException e) {
                        System.err.println("请求失败，状态码: " + statusCode + ", 响应体非 JSON 格式: " + responseBody);
                    }
                } else {
                    System.err.println("请求失败，状态码: " + statusCode + ", 响应体为空");
                }
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String extractAnswer(String responseBody) {
        try {
            Gson gson = new Gson();
            JsonObject responseJson = gson.fromJson(responseBody, JsonObject.class);
            JsonArray choices = responseJson.getAsJsonArray("choices");
            if (choices != null && choices.size() > 0) {
                JsonObject firstChoice = choices.get(0).getAsJsonObject();
                JsonObject message = firstChoice.getAsJsonObject("message");
                return message.get("content").getAsString();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void GetAssistantResponse(){

        Scanner scanner = new Scanner(System.in);
        boolean keepTalking = true;

        while (keepTalking) {
            System.out.print("你（输入“退出”退出千问）：");
            String questionStr = scanner.nextLine();
            if("退出".equals(questionStr)){
                keepTalking = false;
            }else {
                String responseBody = sendRequest(questionStr);
                if(responseBody != null){
                    String answer = extractAnswer(responseBody);
                    if (answer != null) {
                        System.out.println("千问：" + answer);
                    }else {
                        System.out.println("千问：无法解析回答内容。");
                    }
                }else {
                    System.out.println("千问：请求出现问题，请稍后重试。");
                }
            }
        }
        //scanner.close();
    }
}
Main函数调用（你想在其它地方调用也行，这只是做个演示）
package org.example;

import doubao.DouBaoAssistant;
import kimi.KimiMultiTurnChat;
import qianwen.QianWenAssistant;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        System.out.println("输入1：唤醒豆包助手");
        System.out.println("输入2：唤醒kimi助手");
        System.out.println("输入3：唤醒千问助手");
        System.out.println("输入“4”退出程序");

        Scanner scanner = new Scanner(System.in);
        while (true) {

            String userMessage = scanner.nextLine();

            if("1".equals(userMessage)) {

                System.out.println("开始唤醒豆包助手");

                //调用豆包助手
                DouBaoAssistant.GetAssistantResponse();
            }else if("2".equals(userMessage)) {

                System.out.println("开始唤醒kimi助手");

                //调用kimi助手
                KimiMultiTurnChat.GetAssistantResponse();

            }else if("3".equals(userMessage)) {

                System.out.println("开始唤醒千问助手");
                
                //调用千问助手
                QianWenAssistant.GetAssistantResponse();

            } else if ("4".equals(userMessage)) {
                System.out.println("退出程序");
                break;
            } else {
                System.out.println("输入无效，请重新输入");
            }

            System.out.println("输入1：唤醒豆包助手");
            System.out.println("输入2：唤醒kimi助手");
            System.out.println("输入3：唤醒千问助手");
            System.out.println("输入“4”退出程序");
        }
        scanner.close();
    }
}
演示结果，如图所示，可以实现多轮对话，因为需要先获取服务器那边的回答才会呈现出来，所以回答如果是长文本的时候可能要等个几秒钟才会有答案，并不是程序卡了

结束语：因为我本身也不是专门写Java的，为什么写这篇文章，因为我本身也是一个24届刚毕业的，本职工作是C#工程师，因为开年没啥事干被我师傅抓去搭建ai平台，才摸索出来的，也碰了很多壁，有很多知识点都还不懂，想到如果我在大学时期如果需要搭建Ai平台能看到这篇文章我一定很开心，所以有什么写的不好不对的评论区我们一起探讨。

个人小建议：遇到问题就去问AI助手，AI助手给的解决问题的方式还是比较全面的，多尝试，不要怕碰壁。

# java # 开发语言
Logo
DeepSeek技术社区

欢迎加入DeepSeek 技术社区。在这里，你可以找到志同道合的朋友，共同探索AI技术的奥秘。

更多推荐

cover

【华为开发者空间 x DeepSeek】基于华为开发者空间云主机DeepSeek助力电商企业AI海报文案驱动的最佳实践落地

avatar DeepSeek技术社区
cover

【实战利器】大模型开源项目全盘点！超详细，一定记得收藏！

avatar DeepSeek技术社区

【大模型面试必备】130道大模型问题深度解析，附详细答案，非常详细收藏这一篇就够了！

【大模型面试必备】130道大模型问题深度解析，附详细答案，非常详细收藏这一篇就够了！

avatar DeepSeek技术社区