大厂 Java 面试实战：从 Spring Boot 到 AI RAG 智能客服（含完整问答解析）

场景：某内容社区 + AIGC 平台，招聘 Java 高级工程师，主业务是图文/短视频 UGC、AI 智能客服与推荐。

人物：

  • 面试官：资深架构师，语气严肃，但会在候选人答得好时适当引导和夸奖。
  • 小Y：略显“水货”的 Java 程序员，简单题还能答上来，复杂问题就开始含糊其辞、胡乱发挥。

一、第一轮：基础服务 & Spring Boot 入门场景

背景：我们有一个内容社区，用户可以发图文、短视频。现在要做一个内容发布与查询服务，同时为之后的 AI 智能客服提供基础数据接口。

问题 1：Spring Boot 启动流程和自动装配原理

面试官： 我们的内容服务是用 Spring Boot 开发的。你简单说说：一个 Spring Boot 应用从 main 方法启动，到应用跑起来，中间大致发生了什么？特别是 自动装配 是怎么做的？

小Y： 这个嘛，就是 SpringApplication.run(...) 一下，然后 Spring 就“全都帮你配好了”。自动装配就是它自己扫描一下类啊什么的，该配的 Bean 都给你 new 出来了，反正我们一般就加个 @SpringBootApplication 就完事了……

面试官： （皱眉）那你知道 @SpringBootApplication 里边包含哪些注解？spring.factories 或 AutoConfiguration 这些你听过吗？

小Y： 啊……@SpringBootApplication 里面不是有个 @EnableAutoConfiguration 吗？然后就会自动配置……春天来了，万物复苏，所有 Bean 都会自动长出来……

面试官： ……好，先记下来。

问题 2：RESTful API 设计与 Spring MVC

面试官： 内容服务对外要提供 REST API，比如：

  • 发布内容：POST /api/v1/posts
  • 查询内容：GET /api/v1/posts/{id}

你用 Spring MVC / Spring Web 来写，大致会怎么设计 Controller？用到哪些注解？如何处理入参和返回值？

小Y： 这个我会！

@RestController
@RequestMapping("/api/v1/posts")
public class PostController {

    @PostMapping
    public PostDTO createPost(@RequestBody PostCreateRequest request) {
        // 省略
        return new PostDTO();
    }

    @GetMapping("/{id}")
    public PostDTO getPost(@PathVariable Long id) {
        // 省略
        return new PostDTO();
    }
}

就这样，@RestController、@RequestMapping、@PostMapping、@GetMapping，然后用 @RequestBody 接 JSON，@PathVariable 拿路径参数。返回一个对象，Spring 会帮你用 Jackson 转成 JSON。

面试官： 这个还可以，说明你基础写得比较多。

问题 3：数据库设计与 JPA / MyBatis

面试官： 内容要落到数据库。假设我们用 MySQL + JPA（或 MyBatis 均可），你会如何设计一张 内容表？字段会有哪些？Java 里如何建实体类？

小Y： 表嘛，肯定得有：

  • id 主键
  • user_id 用户
  • title 标题
  • content 内容

然后我就 @Entity 搞一个类：

@Entity
@Table(name = "posts")
public class Post {
    @Id
    private Long id;
    private Long userId;
    private String title;
    private String content;
}

剩下的就让 Hibernate 帮我存吧。

面试官： 那审核状态、发布时间、是否逻辑删除这些字段，你考虑了吗？另外，主键 ID 生成策略怎么选？

小Y： 呃……可以后面再加……ID 的话，我一般就 AUTO……自动就行了。

面试官： （记笔记）好。

问题 4：HikariCP 连接池与性能

面试官： 我们线上 MySQL 连接非常多，需要用连接池。Spring Boot 默认集成了 HikariCP。你知道 HikariCP 是干什么的？有哪些主要配置项？为什么不用每次都新建连接？

小Y： HikariCP 就是……连接池，性能比较好。主要配置吧，有 maximumPoolSize，minimumIdle，还有个什么 timeout……反正我一般不配，默认就挺快的。

每次新建连接会很慢嘛，有握手开销，所以要复用。

面试官： 勉强算说到点上。

问题 5：单元测试 JUnit + Mockito

