LangChain4j从入门到精通-15-Spring Boot 集成

分享牛

639人浏览 · 2026-02-12 09:00:00

分享牛 · 2026-02-12 09:00:00 发布

本文是《LangChain4j从入门到精通》系列的第十五篇，全面解析了如何通过Spring Boot启动器实现与LangChain4j的无缝集成。文章详细介绍了两种核心集成模式：基础启动器通过依赖注入和属性配置快速接入大语言模型，声明式AI服务则通过@AiService注解实现零代码接口代理生成。针对生产环境需求，特别讲解了多组件显式装配、流式响应(Flux)、工具自动注册及可观测性监听等高级特性。通过实际代码示例展示了从基础对话到复杂工具调用的完整实现路径，帮助Java开发者快速构建企业级AI应用，显著提升开发效率和应用可维护性。

#Java #SpringBoot #LangChain4j #AI集成 #企业级开发

LangChain4j提供了 Spring Boot 启动器 :

一般集成方案
声明式 AI服务

Spring Boot启动器

Spring Boot starters 有助于创建和配置
language models,
embedding models,
embedding stores,
并通过属性配置其他核心LangChain4j组件

使用其中一个 Spring Boot starters,
导入相应的依赖项
Spring Boot 启动器依赖的命名规范是：langchain4j-{integration-name}-spring-boot-starter。
例如，对于OpenAI（langchain4j-open-ai），依赖项名称应为langchain4j-open-ai-spring-boot-starter：

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
    <version>1.10.0-beta18</version>
</dependency>

然后，你可以在 application.properties文件中按如下方式配置模型参数：

langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
langchain4j.open-ai.chat-model.model-name=gpt-4o
langchain4j.open-ai.chat-model.log-requests=true
langchain4j.open-ai.chat-model.log-responses=true
...

在这种情况下，将自动创建一个 OpenAiChatModel（ChatModel的一个实现）的实例，你可以在需要的地方自动装配它：

@RestController
public class ChatController {

    ChatModel chatModel;

    public ChatController(ChatModel chatModel) {
        this.chatModel = chatModel;
    }

    @GetMapping("/chat")
    public String model(@RequestParam(value = "message", defaultValue = "Hello") String message) {
        return chatModel.chat(message);
    }
}

如果需要使用 StreamingChatModel的实例，

请使用 streaming-chat-model属性而非 chat-model属性：

langchain4j.open-ai.streaming-chat-model.api-key=${OPENAI_API_KEY}
...

声明式AI服务的Spring Boot启动器

LangChain4j提供了一个Spring Boot启动器，用于自动配置 AI服务、RAG、工具等功能。假设您已经导入了一个集成启动器（如上所述），请导入langchain4j-spring-boot-starter模块。

<dependency>
    <groupId>dev.langchain4j</groupId>
    <artifactId>langchain4j-spring-boot-starter</artifactId>
    <version>1.10.0-beta18</version>
</dependency>

您现在可以定义AI服务接口并用@AiService注解它：

@AiService
interface Assistant {

    @SystemMessage("You are a polite assistant")
    String chat(String userMessage);
}

可以将其视为标准的Spring Boot @Service，但具备AI功能。当应用启动时，LangChain4j启动器会扫描类路径，
找到所有带有@AiService注解的接口。对于每个发现的AI服务，它将利用应用上下文中所有可用的LangChain4j组件，创建该接口的实现，并将其注册为一个bean，这样你就可以在需要的地方自动装配它：

@RestController
class AssistantController {

    @Autowired
    Assistant assistant;

    @GetMapping("/chat")
    public String chat(String message) {
        return assistant.chat(message);
    }
}

自动装载组件

如果在应用程序上下文中可用，以下组件将自动连接到AI服务：

ChatModel
StreamingChatModel
ChatMemory
ChatMemoryProvider
ContentRetriever
RetrievalAugmentor
ToolProvider
任何带有 @Tool注解的 @Component或 @Service类中的所有方法
一个例子：

@Component
public class BookingTools {

    private final BookingService bookingService;

    public BookingTools(BookingService bookingService) {
        this.bookingService = bookingService;
    }

    @Tool
    public Booking getBookingDetails(String bookingNumber, String customerName, String customerSurname) {
        return bookingService.getBookingDetails(bookingNumber, customerName, customerSurname);
    }

    @Tool
    public void cancelBooking(String bookingNumber, String customerName, String customerSurname) {
        bookingService.cancelBooking(bookingNumber, customerName, customerSurname);
    }
}

:::注意
如果应用程序上下文中存在多个相同类型的组件，应用程序将无法启动。在这种情况下，请使用显式装配模式（如下所述）。

:::

显式组件装配

如果你有多个AI服务，并希望将不同的LangChain4j组件接入到每个服务中，你可以通过显式装配模式（@AiService(wiringMode = EXPLICIT)）指定要使用的组件。假设我们配置了两个ChatModel：

# OpenAI
langchain4j.open-ai.chat-model.api-key=${OPENAI_API_KEY}
langchain4j.open-ai.chat-model.model-name=gpt-4o-mini

# Ollama
langchain4j.ollama.chat-model.base-url=http://localhost:11434
langchain4j.ollama.chat-model.model-name=llama3.1

@AiService(wiringMode = EXPLICIT, chatModel = "openAiChatModel")
interface OpenAiAssistant {

    @SystemMessage("You are a polite assistant")
    String chat(String userMessage);
}

@AiService(wiringMode = EXPLICIT, chatModel = "ollamaChatModel")
interface OllamaAssistant {

    @SystemMessage("You are a polite assistant")
    String chat(String userMessage);
}

:::注意
在这种情况下，你必须明确指定所有组件。
:::

更多详情请见这里.

监听AI服务注册事件

当你以声明式方式完成AI服务的开发后，可以通过实现ApplicationListener<AiServiceRegisteredEvent>接口来监听AiServiceRegisteredEvent事件。该事件会在AI服务注册到Spring上下文时触发，使你能在运行时获取所有已注册AI服务及其工具的信息。示例如下：

@Component
class AiServiceRegisteredEventListener implements ApplicationListener<AiServiceRegisteredEvent> {


    @Override
    public void onApplicationEvent(AiServiceRegisteredEvent event) {
        Class<?> aiServiceClass = event.aiServiceClass();
        List<ToolSpecification> toolSpecifications = event.toolSpecifications();
        for (int i = 0; i < toolSpecifications.size(); i++) {
            System.out.printf("[%s]: [Tool-%s]: %s%n", aiServiceClass.getSimpleName(), i + 1, toolSpecifications.get(i));
        }
    }
}

Flux

在流式传输时，您可以使用 Flux<String>作为 AI 服务的返回类型：

@AiService
interface Assistant {

    @SystemMessage("You are a polite assistant")
    Flux<String> chat(String userMessage);
}

为此，请导入 langchain4j-reactor模块。

可观测性

要为 ChatModel StreamingChatModel 启用可观测性，你需要声明一个或多个 ChatModelListener beans：

@Configuration
class MyConfiguration {
    
    @Bean
    ChatModelListener chatModelListener() {
        return new ChatModelListener() {

            private static final Logger log = LoggerFactory.getLogger(ChatModelListener.class);

            @Override
            public void onRequest(ChatModelRequestContext requestContext) {
                log.info("onRequest(): {}", requestContext.chatRequest());
            }

            @Override
            public void onResponse(ChatModelResponseContext responseContext) {
                log.info("onResponse(): {}", responseContext.chatResponse());
            }

            @Override
            public void onError(ChatModelErrorContext errorContext) {
                log.info("onError(): {}", errorContext.error().getMessage());
            }
        };
    }
}