# spring-boot-ai-deepseek

**Repository Path**: czh-dev/spring-boot-ai-deepseek

## Basic Information

- **Project Name**: spring-boot-ai-deepseek
- **Description**: SpringBoot2.x（JDK1.8）项目中接入DeepSeek
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 8
- **Forks**: 2
- **Created**: 2025-02-22
- **Last Updated**: 2025-07-17

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# SpringBoot接入DeepSeek

SpringBoot2.x + Jdk1.8

## 准备工作

### 获取Api-Key

1. 访问[DeepSeek开放平台](https://platform.deepseek.com/api_keys)
2. 创建API Key
3. 复制API Key

### 创建一个空的SpringBoot项目

略

## 在项目中接入DeepSeek

### 引入依赖（pom.xml）

```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.czh</groupId>
    <artifactId>spring-boot-ai-deepseek</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>


    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.12.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.24</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>compile</scope>
            <optional>true</optional>
        </dependency>
    </dependencies>
</project>
```



### 启动类（Main.java）

```java
package cn.czh;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}
```



### 配置文件（application.yaml）

```yaml
spring:
  ai:
    deepseek:
      apiKey: sk-xxxxxxxxx # 你的api key  sk-a816a63552c54fa4ad887cc16c1bd8f6
      apiUrl: https://api.deepseek.com/chat/completions
      model: deepseek-chat # 选择模型（V3：deepseek-chat  R1：deepseek-reasoner）
      temperature: 0.7
      maxTokens: 1000
```



### 配置类（DeepSeekConfig.java）

```java
package cn.czh.config;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

@Data
@Configuration
@ConfigurationProperties(prefix = "spring.ai.deepseek")
public class DeepSeekConfig {
    private String apiKey;
    private String apiUrl;
    private String model;
    private Double temperature;
    private Integer maxTokens;
}

```



### 请求体（ChatRequest.java）

```java
package cn.czh.dto;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.List;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ChatRequest {
    private String model;
    private List<Message> messages;
    private Double temperature;
    private Integer max_tokens;

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public static class Message {
        private String role;
        private String content;
    }
}

```



### 响应体（ChatResponse.java）

```java
package cn.czh.dto;

import lombok.Data;

import java.util.List;

@Data
public class ChatResponse {

    private String id;

    private String object;

    private Integer created;

    private String model;

    private List<Choices> choices;

    private Usage usage;

    private String system_fingerprint;

    @Data
    public static class Choices {

        private Integer index;

        private Message message;

        private String logprobs;

        private String finish_reason;

        @Data
        public static class Message {
            private String role;
            private String content;
        }
    }

    @Data
    public static class Usage {
        private Integer prompt_tokens;

        private Integer completion_tokens;

        private Integer total_tokens;

        private Prompt_tokens_details prompt_tokens_details;

        private Integer prompt_cache_hit_tokens;

        private Integer prompt_cache_miss_tokens;

        @Data
        public static class Prompt_tokens_details {
            private Integer cached_tokens;
        }
    }
}
```





### 接口（IDeepSeekService.java）

```java
package cn.czh.service;

public interface IDeepSeekService {

    /**
     * 提问生成回复
     */
    String generateResponse(String query);

}
```



### 接口实现类（DeepSeekServiceImpl.java）

```java
package cn.czh.service.impl;

import cn.czh.config.DeepSeekConfig;
import cn.czh.dto.ChatRequest;
import cn.czh.dto.ChatResponse;
import cn.czh.service.IDeepSeekService;
import cn.hutool.http.HttpResponse;
import cn.hutool.http.HttpUtil;
import cn.hutool.http.Method;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.Optional;

@Slf4j
@Service
public class DeepSeekServiceImpl implements IDeepSeekService {

    @Resource
    private DeepSeekConfig deepSeekConfig;

    @Override
    public String generateResponse(String query) {
        try {
            // 构建 deepseek 请求对象
            ChatRequest request = buildRequest(query);

            // 执行 HTTP 请求
            HttpResponse execute = HttpUtil.createRequest(Method.POST, deepSeekConfig.getApiUrl())
                    .body(JSONUtil.toJsonStr(request))
                    .header("Content-Type", "application/json")
                    .header("Authorization", "Bearer " + deepSeekConfig.getApiKey())
                    .header("Accept", "application/json")
                    .execute();

            // 获取并日志记录响应内容
            String resp = execute.body();
            log.info("deepseek response: {}", resp);

            // 解析响应并提取内容
            ChatResponse chatResponse = JSONUtil.toBean(resp, ChatResponse.class);
            return extractResponse(chatResponse);
        } catch (Exception e) {
            log.error("Error generating response for query: {}", query, e);
            throw new RuntimeException("Failed to generate response", e);
        }
    }

    /**
     * 构建 deepseek 请求对象
     */
    private ChatRequest buildRequest(String query) {
        return ChatRequest.builder()
                .model(deepSeekConfig.getModel())
                .temperature(deepSeekConfig.getTemperature())
                .max_tokens(deepSeekConfig.getMaxTokens())
                .messages(Collections.singletonList(new ChatRequest.Message("user", query)))
                .build();
    }

    /**
     * 提取回复内容
     */
    private String extractResponse(ChatResponse response) {
        return Optional.ofNullable(response)
                .map(ChatResponse::getChoices)
                .filter(choices -> !choices.isEmpty())
                .map(choices -> choices.get(0))
                .map(choice -> choice.getMessage().getContent())
                .orElseThrow(() -> new RuntimeException("Empty response"));
    }

}
```



### 控制器（ChatController.java）

```java
package cn.czh.controller;

import cn.czh.service.IDeepSeekService;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;


@RestController
@RequestMapping("/deepseek")
public class ChatController {

    @Resource
    private IDeepSeekService deepSeekService;

    @PostMapping("/send")
    public String send(String query) {
        return deepSeekService.generateResponse(query);
    }

}
```



## 测试

使用postman访问`localhost:8080/deepseek/send`即可
![输入图片说明](https://foruda.gitee.com/images/1740220585732786198/b11b7bd1_10557865.png "image-20250222174714114.png")