面试官： 这个内容服务，发布接口你会怎么写单元测试？例如只测 Service 层，不连数据库，使用 JUnit5 和 Mockito。

小Y： 嗯……

@ExtendWith(MockitoExtension.class)
class PostServiceTest {

    @Mock
    private PostRepository postRepository;

    @InjectMocks
    private PostService postService;

    @Test
    void testCreatePost() {
        PostCreateRequest req = new PostCreateRequest();
        // ... 设置字段

        when(postRepository.save(any(Post.class)))
            .thenAnswer(invocation -> invocation.getArgument(0));

        PostDTO dto = postService.createPost(req);
        assertNotNull(dto);
    }
}

差不多这样，mock 一下 repository，然后断言不为空……

面试官： 后面有空可以多看看 AssertJ，断言会更优雅一些。

二、第二轮：高并发下的缓存、消息队列与微服务

背景升级：内容访问量上来了，我们接入了推荐系统和 AI 审核，整个系统变成微服务架构，需要考虑缓存、消息队列、服务治理与熔断。

问题 6：Redis 缓存设计与缓存一致性

面试官： 热门内容访问很高，我们决定用 Redis 做缓存。请你说说：

  • 查内容时如何利用 Redis？
  • 缓存 key 设计成什么样？
  • 写内容时如何保证数据库和缓存的一致性？

小Y： 查的时候先查 Redis，查不到再查数据库，然后写进 Redis。Key 可以是 post:id 吧，比如 post:123。

一致性的话……嗯……写的时候就同时更新数据库和 Redis？或者先删 Redis，再更新数据库？或者先更新数据库再删 Redis？反正……看心情？

面试官： （叹气）你知道“先更新 DB 再删缓存”这个常见策略，以及为什么更推荐删缓存而不是更新缓存吗？

小Y： 这个……我记得面经里说过，好像是为了避免脏数据，但是细节我不太记得了……

问题 7：Kafka 在内容审核与推荐中的应用

面试官： 用户发内容后，需要：

  1. 异步送去 AI 审核服务
  2. 异步送给 推荐系统 做用户画像

我们打算用 Kafka。你会怎么设计 topic？生产和消费大致怎么实现？

小Y： 那可以搞两个 topic：

  • post-review
  • post-recommend

内容服务发消息：

kafkaTemplate.send("post-review", postId);
kafkaTemplate.send("post-recommend", postId);

消费者那边写 @KafkaListener，拿到 postId 再去查详情处理。差不多这样？

面试官： 那消息顺序、重复消费、幂等等问题，你想过吗？

小Y： 幂等就……多加几个 if，处理过就不处理了……

面试官： （扶额）好，继续。

问题 8：Spring Cloud 与服务发现、Feign 调用

面试官： 我们各个服务：内容服务、用户服务、审核服务、AI 服务，都注册到服务发现（比如 Nacos / Eureka）上。内容服务需要调用用户服务和 AI 服务接口。你会怎么用 Spring Cloud OpenFeign 来做？

小Y： 我会写一个 Feign 接口：

@FeignClient(name = "user-service")
public interface UserClient {

    @GetMapping("/api/v1/users/{id}")
    UserDTO getUser(@PathVariable("id") Long id);
}

然后在 Service 里面注入 UserClient 就可以直接调了。AI 服务也类似。

面试官： 那超时、重试、熔断、限流这些问题呢？你用过 Resilience4j 吗？

小Y： Resilience4j 我听过，但是没怎么用。一般我就让默认超时，挂了就……再点一次。

面试官： （面无表情）再点一次，是指让用户多点几下吗？

小Y： ……也可以。

问题 9：微服务链路追踪：Zipkin / Jaeger

面试官： 微服务之间调用很多，要排查问题就需要链路追踪。你了解 Zipkin 或 Jaeger 吗？在 Spring Cloud 中大致怎么接入？

小Y： 这个我在别的项目里看过日志里面有 traceId 好像就是这个……具体接入的话，好像是加一个依赖，Spring Cloud Sleuth，然后它就会自动打 traceId 和 spanId 了。Jaeger 的话我只知道是看链路图的界面……

面试官： 你知道 traceId 是如何在不同服务之间传递的吗？

小Y： 应该是靠 HTTP 头之类的吧，比如请求头里面带着一个 ID，调用的时候一起传过去……具体 header 名我倒是不太记得。

