LangChain4j入门（一）SpringBoot整合并接入Deepseek

BOB-wangbaohai

已于 2025-05-14 16:32:49 修改

阅读量911

点赞数 24

分类专栏： LangChain4j入门实践文章标签： LangChain4j deepseek Springboot3.x vue3

于 2025-05-14 08:25:23 首次发布

本文链接：https://blog.csdn.net/weixin_42254759/article/details/147928630

版权

LangChain4j入门实践专栏收录该内容

2 篇文章

订阅专栏

前言

我为什么选择 LangChain4j 框架入门AI实践？作为JAVA仔，我们肯定是希望快速上手，零语言障碍，使用熟悉的语言和框架无缝引入 LLM 能力，LangChain4j 与 Java 生态深度融合的特点正是我们需要的，另外它还有更多的优点。

附 LangChain4j 官网地址：Introduction | LangChain4j

一、LangChain4j 的主要优点

① 与 Java 生态深度融合

如图所见，我们可以看到 LangChain4j 官方为我们提供官方 Starter，我们只需要在配置文件中添加指定的open-api的配置，即可快速接入AI能力。

② 高度模块化与可扩展性

按需引入组件：采用模块化设计，开发者仅需引入自己需要的 chain、memory、agent、vector store 等模块，避免臃肿依赖。

内存管理：内置多种对话记忆（Memory）管理策略，支持短期/长期记忆持久化，方便构建多轮对话和上下文保持。

③ 企业级项目适配

支持微服务架构（Spring Cloud等）、消息驱动（Kafka、RabbitMQ）等主流企业技术栈，可快速将 AI 能力嵌入大型系统中。

二、LangChain4j 的核心作用

① 统一模型调用接口

定义了 LanguageModel、ChatLanguageModel、EmbeddingModel 等接口，将 OpenAI、Vertex AI、DeepSeek 等多家 LLM 提供商的调用细节封装在一致的 API 之下，使得切换或并行使用不同服务变得无缝简单。

② 链式工作流（Chains）

提供“链”（Chains）机制，可将模型调用、提示词处理、数据转换等步骤串联为可复用的流程，助力构建复杂的多步骤 AI 应用。

③ 检索增强生成（RAG）

内置向量化、分片、检索和嵌入管理功能，支持与 MongoDB Atlas Vector Search、ChromaDB、Pinecone、Weaviate 等向量数据库集成，实现基于语义匹配的上下文检索，再将检索结果与提示词一并发送给模型，显著提升生成质量。

④ 多种“工具”支持

集成文档加载器（PDF、HTML、Markdown）、函数调用、流式输出、回调（Callbacks）等能力，使得 AI 系统能够灵活调用外部 API、执行计算或进行自定义逻辑。

三、同类型框架比较

