SpringBoot调用DeepSeek API的完整操作指南_Java

1. 项目依赖

在 pom.xml 中添加以下依赖：

<dependencies>
    <dependency>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-webflux</artifactid>
    </dependency>
    <dependency>
        <groupid>org.projectlombok</groupid>
        <artifactid>lombok</artifactid>
    </dependency>
    <dependency>
        <groupid>com.fasterxml.jackson.core</groupid>
        <artifactid>jackson-databind</artifactid>
    </dependency>
</dependencies>

2. 项目结构

deepseek-project/
├── src/main/java/com/example/deepseek/
│ ├── deepseekapplication.java
│ ├── config/
│ │ └── deepseekconfig.java
│ ├── model/
│ │ ├── chatrequest.java
│ │ ├── chatresponse.java
│ │ └── message.java
│ └── service/
│ └── deepseekservice.java
└── conversation.txt

3. 完整代码实现

3.1 配置类 deepseekconfig.java

package com.example.deepseek.config;

import org.springframework.beans.factory.annotation.value;
import org.springframework.context.annotation.configuration;

@configuration
@getter
public class deepseekconfig {
    @value("${deepseek.api.url}")
    private string apiurl;

    @value("${deepseek.api.key}")
    private string apikey;
}

3.2 请求/响应模型

message.java:

package com.example.deepseek.model;

import lombok.data;

@data
public class message {
    private string role;
    private string content;
}

chatrequest.java:

package com.example.deepseek.model;

import lombok.data;
import java.util.list;

@data
public class chatrequest {
    private string model = "deepseek-ai/deepseek-v3";
    private list<message> messages;
    private boolean stream = true;
    private int max_tokens = 2048;
    private double temperature = 0.7;
    private double top_p = 0.7;
    private int top_k = 50;
    private double frequency_penalty = 0.5;
    private int n = 1;
    private responseformat response_format = new responseformat("text");

    @data
    public static class responseformat {
        private string type;
        
        public responseformat(string type) {
            this.type = type;
        }
    }
}

chatresponse.java:

package com.example.deepseek.model;

import lombok.data;
import java.util.list;

@data
public class chatresponse {
    private list<choice> choices;

    @data
    public static class choice {
        private delta delta;
    }

    @data
    public static class delta {
        private string content;
    }
}

3.3 服务类 deepseekservice.java

package com.example.deepseek.service;

import com.example.deepseek.config.deepseekconfig;
import com.example.deepseek.model.chatrequest;
import com.example.deepseek.model.chatresponse;
import com.example.deepseek.model.message;
import com.fasterxml.jackson.databind.objectmapper;
import lombok.requiredargsconstructor;
import org.springframework.stereotype.service;
import org.springframework.web.reactive.function.client.webclient;
import reactor.core.publisher.flux;

import java.io.filewriter;
import java.io.ioexception;
import java.io.printwriter;
import java.time.localdatetime;
import java.time.format.datetimeformatter;
import java.util.collections;
import java.util.scanner;

@service
@requiredargsconstructor
public class deepseekservice {
    private final deepseekconfig config;
    private final webclient.builder webclientbuilder;
    private final objectmapper objectmapper = new objectmapper();

    public void startinteractivechat() {
        try (scanner scanner = new scanner(system.in);
             printwriter filewriter = new printwriter(new filewriter("conversation.txt", true))) {

            while (true) {
                system.out.print("\n请输入您的问题 (输入 q 退出): ");
                string question = scanner.nextline().trim();

                if ("q".equalsignorecase(question)) {
                    system.out.println("程序已退出");
                    break;
                }

                // 保存问题
                savetofile(filewriter, question, true);

                // 发起对话请求
                flux<string> responseflux = sendchatrequest(question);

                stringbuilder fullresponse = new stringbuilder();
                responseflux
                    .doonnext(chunk -> {
                        system.out.print(chunk);
                        fullresponse.append(chunk);
                    })
                    .dooncomplete(() -> {
                        // 保存完整回复
                        savetofile(filewriter, fullresponse.tostring(), false);
                        system.out.println("\n----------------------------------------");
                        filewriter.println("\n----------------------------------------");
                        filewriter.flush();
                    })
                    .blocklast();
            }
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

    private flux<string> sendchatrequest(string question) {
        chatrequest request = new chatrequest();
        message usermessage = new message();
        usermessage.setrole("user");
        usermessage.setcontent(question);
        request.setmessages(collections.singletonlist(usermessage));

        return webclientbuilder.build()
            .post()
            .uri(config.getapiurl())
            .header("authorization", "bearer " + config.getapikey())
            .header("content-type", "application/json")
            .bodyvalue(request)
            .retrieve()
            .bodytoflux(string.class)
            .filter(line -> line.startswith("data: ") && !line.equals("data: [done]"))
            .map(line -> {
                try {
                    string jsonstr = line.substring(6);
                    chatresponse response = objectmapper.readvalue(jsonstr, chatresponse.class);
                    return response.getchoices().get(0).getdelta().getcontent();
                } catch (exception e) {
                    return "";
                }
            })
            .filter(content -> !content.isempty());
    }

    private void savetofile(printwriter filewriter, string content, boolean isquestion) {
        string timestamp = localdatetime.now().format(datetimeformatter.ofpattern("yyyy-mm-dd hh:mm:ss"));
        if (isquestion) {
            filewriter.printf("\n[%s] question:\n%s\n\n[%s] answer:\n", timestamp, content, timestamp);
        } else {
            filewriter.print(content);
        }
        filewriter.flush();
    }
}

3.4 主应用类 deepseekapplication.java

package com.example.deepseek;

import com.example.deepseek.service.deepseekservice;
import org.springframework.boot.springapplication;
import org.springframework.boot.autoconfigure.springbootapplication;
import org.springframework.context.configurableapplicationcontext;

@springbootapplication
public class deepseekapplication {
    public static void main(string[] args) {
        configurableapplicationcontext context = springapplication.run(deepseekapplication.class, args);
        deepseekservice deepseekservice = context.getbean(deepseekservice.class);
        deepseekservice.startinteractivechat();
    }
}

3.5 配置文件 application.properties

deepseek.api.url=https://api.siliconflow.cn/v1/chat/completions
deepseek.api.key=your_api_key

4. 代码详解

4.1 关键特性

使用 spring webflux 的响应式编程模型

流式处理 api 响应

文件记录对话

错误处理和异常管理

4.2 主要组件

deepseekconfig: 管理 api 配置

deepseekservice: 处理对话逻辑和 api 交互

模型类: 定义请求和响应结构

5. 使用方法

替换 application.properties 中的 your_api_key

运行 deepseekapplication

在控制台输入问题

输入 ‘q’ 退出程序

查看 conversation.txt 获取对话记录

6. 性能和可扩展性

使用响应式编程提高并发性能

灵活的配置管理

易于扩展和定制

7. 注意事项

确保正确配置 api key

处理网络异常

注意内存使用

总结

spring boot 实现提供了一个健壮、可扩展的 deepseek api 调用方案，利用响应式编程提供高效的流式对话体验。

到此这篇关于springboot调用deepseek api的完整操作指南的文章就介绍到这了,更多相关springboot调用deepseek api内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

SpringBoot调用DeepSeek API的完整操作指南

2025年02月13日 • Java •我要评论