问题 10：Prometheus + Grafana 指标监控

面试官： 我们还用 Prometheus + Grafana 对 Java 应用做监控，用 Micrometer 采集指标。你知道 Spring Boot Actuator + Micrometer 是如何暴露监控指标的吗？

小Y： 我知道 /actuator/health ！还有 /actuator/prometheus……

加个依赖，然后 application 里配置一下，Prometheus 就可以拉这些指标，比如 JVM 内存、GC 次数、HTTP 请求次数。Grafana 就画图。

面试官： 那业务层面自定义一个“内容发布成功次数”的指标，你会怎么做？

小Y： 这个……是不是要写个 Counter 之类的？但我没具体写过。

三、第三轮：AI 智能客服、RAG、Agent 与风控

背景再升级：平台接入了 AI 智能客服系统，支持用户用自然语言咨询“如何发内容”“审核规则是什么”“为什么我被限流”等问题。我们计划使用 RAG、向量数据库与 Agentic 工作流来实现企业文档问答和智能工单流转，同时要注意 AI 幻觉和风控问题。

问题 11：RAG、向量数据库与企业文档问答

面试官： 我们有很多平台规则、审核标准、运营手册，想做“企业文档问答”。技术方案考虑：

  • 使用 Spring AI 作为调用大模型的框架
  • 用向量数据库（如 Milvus / Chroma / Redis Vector）存文档的向量
  • 采用 RAG（检索增强生成）来回答

你能描述一下：整个 RAG 流程从用户提问到生成答案，大致的技术步骤吗？

小Y： RAG 我大概知道一点点，就是先检索再生成。

大概流程就是：

  1. 用户问问题
  2. 我们把问题转成向量
  3. 去向量库里找相似的文档
  4. 找到之后塞给大模型
  5. 大模型就会更“贴合资料地”回答

然后……Spring AI 就帮我们把这些都串起来？

面试官： 那你知道“文档分段、向量化、语义检索、提示填充”这些环节各自的作用吗？

小Y： 文档分段就是切块儿……向量化就是 Embedding……提示填充就是在 prompt 里把文档贴给模型……细节我得回去再看看笔记。

问题 12：Agent、工具调用与 AI 幻觉控制

面试官： 我们希望智能客服不只会“聊天”，还要能：

  • 查询用户帐号信息
  • 查询内容审核记录
  • 创建工单

也就是说，需要 工具调用（Tool Calling） 和 多步工作流（Agentic RAG）。同时又要避免 AI 胡说八道（幻觉）。你能说说：

  1. Agent 和普通 Chat 的区别是什么？
  2. 如何通过工具执行框架（如 MCP、标准化工具调用协议）来让 Agent 安全地调用后端接口？
  3. 如何降低 AI 幻觉的风险？

小Y： Agent……嗯……就是更“聪明”的 Chat，可以自己决定下一步干嘛，比如要不要调接口。

工具调用嘛，就是它需要查东西的时候，会让我们后端去查一下，然后再把结果给它，它就能回答得更准。

安全方面的话，肯定不能把所有接口都开放给它，要做权限控制之类的。至于 MCP 这些协议，我……我其实没用过，只知道有这么个概念。

至于幻觉嘛，可以多给它点资料，多提醒它“不要瞎编”，答不出来就说不知道……

面试官： 你提到了“不要瞎编”，这个确实是一个方向，比如在 prompt 设计、系统提示、以及对模型输出做校验，都可以有策略。

四、面试总结与“回家等通知”

面试官： 今天的面谈就到这里。你在 Spring MVC、基本的 REST API、Kafka 使用方式这些方面有一些实践经验，但在微服务治理、缓存一致性、监控、以及 AI + RAG 等方向掌握得比较粗浅，很多只是停留在“听说过”。

我们会综合评估一下，再和你联系。你先回去等通知吧。

小Y： 好的好的，那我回去再好好看一下 Spring Cloud 和 RAG！

五、12 个面试题的详细解析（小白也能看懂）

下面是对上面 12 个问题的系统性讲解，按业务场景串起来。

1. Spring Boot 启动流程与自动装配（问题 1）

