Java实现Deepseek人工智能Ai助手

这个项目是一个基于Java的Deepseek人工智能Ai助手，它使用Java和Spring Boot框架进行开发。Deepseek是一个基于深度学习的人工智能框架，它提供了许多功能，如自然语言处理、机器学习等。

Maven依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
</dependency>
<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
</dependency>

配置文件 application.yml

# Deepseek 深度求索
deepseek:
  path: https://api.deepseek.com
  name: SMART
  key: sk-121a8db621ba4618aabaxxxxxxxxxx

配置类 DeepseekConfig

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.smart.common.core.redis.RedisCache;
import com.smart.common.plugin.deepseek.bean.DeepseekRequest;
import com.smart.common.plugin.deepseek.bean.DeepseekResponse;
import okhttp3.*;
import okio.BufferedSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
import javax.annotation.PostConstruct;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * DeepseekConfig 类
 * <p>
 * Deepseek官方文档可参考【https://api-docs.deepseek.com/zh-cn/api/create-chat-completion】
 */
@Component
public class DeepseekConfig {

    @Value("${deepseek.path}")
    private String DEEPSEEK_API_PATH;
    @Value("${deepseek.key}")
    private String DEEPSEEK_API_KEY;
    @Value("${deepseek.name}")
    private String DEEPSEEK_API_NAME;

    // 初始化问题条件
    private static final String INIT_SYSTEM_MESSAGE = "你是一个专家，请直接根据提出的问题给答案，不需要解释";

    private OkHttpClient client;
    @Autowired
    private RedisCache redisCache;

    @PostConstruct
    public void init() {
        if (DEEPSEEK_API_KEY == null || DEEPSEEK_API_KEY.isEmpty()) {
            throw new IllegalArgumentException("Deepseek API KEY 不能为空");
        }
        client = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(30, TimeUnit.SECONDS)
                .writeTimeout(30, TimeUnit.SECONDS)
                .build();
    }

