Spring AI 实战：SpringBoot 整合 LangChain4j

在 AI 大模型普及的当下，Java 开发者想要快速将大模型能力集成到业务系统中，SpringBoot 的轻量高效与 LangChain4j 的大模型适配能力结合，成为最优解之一。LangChain4j 作为 Java 生态的大模型集成框架，复刻了 Python 版 LangChain 的核心设计，让 Java 开发者无需跨语言即可实现大模型的对话、工具调用、检索增强生成等核心能力。本文将从 LangChain4j 核心特性出发，一步步讲解 SpringBoot 与 LangChain4j 的整合流程，涵盖基础对话、会话记忆、Function Calling、RAG 等核心功能，并通过智能客服实战案例，让开发者快速落地大模型应用开发。

一、LangChain4j 核心认知

1. 框架定位

LangChain4j 是一款专为 Java 开发者设计的轻量级大模型集成框架，核心目标是简化 LLM（大型语言模型）在 Java 应用中的落地，无需复杂的底层调用，通过封装好的 API 即可快速对接 OpenAI、Hugging Face 等主流大模型，轻松构建聊天机器人、问答系统、文本生成等 AI 应用。

2. 核心特性

LangChain4j 之所以能成为 Java 生态大模型开发的首选，核心在于其贴合 Java 开发习惯的设计特性：

模块化架构：模型集成、数据加载、链式调用等功能解耦，可按需选择，避免冗余依赖；

多模型兼容：原生支持 OpenAI、Hugging Face 等主流 LLM 提供商，模型切换无需大幅修改代码；

链式调用能力：支持将文本生成、情感分析、信息检索等多个任务串联，实现复杂业务逻辑；

丰富的内置组件：提供开箱即用的数据加载器、文本处理器，支持从多源加载并预处理数据；

高扩展性：预留丰富的扩展点，可自定义模型、工具、链组件，适配个性化业务需求；

安全管控：内置 API Key 管理机制，避免密钥硬编码，保障数据和接口安全。

3. 核心组件

LangChain4j 的核心能力围绕三大组件展开，是所有功能实现的基础：

语言模型（Language Model）：核心组件，负责接收指令并生成文本，对接各类大模型的底层接口；

记忆（Memory）：存储对话历史，让大模型具备上下文理解能力，实现多轮连贯对话；

工具（Tool）：扩展大模型能力边界，支持调用外部 API、执行搜索、运行系统命令等，解决大模型 “知识滞后”“无法实操” 的问题。

4. 典型应用场景

基于核心组件和特性，LangChain4j 可覆盖绝大多数 Java 端 AI 应用开发场景：

智能客服 / 虚拟助手：实现多轮上下文对话，解答用户业务问题；

知识库问答系统：结合企业文档，提供精准的结构化答案；

自动文本生成：生成文章、代码、报告、营销文案等；

智能工具调度：让大模型根据需求自动调用天气、搜索、物流等外部 API。

二、SpringBoot 整合 LangChain4j 前置准备

在进行功能开发前，需完成基础环境配置，包括 API Key 获取、依赖导入和配置文件编写，本教程以对接 OpenAI 模型为例，其他模型配置逻辑基本一致。

1. 获取 API Key

前往 OpenAI 官网注册并登录账号，进入 API Key 管理页面；

生成并复制 API Key，切勿直接硬编码到代码中；

可将 API Key 存储到环境变量，或 SpringBoot 配置文件中，保证密钥安全。

2. 导入 Maven 依赖

在 SpringBoot 项目的pom.xml中添加核心依赖，包括 SpringBoot Web 启动器、LangChain4j 核心包和 OpenAI 适配包，建议使用最新版本：

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<groupId>dev.langchain4j</groupId>

<artifactId>langchain4j-core</artifactId>

</dependency>

<groupId>dev.langchain4j</groupId>

<artifactId>langchain4j-open-ai</artifactId>

</dependency>