核心技术点： Java SE, Spring Boot, Spring Framework, 自动装配（AutoConfiguration）, @SpringBootApplication

1.1 从 main 方法到应用启动

典型的 Spring Boot 启动类：

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

执行流程（简化版）：

  1. 创建 SpringApplication 对象
  2. 推断应用类型（Servlet、Reactive WebFlux、None）
  3. 准备环境（Environment）
  4. 创建并刷新 ApplicationContext
  5. 执行自动装配，加载各种 @Configuration Bean
  6. 启动内嵌容器（Tomcat / Jetty / Netty）
1.2 @SpringBootApplication 包含什么

它其实是组合注解：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
public @interface SpringBootApplication {}
  • @SpringBootConfiguration = @Configuration
  • @ComponentScan：扫描当前包及子包中的组件
  • @EnableAutoConfiguration：开启自动装配
1.3 自动装配的原理

以 Spring Boot 2.x 为例：

  • 在依赖里，每个 starter 都会带一个 spring.factories 文件
  • 里边定义了 EnableAutoConfiguration 对应的自动配置类列表
org.springframework.boot.autoconfigure.EnableAutoConfiguration=
  org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,
  org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,
  ...

启动时：

  1. Spring 通过 SpringFactoriesLoader 读取所有 jar 包里的 spring.factories
  2. 找出所有 EnableAutoConfiguration 的实现类
  3. 按条件（@ConditionalOnClass, @ConditionalOnMissingBean 等）决定是否生效

例如引入了 spring-boot-starter-data-jpa，就会自动：

  • 配置 EntityManagerFactory
  • 配置 DataSource（结合 HikariCP）
  • 扫描 @Entity

理解要点：

  • Starter + AutoConfiguration 解耦了“依赖引入”和“默认配置”
  • 条件注解允许你覆盖默认行为

2. RESTful API 与 Spring MVC（问题 2）

核心技术点： Spring MVC, Spring Web, Jackson, REST 设计

在内容服务中，一个典型的 REST Controller：

@RestController
@RequestMapping("/api/v1/posts")
public class PostController {

    private final PostService postService;

    public PostController(PostService postService) {
        this.postService = postService;
    }

    @PostMapping
    public PostDTO createPost(@RequestBody PostCreateRequest request) {
        return postService.createPost(request);
    }

    @GetMapping("/{id}")
    public PostDTO getPost(@PathVariable Long id) {
        return postService.getPost(id);
    }
}

注解作用：

  • @RestController = @Controller + @ResponseBody：返回 JSON
  • @RequestMapping：类级别路由前缀
  • @PostMapping/@GetMapping：具体 HTTP 方法路由
  • @RequestBody：将 JSON 请求体反序列化到 Java 对象（用 Jackson）
  • @PathVariable：从 URL 路径里取参数

REST 设计建议：

  • 资源路径用名词：/posts, /users
  • 操作用 HTTP 方法表示：GET/POST/PUT/DELETE
  • 使用合理的状态码：200/201/400/401/403/404/500

3. 数据库建模与 ORM（问题 3）

核心技术点： MySQL, JPA, Hibernate, Spring Data JPA / MyBatis

3.1 内容表设计示例
CREATE TABLE post (
  id           BIGINT PRIMARY KEY,
  user_id      BIGINT       NOT NULL,
  title        VARCHAR(255) NOT NULL,
  content      TEXT         NOT NULL,
  status       TINYINT      NOT NULL DEFAULT 0,  -- 0:草稿,1:待审,2:已过审,3:驳回
  visible      TINYINT      NOT NULL DEFAULT 1,  -- 1:可见,0:不可见
  created_at   DATETIME     NOT NULL,
  updated_at   DATETIME     NOT NULL,
  is_deleted   TINYINT      NOT NULL DEFAULT 0,
  INDEX idx_user_created (user_id, created_at)
);
3.2 JPA 实体映射示例
@Entity
@Table(name = "post")
public class Post {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "user_id", nullable = false)
    private Long userId;

    @Column(nullable = false, length = 255)
    private String title;

    @Lob
    @Column(nullable = false)
    private String content;

    private Integer status;
    private Integer visible;

    @Column(name = "created_at")
    private LocalDateTime createdAt;

    @Column(name = "updated_at")
    private LocalDateTime updatedAt;

    @Column(name = "is_deleted")
    private Integer isDeleted;
}