    /**
     * DeepSeek 对话补全（单一对话）
     *
     * @param requestMessage  用户消息内容
     * @return
     */
    public String getChatMessage(String requestMessage) {
        List<DeepseekRequest.MessageItem> messages = new ArrayList<>();
        messages.add(new DeepseekRequest.MessageItem("system", INIT_SYSTEM_MESSAGE));
        messages.add(new DeepseekRequest.MessageItem("user", requestMessage));

        MediaType mediaType = MediaType.parse("application/json");
        DeepseekRequest chatRequest = new DeepseekRequest();
        chatRequest.setMessages(messages);
        chatRequest.setModel("deepseek-chat");
        String requestContent = JSONObject.toJSONString(chatRequest);
        RequestBody body = RequestBody.create(mediaType, requestContent);

        Request request = new Request.Builder()
                .url(DEEPSEEK_API_PATH + "/chat/completions")
                .post(body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .addHeader("Authorization", "Bearer " + DEEPSEEK_API_KEY)
                .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                String responseBody = response.body().string();
                DeepseekResponse chatCompletionResponse = JSONObject.parseObject(responseBody, DeepseekResponse.class);
                if (chatCompletionResponse.getChoices() != null && !chatCompletionResponse.getChoices().isEmpty()) {
                    return chatCompletionResponse.getChoices().get(0).getMessage().getContent();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("系统繁忙，请稍后使用!", e);
        }
        return "系统繁忙，请稍后使用!";
    }

    /**
     * DeepSeek 对话补全（多轮对话）
     *
     * @param requestMessage  用户消息内容
     * @param sessonKey 对话组临时标识
     * @return
     */
    public String getChatMessageGroup(String requestMessage, String sessonKey) {
        // 整合对话组
        List<DeepseekRequest.MessageItem> messages = messageGroup(requestMessage, sessonKey, "user");
        // 执行 DeepSeek API
        MediaType mediaType = MediaType.parse("application/json");
        DeepseekRequest chatRequest = new DeepseekRequest();
        chatRequest.setMessages(messages);
        chatRequest.setModel("deepseek-chat");
        String requestContent = JSONObject.toJSONString(chatRequest);
        RequestBody body = RequestBody.create(mediaType, requestContent);

        Request request = new Request.Builder()
                .url(DEEPSEEK_API_PATH + "/chat/completions")
                .post(body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .addHeader("Authorization", "Bearer " + DEEPSEEK_API_KEY)
                .build();

        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                String responseBody = response.body().string();
                DeepseekResponse chatCompletionResponse = JSONObject.parseObject(responseBody, DeepseekResponse.class);
                if (chatCompletionResponse.getChoices() != null && !chatCompletionResponse.getChoices().isEmpty()) {
                    String assistantContent = chatCompletionResponse.getChoices().get(0).getMessage().getContent();
                    messageGroup(assistantContent, sessonKey, "assistant");
                    return assistantContent;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("系统繁忙，请稍后使用!", e);
        }
        return "系统繁忙，请稍后使用!";
    }

    /**
     * 对话组 临时存储
     *
     * @param message  消息内容
     * @param sessonKey 对话组临时标识
     * @param role 角色（system：系统指令、user：用户提问、assistant：模型回复）
     */
    public List<DeepseekRequest.MessageItem> messageGroup(String message, String sessonKey, String role) {
        String redisKey = "deepseek:" + sessonKey;
        // 判断是否是长对话
        JSONArray redisResult = null;
        if (null != sessonKey){
            redisResult = redisCache.getCacheObject(redisKey);
        }
        List<DeepseekRequest.MessageItem> messages = null;
        if (null == redisResult) {
            // 存储
            messages = new ArrayList<>();
            messages.add(new DeepseekRequest.MessageItem("system", INIT_SYSTEM_MESSAGE));
            messages.add(new DeepseekRequest.MessageItem("user", message));
            redisCache.setCacheObject(redisKey, messages);
        } else {
            redisResult.add(new DeepseekRequest.MessageItem(role, message));
            redisCache.setCacheObject(redisKey, redisResult);
            // JSONArray转List
            messages = redisResult.toList(DeepseekRequest.MessageItem.class);
        }
        return messages;
    }

    /**
     * DeepSeek 对话补全（流式输出）
     *
     * @param requestMessage 用户消息内容
     * @param emitter        SseEmitter 对象
     * @return 模型回复
     */
    public void getChatMessageStream(String requestMessage, SseEmitter emitter) {
        // 构造消息列表
        List<DeepseekRequest.MessageItem> messages = new ArrayList<>();
        messages.add(new DeepseekRequest.MessageItem("system", INIT_SYSTEM_MESSAGE));
        messages.add(new DeepseekRequest.MessageItem("user", requestMessage));

        // 构造请求体
        DeepseekRequest chatRequest = new DeepseekRequest();
        chatRequest.setMessages(messages);
        chatRequest.setModel("deepseek-chat");
        chatRequest.setStream(true); // 启用流式输出

        // 使用 Jackson 将对象转换为 JSON
        ObjectMapper objectMapper = new ObjectMapper();
        String requestContent;
        try {
            requestContent = objectMapper.writeValueAsString(chatRequest);
        } catch (JsonProcessingException e) {
            emitter.completeWithError(new RuntimeException("请求体序列化失败", e));
            return;
        }
        // 构造 HTTP 请求
        MediaType mediaType = MediaType.parse("application/json");
        RequestBody body = RequestBody.create(mediaType, requestContent);
        Request request = new Request.Builder()
                .url(DEEPSEEK_API_PATH + "/chat/completions")
                .post(body)
                .addHeader("Content-Type", "application/json")
                .addHeader("Accept", "application/json")
                .addHeader("Authorization", "Bearer " + DEEPSEEK_API_KEY)
                .build();

        // 发送请求并处理流式响应
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful() && response.body() != null) {
                BufferedSource source = response.body().source();
                while (!source.exhausted()) {
                    // 读取一行响应
                    String chunk = source.readUtf8Line();
                    System.out.println(chunk);
                    if (chunk != null && !chunk.isEmpty()) {
                        // 发送部分响应
                        emitter.send(chunk);
                    }
//                    String content = getKeyContent(chunk);
//                    if (null != content && !content.isEmpty()) {
//                        // 发送部分响应
//                        emitter.send(content);
//                    }
                }
                // 完成流式输出
                emitter.complete();
            } else {
                emitter.completeWithError(new RuntimeException("Deepseek API 请求失败，状态码: " + response.code()));
            }
        } catch (IOException e) {
            emitter.completeWithError(new RuntimeException("Deepseek API 请求失败", e));
        }
    }