</dependencies>

3. 配置模型参数

在 SpringBoot 的application.yml（或application.properties）中配置 OpenAI 模型的核心参数，核心是配置 API Key，也可自定义模型类型、请求超时时间等：

langchain4j:

openai:

api-key: 你的OpenAI API Key

# 可选配置，指定模型，默认gpt-3.5-turbo

model-name: gpt-3.5-turbo

# 可选配置，请求超时时间

timeout: 30s

三、核心功能实现

SpringBoot 整合 LangChain4j 后，可实现从基础对话到高级定制的全链路能力，以下按基础到高级的顺序讲解核心功能的代码实现，所有代码均以 SpringBoot 的@Service注解实现，可直接注入到控制器中使用。

1. 基础对话能力

基础对话是大模型应用的核心，LangChain4j 提供Low Level API和High Level API两种调用方式，分别适配简单场景和复杂场景。

1.1 Low Level API（轻量调用）

适用于简单的单轮对话场景，直接创建模型实例并调用生成方法，代码简洁：

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.stereotype.Service;

@Service

public class ChatService {

// 注入OpenAI聊天模型

private final ChatLanguageModel chatModel;

// 构造方法初始化模型

public ChatService() {

this.chatModel = new OpenAiChatModel();

}

// 单轮对话方法

public String singleChat(String userMessage) {

// 直接调用模型生成响应

return chatModel.generate(userMessage);

}

1.2 High Level API（链式调用）

适用于需要扩展的对话场景，基于ConversationalRetrievalChain构建对话链，可后续灵活添加记忆、检索等能力：

import dev.langchain4j.chain.ConversationalRetrievalChain;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.stereotype.Service;

@Service

public class ChainChatService {

private final ChatLanguageModel model;

public ChainChatService() {

model = new OpenAiChatModel();

}

// 链式对话方法

public String chainChat(String userMessage) {

// 构建对话链

ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()

.chatLanguageModel(model)

.build();

// 执行链并返回结果

return chain.execute(userMessage);

}

1.3 自定义角色对话

通过PromptTemplate模板为大模型设置角色，让响应更贴合业务场景（如专业客服、技术顾问、文案编辑）：

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.template.PromptTemplate;

import dev.langchain4j.data.segment.Parameters;

import org.springframework.stereotype.Service;

@Service

public class RoleChatService {

// 定义角色提示模板

private final PromptTemplate promptTemplate = PromptTemplate.from(

"你是一名专业的{{role}}，请基于专业知识简洁、准确地回答问题：{{question}}"

);

private final ChatLanguageModel chatModel;

public RoleChatService() {

this.chatModel = new OpenAiChatModel();

}

// 自定义角色对话

public String roleChat(String role, String question) {

// 渲染模板，填充角色和问题参数

String prompt = promptTemplate.apply(Parameters.from("role", role, "question", question));

return chatModel.generate(prompt);

}

2. 会话记忆能力

基础对话默认无上下文记忆，通过 LangChain4j 的Memory组件可实现多轮连贯对话，让大模型记住历史对话内容，核心使用MessageWindowChatMemory实现对话记忆窗口（限制最大记忆消息数）。

2.1 Low Level API 实现记忆

手动管理记忆组件，添加用户消息和 AI 响应到记忆中：

import dev.langchain4j.memory.chat.MessageWindowChatMemory;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.model.chat.UserMessage;

import dev.langchain4j.model.chat.AiMessage;

import org.springframework.stereotype.Service;

@Service

public class MemoryChatService {

private final ChatLanguageModel chatModel;

// 初始化记忆窗口，最大保存50条消息

private final MessageWindowChatMemory memory;

public MemoryChatService() {

this.chatModel = new OpenAiChatModel();

this.memory = MessageWindowChatMemory.builder()

.maxMessages(50)

.build();

}

// 带记忆的多轮对话

public String memoryChat(String userMessage) {

// 将用户消息加入记忆

memory.add(UserMessage.from(userMessage));

// 基于记忆中的所有消息生成响应

String response = chatModel.generate(memory.messages());

// 将AI响应加入记忆

memory.add(AiMessage.from(response));

return response;

}

2.2 High Level API 实现记忆

通过对话链自动管理记忆，无需手动添加消息，开发更高效：

import dev.langchain4j.chain.ConversationalRetrievalChain;

import dev.langchain4j.memory.chat.MessageWindowChatMemory;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.stereotype.Service;

@Service

public class ChainMemoryChatService {

private final ChatLanguageModel model;

private final MessageWindowChatMemory memory;

public ChainMemoryChatService() {

model = new OpenAiChatModel();

memory = MessageWindowChatMemory.builder()

.maxMessages(50)

.build();

}

// 链式多轮对话（自动管理记忆）

public String chainMemoryChat(String userMessage) {

ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()

.chatLanguageModel(model)

.chatMemory(memory) // 为对话链绑定记忆

.build();

return chain.execute(userMessage);

}

3. Function Calling（函数调用）

Function Calling 是大模型的高级能力，让大模型能根据用户需求自动调用外部函数，解决大模型 “知识不实时”“无法执行具体操作” 的问题，例如调用天气 API、搜索接口获取实时信息。

核心实现：通过@Tool注解标记外部函数，通过Agent代理让大模型自动识别并调用工具。

import dev.langchain4j.agent.Agent;

import dev.langchain4j.agent.tool.Tool;

import dev.langchain4j.agent.tool.ToolRegistry;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.stereotype.Service;

@Service

public class FunctionCallingService {

private final ChatLanguageModel model;

// 工具注册器，管理所有可调用工具

private final ToolRegistry toolRegistry;

public FunctionCallingService() {

model = new OpenAiChatModel();

toolRegistry = new ToolRegistry();

}

// 函数调用入口

public String callFunction(String userMessage) {

// 构建代理，绑定模型和工具注册器

Agent agent = Agent.builder()

.chatLanguageModel(model)

.toolRegistry(toolRegistry)

.build();

return agent.execute(userMessage);

}

// 定义搜索工具，@Tool注解标记，描述需清晰，方便大模型识别

@Tool(name = "search", description = "当需要获取实时信息、未知知识时调用，入参为搜索关键词")

public String search(String query) {

// 此处可对接百度、必应等搜索API，实现真实搜索

return "【实时搜索结果】：" + query + " - 相关信息为XXX（对接真实API后替换）";

}

// 定义天气工具

@Tool(name = "weather", description = "当需要查询各地天气信息时调用，入参为城市名称")

public String getWeather(String location) {

// 此处可对接高德、百度天气API

return "【" + location + "天气信息】：25℃，晴，微风（对接真实API后替换）";

}

4. RAG（检索增强生成）

RAG 是解决大模型知识滞后和幻觉问题的核心技术，通过检索外部知识库的相关信息，让大模型基于检索结果生成答案，保证答案的准确性和实时性，是企业级问答系统的核心实现方案。

核心流程：加载知识库文档→切分文本片段→存储到向量库→用户提问时检索相关片段→大模型基于片段生成答案。

import dev.langchain4j.chain.RetrievalAugmentedGenerationChain;

import dev.langchain4j.data.document.Document;

import dev.langchain4j.data.document.DocumentLoader;

import dev.langchain4j.data.document.FileDocumentLoader;

import dev.langchain4j.data.segment.TextSegment;

import dev.langchain4j.data.segment.TextSegmenter;

import dev.langchain4j.data.segment.TextSegmenterFactory;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.retrieval.Retriever;

import dev.langchain4j.retrieval.vectorstore.VectorStoreRetriever;

import dev.langchain4j.vectorstore.VectorStore;

import dev.langchain4j.vectorstore.VectorStoreFactory;

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class RagService {

private final ChatLanguageModel model;

private final Retriever retriever;

// 初始化时创建向量库和检索器

public RagService() {

model = new OpenAiChatModel();

VectorStore vectorStore = VectorStoreFactory.create(); // 内置向量库，生产可替换为Pinecone等

retriever = new VectorStoreRetriever(vectorStore);

}

// RAG核心方法，基于知识库生成答案

public String ragAnswer(String userMessage) {

RetrievalAugmentedGenerationChain ragChain = RetrievalAugmentedGenerationChain.builder()

.chatLanguageModel(model)

.retriever(retriever) // 绑定检索器

.build();

return ragChain.execute(userMessage);

}

// 加载知识库文档到向量库

public void loadKnowledgeBase(String docPath) {

// 加载本地文档（支持txt、md、pdf等格式）

DocumentLoader documentLoader = new FileDocumentLoader(docPath);

List<Document> documents = documentLoader.load();

// 切分文本为小片段（适配大模型上下文窗口）

TextSegmenter segmenter = TextSegmenterFactory.create();

List<TextSegment> segments = segmenter.segment(documents);

// 将文本片段加入检索器（自动向量化存储）

retriever.add(segments);

}

5. 自定义扩展能力

LangChain4j 的高扩展性体现在自定义模型、自定义工具、自定义链三个方面，可完全适配企业个性化业务需求，以下讲解核心自定义实现。

5.1 自定义模型

当需要对接自研大模型或本地模型（如本地部署的 Transformer）时，可实现ChatLanguageModel接口自定义模型：

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.chat.ChatMessage;

import dev.langchain4j.model.chat.ChatResponse;

import dev.langchain4j.model.chat.AiMessage;

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class CustomModelService {

// 自定义模型实例

private final ChatLanguageModel customModel;

public CustomModelService() {

this.customModel = new LocalChatModel();

}

// 自定义模型生成方法

public String customGenerate(String prompt) {

return customModel.generate(prompt);

}

// 实现ChatLanguageModel接口，自定义本地模型

static class LocalChatModel implements ChatLanguageModel {

@Override

public ChatResponse generate(List<ChatMessage> messages) {

// 此处实现自研/本地模型的调用逻辑

String customResponse = "本地模型响应：" + messages.get(messages.size()-1).text();

// 构造并返回响应

return ChatResponse.builder()

.message(AiMessage.from(customResponse))

.build();

}

5.2 自定义工具

除了内置工具，可通过@Tool注解实现自定义业务工具，例如调用企业内部的订单查询、物流跟踪接口：

import dev.langchain4j.agent.Agent;

import dev.langchain4j.agent.tool.Tool;

import dev.langchain4j.agent.tool.ToolRegistry;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.stereotype.Service;

@Service

public class CustomToolService {

private final ChatLanguageModel model;

private final ToolRegistry toolRegistry;

public CustomToolService() {

model = new OpenAiChatModel();

toolRegistry = new ToolRegistry();

}

public String callCustomTool(String userMessage) {

Agent agent = Agent.builder()

.chatLanguageModel(model)

.toolRegistry(toolRegistry)

.build();

return agent.execute(userMessage);

}

// 自定义企业订单查询工具

@Tool(name = "orderQuery", description = "查询企业订单状态，入参为订单编号")

public String queryOrder(String orderNo) {

// 对接企业内部订单系统API

return "【订单" + orderNo + "状态】：已发货，物流单号：SF1234567890";

}

5.3 自定义链

当需要串联多个自定义任务时，可实现Chain接口自定义链，例如 “文本生成→情感分析→结果过滤” 的组合逻辑：

import dev.langchain4j.chain.Chain;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import org.springframework.stereotype.Service;

@Service

public class CustomChainService {

private final ChatLanguageModel model;

public CustomChainService() {

model = new OpenAiChatModel();

}

// 自定义链执行入口

public String customChainExecute(String userMessage) {

CustomBusinessChain chain = new CustomBusinessChain(model);

return chain.execute(userMessage);

}

// 实现Chain接口，自定义业务链

static class CustomBusinessChain implements Chain {

private final ChatLanguageModel model;

public CustomBusinessChain(ChatLanguageModel model) {

this.model = model;

}

@Override

public String execute(String input) {

// 步骤1：大模型生成文本

String generateText = model.generate("基于以下需求生成文案：" + input);

// 步骤2：对生成的文本进行情感分析

String sentiment = model.generate("分析以下文本的情感倾向，仅返回正面/负面/中性：" + generateText);

// 步骤3：过滤负面文案，返回结果

if ("负面".equals(sentiment)) {

return "生成的文案情感倾向为负面，已过滤，请重新输入需求";

}

return "生成文案（情感：" + sentiment + "）：" + generateText;

}

四、实战案例：智能客服系统

结合以上所有核心功能，我们构建一个企业级智能客服系统，实现多轮上下文对话、实时工具调用、知识库问答的核心能力，让开发者快速将代码落地到实际项目中。

1. 项目结构设计

遵循 SpringBoot 的分层开发规范，按控制器→服务层→自定义组件划分，结构清晰，易于维护：

src/main/java/com/example/aichat/

├── controller/ # 控制层，提供接口入口

│ └── AiChatController.java

├── service/ # 服务层，实现核心业务逻辑

│ └── AiCustomerService.java

└── AiChatApplication.java # SpringBoot启动类

2. 核心代码实现

2.1 服务层：整合所有核心能力

将对话、记忆、Function Calling、RAG 整合到一个服务类，实现智能客服的综合能力：

import dev.langchain4j.agent.Agent;

import dev.langchain4j.agent.tool.Tool;

import dev.langchain4j.agent.tool.ToolRegistry;

import dev.langchain4j.chain.ConversationalRetrievalChain;

import dev.langchain4j.data.document.Document;

import dev.langchain4j.data.document.FileDocumentLoader;

import dev.langchain4j.data.segment.TextSegment;

import dev.langchain4j.data.segment.TextSegmenter;

import dev.langchain4j.data.segment.TextSegmenterFactory;

import dev.langchain4j.memory.chat.MessageWindowChatMemory;

import dev.langchain4j.model.chat.ChatLanguageModel;

import dev.langchain4j.model.openai.OpenAiChatModel;

import dev.langchain4j.retrieval.Retriever;

import dev.langchain4j.retrieval.vectorstore.VectorStoreRetriever;

import dev.langchain4j.vectorstore.VectorStore;

import dev.langchain4j.vectorstore.VectorStoreFactory;

import org.springframework.stereotype.Service;

import java.util.List;

@Service

public class AiCustomerService {

// 核心组件

private final ChatLanguageModel model;

private final MessageWindowChatMemory memory;

private final ToolRegistry toolRegistry;

private final Retriever retriever;

// 初始化所有组件

public AiCustomerService() {

model = new OpenAiChatModel();

// 对话记忆，最大保存100条消息

memory = MessageWindowChatMemory.builder().maxMessages(100).build();

toolRegistry = new ToolRegistry();

// 知识库检索器

VectorStore vectorStore = VectorStoreFactory.create();

retriever = new VectorStoreRetriever(vectorStore);

// 初始化加载企业知识库

this.loadKnowledgeBase("src/main/resources/knowledge/base.md");

}

// 智能客服核心方法：整合记忆、工具、检索

public String customerService(String userMessage) {

ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()

.chatLanguageModel(model)

.chatMemory(memory)

.toolRegistry(toolRegistry)

.retriever(retriever)

.build();

return chain.execute(userMessage);

}

// 工具1：企业产品知识库查询（对接本地文档）

@Tool(name = "productQuery", description = "查询企业产品的功能、价格、使用方法，入参为产品名称")

public String queryProduct(String productName) {

return retriever.retrieve(productName).get(0).text();

}

// 工具2：物流查询

@Tool(name = "logisticsQuery", description = "查询订单物流状态，入参为订单编号")

public String queryLogistics(String orderNo) {

// 对接企业物流系统

return "【订单" + orderNo + "物流】：已到达杭州市余杭区，预计今日送达";

}

// 工具3：人工客服转接

@Tool(name = "transferService", description = "当用户需要人工服务时调用，无入参")

public String transferToHuman() {

return "已为您转接人工客服，客服工号：8008，预计等待时间：30秒，请稍候...";

}

// 加载企业知识库文档

private void loadKnowledgeBase(String docPath) {

try {

DocumentLoader loader = new FileDocumentLoader(docPath);

List<Document> docs = loader.load();

TextSegmenter segmenter = TextSegmenterFactory.create();

List<TextSegment> segments = segmenter.segment(docs);

retriever.add(segments);

System.out.println("企业知识库加载成功，共加载" + segments.size() + "个文本片段");

} catch (Exception e) {

System.err.println("知识库加载失败：" + e.getMessage());

}

2.2 控制层：提供 RESTful 接口

创建控制器，提供 HTTP 接口，供前端或其他系统调用，实现前后端分离：

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

@RestController

@RequestMapping("/api/ai/customer")

public class AiChatController {

// 注入智能客服服务

@Autowired

private AiCustomerService aiCustomerService;

// 智能客服对话接口

@PostMapping("/chat")

public String chat(@RequestBody String userMessage) {

return aiCustomerService.customerService(userMessage);

}

2.3 启动类

普通 SpringBoot 启动类，无需额外配置：

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication

public class AiChatApplication {

public static void main(String[] args) {

SpringApplication.run(AiChatApplication.class, args);

}

3. 接口测试

启动 SpringBoot 项目后，可通过 Postman、Apifox 等工具调用接口，测试智能客服能力：

请求地址：http://localhost:8080/api/ai/customer/chat

请求方式：POST

请求体："我的订单SF1234567890到哪了？"

响应结果：【订单SF1234567890物流】：已到达杭州市余杭区，预计今日送达

五、总结与拓展

1. 整合总结

SpringBoot 与 LangChain4j 的整合，让 Java 开发者无需深入大模型底层调用逻辑，即可快速实现 AI 应用开发，核心优势体现在：

开发高效：基于 SpringBoot 的注解式开发，符合 Java 开发者的编码习惯，快速上手；

能力全面：从基础对话到高级的 RAG、Function Calling，覆盖大模型应用的核心场景；

高度可扩展：支持自定义模型、工具、链，适配企业个性化业务需求；

生态兼容：无缝对接 SpringBoot 生态，可与 Spring Security、MyBatis 等组件结合，构建完整的企业级系统。

本文的案例基于 LangChain4j 内置组件实现，生产环境中可根据业务需求进行优化：

向量库替换：将内置 VectorStore 替换为专业向量库（如 Pinecone、Milvus、Elasticsearch），提升海量知识库的检索性能；

模型集群：对接大模型集群，实现负载均衡，提升接口并发能力；

缓存优化：对高频查询的知识库片段和工具调用结果做缓存，减少大模型和外部 API 的调用次数；

日志与监控：添加详细的日志记录和接口监控，跟踪大模型调用、工具执行的状态，便于问题排查；

权限控制：结合 Spring Security 对 AI 接口做权限控制，避免未授权调用。

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

破解技术文档 4 大痛点，PandaWiki 让研发效率翻倍

在软件开发流程中，技术文档的重要性无需多言。但现实中，许多研发团队都面临着文档维护繁琐、查找效率低下、内容更新滞后等问题，传统的文档管理模式已难以适配现代开发团队的实际需求。PandaWiki 作为一款开源知识库系统，为技术文档的管理与维护提供了全新解决方案。它不仅能帮助团队搭建结构化的文档体系，还借助 AI 能力让文档变得更智能、更易用。