主键策略选择：

  • 小规模项目可用 IDENTITY（自增）
  • 分布式场景常用雪花算法、UUID、Segment/Leaf 等

4. HikariCP 连接池与性能（问题 4）

核心技术点： HikariCP, 连接池, JDBC, 数据库性能

为什么要连接池？

  • 每次新建 connection = 网络握手 + 认证，开销大
  • 并发下频繁创建/销毁连接很慢

HikariCP 是 Spring Boot 默认连接池，特点：

  • 轻量、响应快
  • 低延迟

常用配置：

spring:
  datasource:
    url: jdbc:mysql://...
    username: root
    password: ...
    hikari:
      maximum-pool-size: 30
      minimum-idle: 10
      idle-timeout: 600000      # 10 分钟
      max-lifetime: 1800000     # 30 分钟
      connection-timeout: 30000 # 30 秒

调参经验：

  • maximum-pool-size 不要超过数据库允许的最大连接数
  • 根据 QPS 和单次查询耗时估算需要的连接数

5. 单元测试 JUnit5 + Mockito（问题 5）

核心技术点： JUnit 5, Mockito, AssertJ, 单元测试

目标：只测业务逻辑，不访问数据库。

示例：

@ExtendWith(MockitoExtension.class)
class PostServiceTest {

    @Mock
    private PostRepository postRepository;

    @InjectMocks
    private PostService postService;

    @Test
    void createPost_shouldReturnDto() {
        PostCreateRequest req = new PostCreateRequest();
        req.setUserId(1L);
        req.setTitle("hello");
        req.setContent("world");

        when(postRepository.save(any(Post.class)))
                .thenAnswer(invocation -> {
                    Post p = invocation.getArgument(0);
                    p.setId(100L);
                    return p;
                });

        PostDTO dto = postService.createPost(req);

        assertThat(dto.getId()).isEqualTo(100L);
        assertThat(dto.getTitle()).isEqualTo("hello");
    }
}

要点：

  • @Mock 替代外部依赖
  • @InjectMocks 注入到被测类
  • 使用 AssertJ：assertThat(...) 更可读

6. Redis 缓存与一致性（问题 6）

核心技术点： Redis, Spring Cache, 缓存穿透/击穿/雪崩, 缓存一致性

常用读流程：

  1. 先查 Redis
  2. 有值：直接返回
  3. 无值：查 DB，写回 Redis，返回

Key 设计：

  • post:{id} 如 post:123，直观易管理
一致性策略（典型思路）

以“读多写少”的内容服务为例：

  • 更新流程（推荐之一）

    1. 更新 DB
    2. 删除缓存 DEL post:{id}

  • 为什么“删缓存”而不是“更新缓存”？

    • 更新缓存需要先读旧值、计算新值，逻辑复杂
    • 删除更简单，而且下一次读时会自动从 DB 回填

要注意：

  • 写请求并发时，可能出现“删除顺序乱”的问题，要配合过期时间与重试策略
  • 对极其敏感的场景可以考虑消息队列来串行更新

7. Kafka 在异步流程中的应用（问题 7）

核心技术点： Kafka, 消息队列, 幂等, 消费者分组

应用场景：

  • 用户发内容 -> 内容服务落库成功 -> 发送消息给：
    • 审核服务
    • 推荐服务

Topic 设计：

  • post-created-review
  • post-created-recommend

生产端示例：

public void publishPostCreated(Long postId) {
    kafkaTemplate.send("post-created-review", postId.toString());
    kafkaTemplate.send("post-created-recommend", postId.toString());
}

消费端示例：

@KafkaListener(topics = "post-created-review", groupId = "review-service")
public void handleReview(String postId) {
    // 1. 根据 postId 查 DB
    // 2. 送入 AI 审核模型
}

幂等处理：

  • 在审核/推荐服务中，用“业务表 + 唯一索引”或 Redis 记录是否已处理过某个 postId
  • 即使消息重复消费，也不会重复写入

8. Spring Cloud & OpenFeign（问题 8）

核心技术点： Spring Cloud, OpenFeign, 服务治理, Resilience4j

典型的 Feign 调用：

@FeignClient(name = "ai-service", configuration = AiFeignConfig.class)
public interface AiClient {