    /**
     * 提取JSON中的关键内容
     * @param json
     * @return
     */
    public String getKeyContent(String json){
        // 匹配 content
        Pattern contentPattern = Pattern.compile("\"content\":\"(.*?)\"");
        Matcher contentMatcher = contentPattern.matcher(json);
        String content = contentMatcher.find() ? contentMatcher.group(1) : "";
        // 匹配 id
        // Pattern idPattern = Pattern.compile("\"id\":\"(.*?)\"");
        // Matcher idMatcher = idPattern.matcher(json);
        // String id = idMatcher.find() ? idMatcher.group(1) : "";
        return content;
    }
}

响应实体 DeepseekResponse

import lombok.Data;
import java.util.List;

/**
 * 聊天响应体 类
 */
@Data
public class DeepseekResponse {

    /**
     * 请求ID（对话的唯一标识符），例如：c0bb6a2a-cf89-4480-b30a-d1c2ddf869a8
     */
    private String id;
    /**
     * 对象类型，例如：chat.completion.chunk
     */
    private String object;
    /**
     * 创建时间戳，例如：1741536000
     */
    private Long created;
    /**
     * 模型名称，例如：deepseek-chat
     */
    private String model;
    /**
     * 生成结果列表
     */
    private List<Choice> choices;
    /**
     * 资源消耗统计
     */
    private Usage usage;
    /**
     * 系统指纹，例如：fp_3a5770e1b4_pxxxxxxx
     */
    private String systemFingerprint;

    /**
     * 生成选项
     */
    @Data
    public static class Choice {
        /**
         * 选项序号（选择列表中的索引）例如：0
         */
        private Integer index;
        /**
         * 消息内容（模型生成的 completion 消息。）
         */
        private Message message;
        /**
         * 日志概率值
         */
        private Object logprobs;
        /**
         * 终止原因【stop/length/content_filter/tool_calls/insufficient_system_resource】例如：stop
         *
         * stop：模型自然停止生成，或遇到 stop 序列中列出的字符串。
         * length ：输出长度达到了模型上下文长度限制，或达到了 max_tokens 的限制。
         * content_filter：输出内容因触发过滤策略而被过滤。
         * insufficient_system_resource：系统推理资源不足，生成被打断。
         */
        private String finishReason;
    }

    /**
     * 消息内容
     */
    @Data
    public static class Message {
        /**
         * 角色类型（assistant），例如：assistant
         */
        private String role;
        /**
         * 消息文本，例如：1. 准备温水...
         */
        private String content;
    }

    /**
     * 资源消耗统计
     */
    @Data
    public static class Usage {
        /**
         * 提示词token数，例如：10
         */
        private Integer promptTokens;
        /**
         * 生成token数，例如：100
         */
        private Integer completionTokens;
        /**
         * 总token数，例如：100
         */
        private Integer totalTokens;
        /**
         * 提示词token详情
         */
        private PromptTokensDetails promptTokensDetails;
        /**
         * 缓存命中token数，例如：0
         */
        private Integer promptCacheHitTokens;
        /**
         * 缓存未命中token数，例如：27
         */
        private Integer promptCacheMissTokens;
    }

    /**
     * 提示词token详情
     */
    @Data
    public static class PromptTokensDetails {
        /**
         * 缓存token数，例如：0
         */
        private Integer cachedTokens;
    }
}

对话请求体 DeepseekRequest

import lombok.Data;
import java.util.List;

/**
 * 对话请求体 类
 */
@Data
public class DeepseekRequest {
    /**
     * 对话消息列表，例如： [{\"role\":\"system\",\"content\":\"系统提示语\"},{\"role\":\"user\",\"content\":\"用户提问\"}]
     */
    private List<MessageItem> messages;
    /**
     * 调用的模型名称（deepseek-chat/deepseek-reasoner），例如：deepseek-chat
     */
    private String model;
    /**
     * 流输出（开启true，关闭False）
     */
    private boolean stream;