特性	LangChain4j	Spring AI
设计初衷	简化在 Java 应用中集成 LLM，提供统一 API 抽象，灵活切换 OpenAI、Vertex AI、DeepSeek 等多家模型服务。	基于 Spring 生态，提供与 Spring Beans、配置、生命周期无缝结合的 AI 抽象，支持 Chat、Embedding、Text-to-Image 等多种模型调用。
核心抽象	定义 `ChatLanguageModel`、`EmbeddingModel`、`Agent`、`Chain`、`Memory` 等接口，全方位覆盖提示词、链式调用、对话记忆等场景。	提供 `AI`、`Chat`、`TextToImage`、`Embedding` 等通用接口，模型切换与调用方式保持一致，并暴露底层特性如流式（streaming）与函数调用（function calling）。
多模型支持	原生支持 15+ 主流 LLM 提供商（OpenAI、Vertex AI、Anthropic、DeepSeek 等）及 15+ 向量存储（Pinecone、Chroma、Weaviate、Qdrant 等）。	支持 OpenAI、Anthropic Claude、Azure OpenAI、Google Vertex AI、Groq、Mistral、Ollama 等；向量数据库通过文档读取器/写入器插件集成。
链式调用（Chains）	完整实现 Chain 模式，可将提示词构建、模型调用、数据处理、工具执行串联，适用于复杂多步骤工作流。	通过 Spring Bean 和装配机制，将多模型调用与处理逻辑以配置方式组装，支持自定义 Step 及流程；目前尚未提供与 LangChain 同级别的 Chain 库。
检索增强生成（RAG）	内置文档分片、向量化、检索模块，可无缝对接常见向量库，构建高效 RAG 流水线。	提供 ETL 风格的文档加载器、转换器、写入器，可对接多种向量库存储与检索，但需手动组装 RAG 流程。
多轮对话记忆	支持短期/长期 Memory 管理，Memory 可持久化到数据库或内存中，实现对话上下文连续性。	提供简单的对话上下文维护能力，更多依赖用户自行管理 Bean 作用域或外部存储，自带 Memory 方案相对轻量。
Spring 集成	提供 Spring Boot Starter，一行配置自动装配 `OpenAiChatModel`、`EmbeddingStore` 等 Bean；也支持 Quarkus、Helidon。	与 Spring Boot 深度集成，AI 抽象即 Spring Bean，支持 `@AIClient`、自动配置、Properties/YAML 注入，以及 Micrometer 指标和 AOP 拦截。
可观测性 & 监控	依赖用户自行引入 Micrometer、OpenTelemetry 集成示例；Quarkus 扩展提供内建 Metrics/Tracing/Dev Services。	开箱即用 Micrometer 指标、Tracing 与 Auditing 支持，自动收集模型调用耗时、错误率等关键指标。
文档与社区	官方文档全面（入门、示例、扩展），GitHub 社区活跃，Discord、Issue 交流及时。	官方文档详尽（参考手册、Baeldung 教程、Medium 博文），Spring 社区庞大，Stack Overflow、Reddit 话题众多。

四、Spring工程整合LangChain4j

① 创建maven工程

此处没有什么特殊的，大家可以从零创建一个新项目，也可以在现有的微服务脚手架里创建一个新的模块，我这里是使用自己的微服务脚手架，框架是开源的，如果大家没有脚手架可以直接使用我的，文末我会把仓库链接贴出来，我的脚手架的SpringBoot版本是3.2.0。

唯一需要注意的是，我使用的 LangChain4j 版本是最新版本，根据官方文档我们必须使用JDK17，这是最低的要求。

（1）父工程

