在SpringBoot项目中接入DeepSeek大模型的完整流程_Java

一、基础环境准备

安装的 jdk 版本必须是 17 或 21，不能选择其他版本！ 因为项目使用最新版本的 spring boot 3 和 spring ai 开发框架。

推荐使用 21 版本，因为支持虚拟线程这个王炸功能。

二、新建项目

在 idea 中新建项目，选择 spring initializr 模板，注意需要确保 server url 为 https://start.spring.io/。

java 版本选择 21。

选择 spring boot 3.4.4 版本，可以根据自己的需要添加一些依赖，比如 spring web 和 lombok。

当然，后续通过修改 maven 配置添加依赖也是可以的。

点击创建，就得到了一个 spring boot 项目，需要等待 maven 为我们安装依赖。

小提示，如果 lombok 依赖报错的话，可以手动指定 lombok 的版本，pom.xml 代码如下：

<dependency>
    <groupid>org.projectlombok</groupid>
    <artifactid>lombok</artifactid>
    <version>1.18.36</version>
    <optional>true</optional>
</dependency>

三、整合依赖

可以根据自己的需要，整合一些开发项目常用的依赖。此处我们整合 hutool 工具库和 knife4j 接口文档即可。

1、hutool 工具库

hutool 是主流的 java 工具类库，集合了丰富的工具类，涵盖字符串处理、日期操作、文件处理、加解密、反射、正则匹配等常见功能。

参考官方文档引入：https://doc.hutool.cn/pages/index/#%f0%9f%8d%8amaven

在 maven 的 pom.xml 中添加依赖：

<dependency>
    <groupid>cn.hutool</groupid>
    <artifactid>hutool-all</artifactid>
    <version>5.8.37</version>
</dependency>

2、knife4j 接口文档

knife4j 是基于 swagger 接口文档的增强工具，提供了更加友好的 api 文档界面和功能扩展，例如动态参数调试、分组文档等。

参考官方文档引入，注意我们使用的是 spring boot 3.x。

1）在 maven 的 pom.xml 中添加依赖：

<dependency>
    <groupid>com.github.xiaoymin</groupid>
    <artifactid>knife4j-openapi3-jakarta-spring-boot-starter</artifactid>
    <version>4.4.0</version>
</dependency>

2）新建 controller 包用于存放 api 接口，编写一个健康检查接口用于测试接口文档是否正常引入：

@restcontroller
@requestmapping("/health")
public class healthcontroller {

  @getmapping("/check")
  public string checkhealth(){
    return "ok";
  }
}

3）在 application.yml 中追加接口文档配置，扫描 controller 包：

server:
  port: 8080
  servlet:
    context-path: /api
######################################################
############          接口文档配置           #####################
######################################################
# 访问地址   ${server.servlet.context-path}/doc.html
springdoc:
  swagger-ui:
    path: /swagger-ui.html
    tags-sorter: alpha
    operations-sorter: alpha
  api-docs:
    path: /v3/api-docs
  group-configs:
    - group: 'default'
      paths-to-match: '/**'
      packages-to-scan: com.qianliuliang.love.controller # 配置扫描哪些包的接口要加入到文档
# knife4j config
knife4j:
  enable: true
  setting:
    language: zh_cn

4）启动项目，访问 http://localhost:8080/api/doc.html 能够看到接口文档。

如果是要开发完整项目，除了引入依赖之外，还要编写一些通用基础代码，比如自定义异常、响应包装类、全局异常处理器、请求包装类、全局跨域配置等。

5）验证项目是否正常，直接在接口文档发起调试，成功返回"ok"，说明项目初始化没有问题

四、大模型接入

使用springai接口deepseek模型（需准备deepseek apikey）

1）在pom.xml中引入依赖

 <!--整合llm-->
<dependency>
    <groupid>org.springframework.ai</groupid>
    <artifactid>spring-ai-openai-spring-boot-starter</artifactid>
</dependency>

2）在deepseek官网中申请apikey
官网地址 https://www.deepseek.com/
操作步骤如下：

点击<api开放平台>

依次点击、<创建api key>

创建号api key后妥善保管，也不要提交到远端

3）在application.yaml 添加模型配置

spring:
  application:
    name: ai_love
  #ds模型配置
  ai:
    openai:
      api-key: 你的apikey
      base-url: https://api.deepseek.com
      chat:
        options:
          model: deepseek-chat

api-key: 你的apikey 把申请的key填入

4）配置chatclient bean

在项目中创建package 名称为：config；在包下面创建类，内容如下：

package com.qianliuliang.love.config;

import com.qianliuliang.love.advisor.myloggeradvisor;
import org.springframework.ai.chat.client.chatclient;
import org.springframework.ai.chat.client.advisor.messagechatmemoryadvisor;
import org.springframework.ai.chat.memory.chatmemory;
import org.springframework.ai.chat.memory.inmemorychatmemory;
import org.springframework.ai.openai.openaichatmodel;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.configuration;

/**
 * chatclient bean
 */
@configuration
public class client {


    /**
     * 基于内存会话记忆的  client
     *
     * @param openaichatmodel
     * @return
     */
    @bean
    public chatclient chatclientwithchatmemory(openaichatmodel openaichatmodel) {
        // 基于内存的会话记忆，可实现上下文记忆会话
        chatmemory chatmemory = new inmemorychatmemory();
        return chatclient.builder(openaichatmodel)
                .defaultsystem("你是一个智能恋爱助手！名字叫lovedd") // 系统提示词
                .defaultadvisors(new messagechatmemoryadvisor(chatmemory),
                        new myloggeradvisor()) // 自定义日志
                .build();
    }

}

创建chat对话

import lombok.extern.slf4j.slf4j;
import org.springframework.ai.chat.client.chatclient;
import org.springframework.ai.chat.client.advisor.simpleloggeradvisor;
import org.springframework.ai.chat.model.chatresponse;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;

/**
 * 简单会话
 */
@slf4j
@component
public class simplechat {

    @autowired
    private chatclient chatclient; 

    /**
     * 普通文本会话
     *
     * @param msg 用户消息
     * @param chatid 会话id
     * @return
     */
    public string dochatwithstring(@requestparam string msg, string chatid) {
        chatresponse chatresponse = chatclient.prompt()
                .advisors(advisorspec ->
                        advisorspec.param("chat_memory_conversation_id", chatid) //会话id/聊天室id
                        .param("chat_memory_response_size", 10))// 支持10轮会话
                .user(msg)
                //.advisors(new simpleloggeradvisor())//日志打印
                .call()
                .chatresponse();
        return chatresponse.getresult().getoutput().gettext();// 返回与大模型的对话的内容
    }
}

创建controller

import com.qianliuliang.love.chat.simplechat;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.web.bind.annotation.postmapping;
import org.springframework.web.bind.annotation.requestmapping;
import org.springframework.web.bind.annotation.restcontroller;

@restcontroller
@requestmapping("/chat")
public class chatcontroller {


    @autowired
    private simplechat simplechat;

    /**
     * 普通文本会话
     *
     * @param msg
     * @param chatid
     * @return
     */
    @postmapping("/dochatwithstring")
    public string dochatwithstring( string msg, string chatid) {
        return simplechat.dochatwithstring(msg, chatid);
    }
}