    /**
     * 对话消息项
     */
    @Data
    public static class MessageItem {
        /**
         * 该消息的发起角色（system/user/assistant/tool），例如：system
         *
         * system：用于设置对话背景、系统指令或模型行为（例如，让模型扮演某个特定角色）
         * user：用于用户输入的问题或请求
         * assistant：用于模型的回复
         */
        private String role;
        /**
         * 消息内容，例如：你是一个程序员专家
         */
        private String content;
        /**
         * 参与者的名称，为模型提供信息以区分相同角色的参与者【选填】
         */
        private String name;

        public MessageItem() {
        }
        public MessageItem(String role, String content) {
            this.role = role;
            this.content = content;
        }
        public MessageItem(String role, String content, String name) {
            this.role = role;
            this.content = content;
            this.name = name;
        }
    }
}

控制层 DeepseekController

import com.smart.common.plugin.deepseek.bean.DeepseekMessageRequest;
import com.smart.system.service.IDeepseekService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;


/**
 * DeepseekController 类
 */
@Api(tags = "人工智能Deepseek", value="DeepseekController")
@RestController
@RequestMapping("/deepseek")
public class DeepseekController {

    @Autowired
    private IDeepseekService deepseekService;

    /**
     * DeepSeek聊天（一问一答）
     * @return
     */
    @ApiOperation("DeepSeek聊天（一问一答）")
    @RequestMapping(value = "/getChatMessage", method = RequestMethod.POST)
    public String getChatMessage(@RequestBody DeepseekMessageRequest req) {
        return deepseekService.getChatMessage(req.getMessage());
    }

    /**
     * DeepSeek聊天（多问多答）
     * @return
     */
    @ApiOperation("DeepSeek聊天（多问多答）")
    @RequestMapping(value = "/getChatMessageGroup", method = RequestMethod.POST)
    public String getChatMessageGroup(@RequestBody DeepseekMessageRequest req) {
        return deepseekService.getChatMessageGroup(req.getMessage(), req.getSessonId());
    }

    /**
     * DeepSeek聊天（流式输出）
     * @return SseEmitter 对象
     */
    @ApiOperation("DeepSeek聊天（流式输出）")
    @RequestMapping(value = "/getChatMessageStream", method = RequestMethod.POST, produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    public SseEmitter getChatMessageStream(@RequestBody DeepseekMessageRequest req) {
        SseEmitter emitter = new SseEmitter(30_000L);  // 设置超时时间 30 秒
        // 模拟异步任务，发送实时数据
        new Thread(() -> {
            try {
                deepseekService.getChatMessageStream(req.getMessage(), emitter);
                emitter.complete();  // 任务完成，结束SSE流
            } catch (Exception e) {
                emitter.completeWithError(e);  // 出现异常时结束流
            }
        }).start();
        return emitter;
    }
}

业务逻辑接口层 IDeepseekService

import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

/**
 * IDeepseekService 接口类
 */
public interface IDeepseekService {
    String getChatMessage(String requestMessage);

    String getChatMessageGroup(String requestMessage, String messageGroupKey);

    void getChatMessageStream(String requestMessage, SseEmitter sseEmitter);
}

业务逻辑实现层 DeepseekServiceImpl

import com.smart.common.plugin.deepseek.DeepseekConfig;
import com.smart.system.service.IDeepseekService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;

/**
 * DeepseekServiceImpl 类
 */
@Service
public class DeepseekServiceImpl implements IDeepseekService {

    @Autowired
    DeepseekConfig deepseekConfig;

    /**
     * DeepSeek聊天（一问一答）
     * @param requestMessage 用户消息内容
     * @return
     */
    @Override
    public String getChatMessage(String requestMessage) {
        return deepseekConfig.getChatMessage(requestMessage);
    }

    /**
     * DeepSeek聊天（多问多答）
     * @param requestMessage 用户消息内容
     * @param messageGroupKey 对话组临时标识
     * @return
     */
    @Override
    public String getChatMessageGroup(String requestMessage, String messageGroupKey)  {
        String res = deepseekConfig.getChatMessageGroup(requestMessage, messageGroupKey);
        return res;
    }

    /**
     * DeepSeek聊天（流式输出）
     * @param requestMessage
     * @param sseEmitter
     */
    @Override
    public void getChatMessageStream(String requestMessage, SseEmitter sseEmitter) {
        deepseekConfig.getChatMessageStream(requestMessage, sseEmitter);
    }
}