    @PostMapping("/api/v1/review")
    ReviewResult review(@RequestBody ReviewRequest request);
}

与 Resilience4j 结合：

@CircuitBreaker(name = "aiService", fallbackMethod = "reviewFallback")
public ReviewResult reviewContent(Post post) {
    return aiClient.review(new ReviewRequest(post.getId(), post.getContent()));
}

public ReviewResult reviewFallback(Post post, Throwable t) {
    // 降级策略：标记为待人工审核
    return ReviewResult.pending(post.getId());
}

要点：

  • 为关键下游服务配置：超时、重试、熔断
  • 降级逻辑要与业务结合（例如转人工）

9. 链路追踪：Zipkin / Jaeger（问题 9）

核心技术点： Spring Cloud Sleuth, Zipkin/Jaeger, TraceId, SpanId

基本原理：

  • 每个请求有一个 traceId
  • 一次调用链的每一段是一个 span，有 spanId
  • 通过 HTTP Header 传递：
    • 老方案：X-B3-TraceId, X-B3-SpanId
    • 新方案：traceparent（W3C 标准）

Spring Cloud Sleuth 做的事情：

  • 接入 HTTP 拦截器、Feign 拦截器
  • 每次调用自动生成或继承 traceId/spanId
  • 自动把这些信息加到日志 MDC 中

Zipkin/Jaeger：

  • 收集这些 trace 数据
  • 提供 Web UI 展示调用链路和耗时

10. Prometheus + Grafana + Micrometer（问题 10）

核心技术点： Spring Boot Actuator, Micrometer, Prometheus, Grafana

Spring Boot Actuator 暴露监控端点：

  • /actuator/health 健康检查
  • /actuator/metrics 指标
  • /actuator/prometheus Prometheus 格式输出

引入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

自定义业务指标：

@Component
public class PostMetrics {

    private final Counter postCreateCounter;

    public PostMetrics(MeterRegistry registry) {
        this.postCreateCounter = Counter.builder("post_create_total")
                .description("Total created posts")
                .tag("service", "content")
                .register(registry);
    }

    public void increment() {
        postCreateCounter.increment();
    }
}

在 PostService.createPost 中调用 postMetrics.increment()，就能在 Prometheus 中看到该指标。

11. RAG 与向量数据库：企业文档问答（问题 11）

核心技术点： RAG, Embedding, 向量数据库（Milvus/Chroma/Redis Vector/Cassandra+向量扩展）, 语义检索, Spring AI

11.1 RAG 的整体流程

以“平台审核规则文档问答”为例：

  1. 离线阶段：文档准备

    • 收集所有审核规则、运营手册、FAQ 等 PDF/Word/Markdown
    • 使用“文档加载器”解析为纯文本

  2. 分段（Chunking）

    • 按段落/标题/长度将长文档切成小块
    • 每块 300~1000 字左右，兼顾语义完整和检索精度

  3. 向量化（Embedding）

    • 调用 Embedding 模型（如 OpenAI, Ollama 等）
    • 将每个文档块转成向量（高维浮点数数组）

  4. 存入向量数据库

    • 结构：{id, text, metadata, vector}
    • 数据库可以是 Milvus、Chroma、Elasticsearch+向量插件、Redis 向量索引等

  5. 在线阶段：用户提问

    • 用户输入自然语言问题：如“为什么我的短视频被判定涉黄？”

  6. 问题向量化

    • 对问题文本也做 Embedding，得到问题向量

  7. 语义检索

    • 在向量库中按相似度搜索，找出最相关的 k 个文档块

  8. 提示填充（Prompting）

    • 构造给大模型的 Prompt：

    系统：你是平台审核规则专家，只能根据提供的规则回答。 上下文：

    • 文档片段1
    • 文档片段2 问题：用户的问题

  9. 大模型生成答案

    • 模型参考检索到的“知识”，给出回答
11.2 为什么 RAG 能减少幻觉
  • 传统纯生成：模型只靠训练时记忆，可能“瞎编”平台规则
  • RAG：
    • 让模型基于 最新、准确的企业文档 作答
    • Prompt 中要求“只根据提供上下文回答，不要自创规则”

这对内容审核、风控场景很关键。