完整父工程POM如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://maven.apache.org/POM/4.0.0"
         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.ceair</groupId>
    <artifactId>eal-pm</artifactId>
    <version>1.0.0</version>
    <description>父工程，定义依赖</description>
    <modules>
        <module>pm-common</module>
        <module>pm-doc-common</module>
        <module>pm-authorization</module>
        <module>pm-gateway</module>
        <module>pm-system</module>
        <module>pm-log</module>
        <module>pm-base</module>
        <module>pm-process</module>
        <module>pm-langChain4j</module>
    </modules>

    <!--只定义版本-->
    <packaging>pom</packaging>

    <!--配置项-->
    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <springboot.version>3.2.0</springboot.version>
        <springcloud.version>2023.0.0</springcloud.version>
        <springcloudalibaba.version>2023.0.0.0-RC1</springcloudalibaba.version>
        <mysql.version>8.0.33</mysql.version>
        <mybatis-plus.version>3.5.9</mybatis-plus.version>
        <hutool.version>5.8.22</hutool.version>
        <lombok.version>1.18.24</lombok.version>
        <redis.version>3.1.5</redis.version>
        <mapstruct.version>1.5.5.Final</mapstruct.version>
        <springdoc.version>2.6.0</springdoc.version>
        <!-- SpringDoc-OpenApi版本号 -->
        <spring-doc.version>2.2.0</spring-doc.version>
        <flowable.version>7.1.0</flowable.version>
        <!-- langchain4j版本号 -->
        <langchain4j.version>1.0.0-beta4</langchain4j.version>
    </properties>

    <!--dependencyManagement不会传递-->
    <dependencyManagement>
        <dependencies>
            <!--springboot-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${springboot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--spring cloud-->
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${springcloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--spring cloud alibaba-->
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${springcloudalibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--引入langchain4j依赖管理清单-->
            <dependency>
                <groupId>dev.langchain4j</groupId>
                <artifactId>langchain4j-bom</artifactId>
                <version>${langchain4j.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

            <!--lombok-->
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>${lombok.version}</version>
            </dependency>

            <!--mysql-->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>

            <!--redis-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
                <version>${redis.version}</version>
            </dependency>

            <!--mybatis plus-->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-spring-boot3-starter</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-jsqlparser</artifactId>
                <version>${mybatis-plus.version}</version>
            </dependency>

            <!--hutool-->
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>

            <!--mapstruct-->
            <dependency>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct</artifactId>
                <version>${mapstruct.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-processor</artifactId>
                <version>${mapstruct.version}</version>
            </dependency>

            <!-- 适用于webmvc的SpringDoc依赖 -->
            <dependency>
                <groupId>org.springdoc</groupId>
                <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
                <version>${spring-doc.version}</version>
            </dependency>

            <!-- 适用于webflux的SpringDoc依赖 -->
            <dependency>
                <groupId>org.springdoc</groupId>
                <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
                <version>${spring-doc.version}</version>
            </dependency>

            <!-- flowable -->
            <dependency>
                <groupId>org.flowable</groupId>
                <artifactId>flowable-spring-boot-starter</artifactId>
                <version>${flowable.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <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>

（2）子模块

<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>
    <parent>
        <groupId>com.ceair</groupId>
        <artifactId>eal-pm</artifactId>
        <version>1.0.0</version>
    </parent>

    <artifactId>pm-langChain4j</artifactId>
    <packaging>pom</packaging>

    <name>pm-langChain4j</name>
    <modules>
        <module>langChain4j-api</module>
        <module>langChain4j-server</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

    </dependencies>
</project>

（3）子模块的API模块

这里只是初始化一下，以备后续给其他服务提供Fegin接口的能力。

<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>
    <parent>
        <groupId>com.ceair</groupId>
        <artifactId>pm-langChain4j</artifactId>
        <version>1.0.0</version>
    </parent>

    <artifactId>langChain4j-api</artifactId>
    <packaging>jar</packaging>

    <name>langChain4j-api</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

    </dependencies>

</project>

（4）子模块的Server模块

提供正式的服务模块，这里需要集成 LangChain4j 的 Starter。

补充说明：pm-common/pm-doc-common基础依赖，是本脚手架的基础模块，提供了mysql；mongodb；Spring Authorization Server资源服务；SpringBoot/cloud/cloudalibaba集成管理；kafka；mybatis-plus；SpringDoc-openAPI接口文档等基础服务和配置。

<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>
    <parent>
        <groupId>com.ceair</groupId>
        <artifactId>pm-langChain4j</artifactId>
        <version>1.0.0</version>
    </parent>

    <artifactId>langChain4j-server</artifactId>
    <packaging>jar</packaging>

    <name>langChain4j-server</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--pm-common-->
        <dependency>
            <groupId>com.ceair</groupId>
            <artifactId>pm-common</artifactId>
            <version>${project.version}</version>
        </dependency>

        <!--pm-doc-common-->
        <dependency>
            <groupId>com.ceair</groupId>
            <artifactId>pm-doc-common</artifactId>
            <version>${project.version}</version>
        </dependency>

        <!-- langchain4j -->
        <dependency>
            <groupId>dev.langchain4j</groupId>
            <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

② 创建配置文件

由于本服务集成了基础工程和 LangChain4j，所以需要配置的东西比较多，大家可以根据我配置文件中的注释替换成自己可用的中间件环境。

server:
  # 设置资源服务器端口
  port: 9004
spring:
  profiles:
    active: dev
  application:
    name: pm-langchain4j

# 本地开发配置
---
spring:
  config:
    activate:
      on-profile: dev
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 这里需要配置你自己的数据库连接信息
    url: jdbc:mysql://192.168.30.129:3306/pm-langChain4j?serverTimezone=UTC&userUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456
  data:
    redis:
      # 这里需要配置你自己的缓存连接信息
      host: 192.168.30.129
      port: 6379
      password: 123456
    mongodb:
      # 这里需要配置你自己的数据库连接信息
      uri: mongodb://root:123456@192.168.30.129:27017/pm-langChain4j?authSource=admin
  security:
    oauth2:
      # 资源服务器配置
      resourceserver:
        jwt:
          # Jwt中claims的iss属性，也就是jwt的签发地址，即认证服务器的根路径
          # 资源服务器会进一步的配置，通过该地址获取公钥以解析jwt
          issuer-uri: http://127.0.0.1:8080
  cloud:
    nacos:
      # 这里需要配置你自己的nacos连接信息
      serverAddr: 192.168.30.129:8848
      username: nacos
      password: nacos
      discovery:
        namespace: af54b638-b927-4d97-bfc5-e9f127dd92df
  kafka:
    # 这里需要配置你自己的mq连接信息
    bootstrap-servers: 192.168.30.129:9092
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

# Mybatis-Plus 配置
mybatis-plus:
  # 扫描mapper文件
  mapper-locations:
    - classpath:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

#kafka消息相关
syslog:
  kafka:
    topic: sys-log-topic

# ------------以下内容可改为公共配置------------
# SpringDoc自定义配置
custom:
  info:
    title: ${spring.application.name}-api
    version: 1.0.0
    description: 这是一个使用SpringDoc生成的在线文档.
    terms-of-service: http://127.0.0.1:5173
    gateway-url: http://127.0.0.1:9999/${spring.application.name}
  license:
    name: Apache 2.0
  security:
    name: Authenticate
    token-url: http://127.0.0.1:8080/oauth2/token
    authorization-url: http://127.0.0.1:8080/oauth2/authorize

#flowable配置
flowable:
  # 异步执行器主要用于处理那些耗时的任务，例如发送电子邮件、生成报告、调用外部服务等。这些任务可以在后台线程池中异步执行，而不会阻塞主线程或影响用户的响应时间
  async-executor-activate: false
  # 是否开启数据库自动升级
  database-schema-update: true

#open-ai相关配置
langchain4j:
  open-ai:
    chat-model:
      # 这里需要你自己的 api-key
      api-key: **************************
      model-name: deepseek-chat
      log-requests: true
      log-responses: true
      base-url: https://api.deepseek.com

#日志级别
logging:
  level:
    root: debug

③ 申请deepseek的 api-key

申请地址：DeepSeek 开放平台

创建完api-key之后，需要先充值1块钱才能使用，不过也有说可以免费试用的，我是没有找到入口，有大佬知道的话麻烦在评论区分享一下。

④ 创建主启动类

package com.ceair;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

/**
 * @author wangbaohai
 * @ClassName LangChain4jResourceApplication
 * @description: LangChain4j主启动类
 * @date 2025年05月13日
 * @version: 1.0.0
 */
@SpringBootApplication
@EnableDiscoveryClient()
public class LangChain4jResourceApplication {

    public static void main(String[] args) {
        SpringApplication.run(LangChain4jResourceApplication.class, args);
    }

}

⑤ 创建测试接口

package com.ceair.controller;

import com.ceair.entity.result.Result;
import dev.langchain4j.model.openai.OpenAiChatModel;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wangbaohai
 * @ClassName TestController
 * @description: 测试接口
 * @date 2025年05月13日
 * @version: 1.0.0
 */
@RestController
@RequestMapping("/api/v1/test")
@RequiredArgsConstructor
@Slf4j
@Tag(name = "测试接口", description = "测试LangChain4j功能相关接口")
public class TestController {

    private final OpenAiChatModel openAiChatModel;

    /**
     * 测试LangChain4j的deepseek功能
     * 向OpenAI模型发送预设问题并获取回答
     *
     * @return Result<String> 包含成功状态和模型回答结果的封装对象
     * 当调用成功时返回模型回答文本，失败时返回错误信息
     */
    @Operation(summary = "测试LangChain4j功能-deepseek")
    @PostMapping("/deepseek")
    public Result<String> deepseek() {
        // 向 模型 提问
        String answer = openAiChatModel.chat("请回答我你有什么用");
        return Result.success(answer);
    }

}