在Java项目中集成Deepseek大语言模型实践指南

发布于：2025-05-21 ⋅ 阅读:(17) ⋅ 点赞:(0)

1. 引言

        随着人工智能技术的发展，大语言模型在各领域应用日益广泛。本文将详细介绍如何在Java项目中集成Deepseek大模型，实现智能文本生成、对话等功能。

2. 前期准备

  1. 准备Java Spring Boot项目环境
  2. 确保Maven已配置
  3. 注册Deepseek账号并获取API密钥

 获取api key

这里我简单演示一下怎么申请获取key 

点击    deepseek API开放平台

申请创建好key后，请注意保存并保密好你的key

然后再需要充点米按照我下面的步骤就能调用了

3. 添加必要依赖

下面以我的一个项目为例，在pom.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>com.kmbeast</groupId>
    <artifactId>personal-health-api</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>personal-health-api</name>
    
    <!--springboot父依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>
    
    <!--编译配置与版本管理-->
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        
        <!-- 依赖版本管理 -->
        <commons-lang3.version>3.12.0</commons-lang3.version>
        <mybatis-spring-boot-starter.version>2.1.2</mybatis-spring-boot-starter.version>
        <mybatis-plus.version>3.5.3.1</mybatis-plus.version>
        <druid-spring-boot-starter.version>1.2.8</druid-spring-boot-starter.version>
        <easyexcel.version>3.2.1</easyexcel.version>
        <poi.version>4.1.2</poi.version>
        <java-jwt.version>3.4.0</java-jwt.version>
        <jjwt.version>0.9.0</jjwt.version>
        <itext-asian.version>5.2.0</itext-asian.version>
        <fastjson2.version>2.0.33</fastjson2.version>
        <weka.version>3.8.5</weka.version>
        <commons-math3.version>3.6.1</commons-math3.version>
        <drools.version>7.59.0.Final</drools.version>
        <opennlp.version>1.9.3</opennlp.version>
        <jfreechart.version>1.5.3</jfreechart.version>
        <ehcache.version>2.10.6</ehcache.version>
        <knife4j.version>4.4.0</knife4j.version>
    </properties>
    
    <!--依赖-->
    <dependencies>
        <!--工具类依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>${commons-lang3.version}</version>
        </dependency>
        
        <!--SpringBoot 启动包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <!--SpringBoot Web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!--SpringBoot Aop-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        
        <!--Lombok 简化实体类开发-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        
        <!--数据库链接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid-spring-boot-starter.version}</version>
        </dependency>
        
        <!-- mybatis依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>${mybatis-spring-boot-starter.version}</version>
        </dependency>
        
        <!--MybatisPlus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <!--excel处理-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>easyexcel</artifactId>
            <version>${easyexcel.version}</version>
        </dependency>
        
        <!--excel处理-->
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>${poi.version}</version>
        </dependency>
        
        <!-- JWT相关 -->
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>${java-jwt.version}</version>
        </dependency>
        
        <!-- JWT相关 -->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>${jjwt.version}</version>
        </dependency>
        
        <!-- JWT相关 -->
        <dependency>
            <groupId>com.itextpdf</groupId>
            <artifactId>itext-asian</artifactId>
            <version>${itext-asian.version}</version>
        </dependency>
        
        <!-- JSON解析 -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>${fastjson2.version}</version>
        </dependency>
        
        <!-- WebSocket依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        
        <!-- 机器学习库 -->
        <dependency>
            <groupId>nz.ac.waikato.cms.weka</groupId>
            <artifactId>weka-stable</artifactId>
            <version>${weka.version}</version>
        </dependency>
        
        <!-- 数学计算库 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-math3</artifactId>
            <version>${commons-math3.version}</version>
        </dependency>
        
        <!-- 规则引擎 -->
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-core</artifactId>
            <version>${drools.version}</version>
        </dependency>
        
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>${drools.version}</version>
        </dependency>
        
        <!-- OpenNLP -->
        <dependency>
            <groupId>org.apache.opennlp</groupId>
            <artifactId>opennlp-tools</artifactId>
            <version>${opennlp.version}</version>
        </dependency>
        
        <!-- 图表生成 -->
        <dependency>
            <groupId>org.jfree</groupId>
            <artifactId>jfreechart</artifactId>
            <version>${jfreechart.version}</version>
        </dependency>
        
        <!-- 开启缓存支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        
        <!-- 添加 Ehcache 支持 -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>${ehcache.version}</version>
        </dependency>
        
        <!-- Knife4j API文档 -->
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>knife4j-openapi2-spring-boot-starter</artifactId>
            <version>${knife4j.version}</version>
        </dependency>
    </dependencies>

    <build>
        <defaultGoal>compile</defaultGoal>
        <!--定义资源路径-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>*/*.*</include>
                    <include>*.*</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

        上面是我一个项目的全部依赖，，因为我调用deepseekapi后，还用了保存日志持久化的操作，必须要有以下依赖。

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Lombok简化代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
    
    <!-- MyBatis数据库操作 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>
    <!--MybatisPlus依赖-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>${mybatis-plus.version}</version>
    </dependency>
</dependencies>

4. 配置Deepseek参数

在application.yml中添加Deepseek配置：

# 大模型配置
llm:
  provider: deepseek
  connect-timeout: 30000  # 连接超时时间(ms)
  read-timeout: 90000     # 读取超时时间(ms)

# Deepseek配置  
deepseek:
  api-key: your-api-key-here
  model: deepseek-chat
  api-url: https://api.deepseek.com/v1/chat/completions
  max-retries: 2  # 请求失败后最大重试次数

以我的项目作为示例：

# 服务配置
server:
  port: 9999
  servlet:
    context-path: /api/personal-heath/v1.0
# API地址前缀，用于接口拦截放行
my-server:
  api-context-path: /api/personal-heath/v1.0
#MySQL与文件上传限制配置
spring:
  servlet:
    multipart:
      max-file-size: 10MB
      max-request-size: 10MB
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/personal_health?characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true
    username: root
    password: 123456
  # SpringBoot 2.6+解决与Swagger兼容性问题
  mvc:
    pathmatch:
      matching-strategy: ANT_PATH_MATCHER
# 让 Mybatis 在 Mapper目录下找到 XML 映射文件
mybatis:
  mapper-locations: classpath:mapper/*.xml

# 大模型配置
llm:
  # 使用deepseek，可选值：openai/deepseek
  provider: deepseek
  connect-timeout: 30000  # 连接超时时间(ms)
  read-timeout: 90000     # 读取超时时间(ms)，对于大模型需要更长时间

# Deepseek配置  
deepseek:
  api-key:   #注意这里配置你的真实的key
  model: deepseek-chat
  api-url: https://api.deepseek.com/v1/chat/completions
  max-retries: 2  # 请求失败后最大重试次数

# 健康分析服务配置
health:
  analysis:
    provider: llm

# Knife4j配置
knife4j:
  enable: true
  basic:
    enable: false
  setting:
    language: zh-CN
    enableSwaggerModels: true
    enableDocumentManage: true
    swaggerModelName: 实体类列表
    enableOpenApi: false

这里不方便展示我的真实的key

5. 创建数据传输对象

这里的传输对象不固定，可根据需求修改

LLMRequest.java

@Data
@Builder
public class LLMRequest {
    private String userPrompt;
    private String systemPrompt;
    private String modelName;
    private Float temperature;
    private Integer maxTokens;
}

LLMResponse.java

@Data
@Builder
public class LLMResponse {
    private String content;
    private Integer usedTokens;
    private String requestId;
    private boolean success;
    private String errorMessage;
}

6. 实现大模型服务接口

public interface ILLMService {
    LLMResponse generateResponse(LLMRequest request);
    LLMResponse generateChatResponse(LLMRequest request);
    List<LLMResponse> batchProcess(List<LLMRequest> requests);
}

7. RestTemplate配置

@Configuration
public class RestTemplateConfig {
    
    @Value("${llm.connect-timeout:30000}")
    private int connectTimeout;
    
    @Value("${llm.read-timeout:90000}")
    private int readTimeout;
    
    @Bean("llmRestTemplate")
    public RestTemplate llmRestTemplate() {
        HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(connectTimeout);
        factory.setReadTimeout(readTimeout);
        
        return new RestTemplate(factory);
    }
}

8. 实现Deepseek服务

@Slf4j
@Service("deepseekService")
@ConditionalOnProperty(name = "llm.provider", havingValue = "deepseek")
public class DeepseekServiceImpl implements ILLMService {
    
    @Value("${deepseek.api-key}")
    private String apiKey;
    
    @Value("${deepseek.model:deepseek-chat}")
    private String model;
    
    @Value("${deepseek.api-url}")
    private String apiUrl;
    
    @Value("${deepseek.max-retries:2}")
    private int maxRetries;
    
    @Autowired
    @Qualifier("llmRestTemplate")
    private RestTemplate restTemplate;
    
    @Autowired
    private AIModelLogMapper aiModelLogMapper;
    
    @Override
    public LLMResponse generateResponse(LLMRequest request) {
        long startTime = System.currentTimeMillis();
        AIModelLog logRecord = createLogRecord("Deepseek", apiUrl);
        
        // 重试机制
        int retryCount = 0;
        Exception lastException = null;
        
        while (retryCount <= maxRetries) {
            try {
                // 构建请求体
                Map<String, Object> requestBody = new HashMap<>();
                requestBody.put("model", StringUtils.hasText(request.getModelName()) ? 
                        request.getModelName() : model);
                
                List<Map<String, String>> messages = new ArrayList<>();
                
                // 添加系统提示词
                if (StringUtils.hasText(request.getSystemPrompt())) {
                    Map<String, String> systemMessage = new HashMap<>();
                    systemMessage.put("role", "system");
                    systemMessage.put("content", request.getSystemPrompt());
                    messages.add(systemMessage);
                }
                
                // 添加用户提示词
                Map<String, String> userMessage = new HashMap<>();
                userMessage.put("role", "user");
                userMessage.put("content", request.getUserPrompt());
                messages.add(userMessage);
                
                requestBody.put("messages", messages);
                
                // 设置温度参数
                if (request.getTemperature() != null) {
                    requestBody.put("temperature", request.getTemperature());
                }
                
                // 设置最大令牌数
                if (request.getMaxTokens() != null) {
                    requestBody.put("max_tokens", request.getMaxTokens());
                }
                
                // 设置请求头
                HttpHeaders headers = new HttpHeaders();
                headers.setContentType(MediaType.APPLICATION_JSON);
                headers.set("Authorization", "Bearer " + apiKey);
                
                // 发送请求
                HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
                ResponseEntity<Map> response = restTemplate.exchange(
                    apiUrl, HttpMethod.POST, entity, Map.class);
                
                // 解析响应
                Map responseBody = response.getBody();
                if (responseBody != null && responseBody.containsKey("choices")) {
                    List<Map> choices = (List<Map>) responseBody.get("choices");
                    if (!choices.isEmpty()) {
                        Map choice = choices.get(0);
                        Map message = (Map) choice.get("message");
                        String content = (String) message.get("content");
                        
                        // 记录成功日志
                        logRecord.setStatus((byte) 1);
                        logRecord.setResponseTime((int)(System.currentTimeMillis() - startTime));
                        saveLog(logRecord);
                        
                        return LLMResponse.builder()
                                .content(content)
                                .usedTokens(responseBody.containsKey("usage") ? 
                                        (Integer)((Map)responseBody.get("usage")).get("total_tokens") : null)
                                .requestId(responseBody.containsKey("id") ? (String)responseBody.get("id") : null)
                                .success(true)
                                .build();
                    }
                }
                
                // 失败处理...
                
            } catch (ResourceAccessException e) {
                // 网络错误重试逻辑...
                retryCount++;
            }
        }
        
        // 所有重试失败后返回错误响应
        return LLMResponse.builder()
                .success(false)
                .errorMessage("Deepseek API调用失败")
                .build();
    }
    
    // 其他方法实现...
}

9. 使用示例

@RestController
@RequestMapping("/api/llm")
public class LLMController {

    @Autowired
    @Qualifier("deepseekService")
    private ILLMService llmService;
    
    @PostMapping("/generate")
    public ResponseEntity<LLMResponse> generateResponse(@RequestBody LLMRequest request) {
        LLMResponse response = llmService.generateResponse(request);
        return ResponseEntity.ok(response);
    }
}

用swagger测试后你就会看到

10.注意事项

API密钥安全：永远不要在代码中硬编码API密钥，使用配置文件或环境变量

错误处理：实现合理的重试机制和错误处理策略

性能优化：对大模型响应进行缓存，避免重复请求

成本控制：监控Token使用量，设置合理的最大Token限制

超时设置：大模型请求可能需要较长时间，合理设置超时参数

 11. 总结

        通过以上步骤，我们成功在Java项目中集成了Deepseek大模型，实现了智能文本生成功能。该方案具有良好的可扩展性，可以根据业务需求进一步优化和扩展。

        采用这种方式集成大模型，不仅能够为应用提供强大的AI能力，还能保持代码的解耦和灵活性，为未来集成更多AI模型奠定基础。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布