12. Agent、工具调用、MCP 与 AI 幻觉（问题 12）

核心技术点： Agent, 工具调用（Tool Calling）, MCP（模型上下文协议）, 工作流编排, Agentic RAG, AI 幻觉

12.1 Agent vs 普通 Chat

  • 普通 Chat：

    • 输入问题 -> 模型直接生成文字回答
    • 不主动调用外部系统

  • Agent：

    • 具备“规划能力”：拆分任务、多轮决策
    • 可以选择调用后端工具（API）来查数据、下单、创建工单等

在智能客服中：

  • Chat：仅给出“你可以联系客服”的建议
  • Agent：直接帮你创建工单、查订单状态、申请退款
12.2 工具调用与 MCP（模型上下文协议）

工具调用标准化思路：

  1. 定义工具的“接口描述”：
    • 名称、参数、返回值
    • 权限和安全约束
  2. 模型在对话中决定是否调用某个工具
  3. 工具执行在 我方后端 完成
  4. 执行结果回传给模型，由模型继续生成答案

MCP（Model Context Protocol）等协议的目标：

  • 统一“模型-客户端-工具”的交互方式
  • 让不同模型、不同工具之间更容易集成

在业务里：

  • 定义工具：getUserInfo, getReviewRecord, createTicket 等
  • 为每个工具设置访问控制：
    • 只能查当前登录用户的数据
    • 敏感操作需要额外确认
12.3 控制 AI 幻觉的策略

  1. Prompt 级约束

    • 明确告诉模型：不确定就说“不知道”
    • 限制其不得编造审核规则或法律条文

  2. RAG + 严格上下文

    • 只允许模型基于检索到的审核规则回答
    • 没有命中相关片段时，直接引导人工客服

  3. 输出后校验

    • 对模型的回答做正则/规则检查
    • 不允许出现危险操作（如引导违规操作）

  4. 工具结果优先

    • 对于订单状态、审核结果等，优先以系统真实数据为准
    • 模型只负责解释和安抚语言

  5. 可追踪与审计

    • 所有问答与工具调用记录下来
    • 便于事后回溯和优化
12.4 Agentic RAG 与复杂工作流

在复杂的企业场景中（内容审核申诉、风控、供应链金融等），Agent 可以：

  1. 接收用户自然语言问题
  2. 决定是否先走 RAG 检索企业文档
  3. 再决定是否调用内部系统：
    • 查询账户风险标签
    • 查询历史申诉记录
    • 创建/更新工单
  4. 根据规则和查询结果，规划下一步行动

这就是“Agentic RAG”：

  • RAG 解决“知识外部化”问题
  • Agent 解决“多步决策 + 工具执行”问题

六、如何用这套场景系统复盘学习

如果你是小白，想通过这篇“剧情化面试”系统提升，可以按下面顺序学：

  1. 打基础

    • Java SE 8/11（集合、并发、JVM 基本原理）
    • Spring Boot + Spring MVC，能写 REST 服务
    • MySQL + JPA/MyBatis，能做简单 CRUD

  2. 进阶服务端开发

    • HikariCP 连通池调整
    • Redis 缓存 + 常见问题（穿透/击穿/雪崩）
    • Kafka 或 RabbitMQ 异步解耦
    • JUnit5 + Mockito 单元测试

  3. 迈向分布式与云原生

    • Spring Cloud（服务发现、Feign、Gateway）
    • 微服务治理：限流、熔断、降级（Resilience4j）
    • 链路追踪：Sleuth + Zipkin/Jaeger
    • 监控：Prometheus + Grafana + Micrometer

  4. 拥抱 AI + RAG + Agent

    • 理解 Embedding、向量数据库、语义检索
    • 通过 Spring AI 或其他 SDK 调用大模型
    • 设计企业文档问答系统（RAG）
    • 了解 MCP、工具调用、Agentic RAG
    • 学会思考“幻觉、风控、安全”问题

以这套“内容社区 + AI 智能客服”的业务线索为主线，一次性串起了 Java 服务端主流技术栈和前沿 AI 能力，也正是当下大厂面试越来越关注的方向。

# 微服务 # RAG
Logo
腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

avatar 腾讯云开发者社区

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

avatar 腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git

avatar 腾讯云开发者社区