面向 5 年经验 Java 开发者,目标岗位 18-22K AI+Java 方向。
每题包含:标准回答 → 追问 → 追问回答 → 面试Tips。
标准回答:
Bean 生命周期核心阶段:实例化(反射创建)→ 属性填充(@Autowired)→ Aware 回调(BeanNameAware/ApplicationContextAware)→ BeanPostProcessor.postProcessBeforeInitialization → InitializingBean.afterPropertiesSet → @PostConstruct → 自定义 init-method → BeanPostProcessor.postProcessAfterInitialization(AOP 代理在此生成)→ 使用 → DisposableBean.destroy → @PreDestroy → 自定义 destroy-method。
追问:BeanPostProcessor 和 BeanFactoryPostProcessor 的区别?
回答:
BeanFactoryPostProcessor 在 Bean 实例化之前执行,可以修改 BeanDefinition(如 PropertyPlaceholderConfigurer 替换占位符);BeanPostProcessor 在 Bean 实例化之后执行,可以修改或替换 Bean 实例(如 AbstractAutoProxyCreator 生成 AOP 代理)。执行时机不同,作用对象不同(一个是定义,一个是实例)。
Tips: 生命周期不用背全,但一定要提到 AOP 代理在 postProcessAfterInitialization 中生成。
标准回答:
Spring AOP 默认使用 JDK 动态代理(接口代理)或 CGLIB(类代理)。如果目标类实现了接口且未配置强制 CGLIB,用 JDK 动态代理;否则用 CGLIB 生成子类。Spring Boot 2.x 默认使用 CGLIB(spring.aop.proxy-target-class=true)。两者区别:JDK 代理只能代理接口方法;CGLIB 可以代理类的方法(final 除外),通过生成子类实现。
追问:JDK 动态代理的原理?手写一个核心逻辑?
回答:
JDK 动态代理通过 Proxy.newProxyInstance() 在运行时生成实现目标接口的代理类,代理类将方法调用转发到 InvocationHandler.invoke(),在此处织入切面逻辑。
Object proxy = Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
(proxyObj, method, args) -> {
// 前置通知
log.info("Before: {}", method.getName());
Object result = method.invoke(target, args);
// 后置通知
log.info("After: {}", method.getName());
return result;
}
);
Tips: 面试官可能让你手写,核心就 InvocationHandler 那一行。
标准回答:
@SpringBootApplication 包含 @EnableAutoConfiguration,通过 @Import(AutoConfigurationImportSelector.class) 加载 META-INF/spring.factories(Boot 2.x)或 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports(Boot 3.x)中的自动配置类。每个 @AutoConfiguration 类通过 @Conditional 系列注解(@ConditionalOnClass、@ConditionalOnMissingBean 等)按条件装配。
追问:如果两个自动配置类冲突了怎么办?
回答:
Spring Boot 提供多种控制手段:@AutoConfigureOrder 控制加载顺序;@ConditionalOnMissingBean 保证只有一个生效(后加载的发现已有就跳过);spring.autoconfigure.exclude 配置排除特定自动配置;@ConditionalOnProperty 通过配置开关控制。Starter 的自动配置类通常设计为 @ConditionalOnMissingBean,用户自定义的 Bean 优先。
Tips: 提到 Boot 2.x 用 spring.factories、Boot 3.x 用 imports 文件说明你关注版本变化。
标准回答:
七种传播行为,常用的三种:REQUIRED(默认,有事务加入,没有新建)、REQUIRES_NEW(始终新建事务,挂起当前事务)、NESTED(嵌套事务,Savepoint 回滚不影响外层)。其他:SUPPORTS、NOT_SUPPORTED、MANDATORY、NEVER。
追问:REQUIRED 和 NESTED 的区别?NESTED 的实现原理?
回答:
REQUIRED 加入同一个事务,内层回滚会导致整个事务回滚;NESTED 创建 Savepoint,内层回滚到 Savepoint 不影响外层。NESTED 底层依赖数据库的 Savepoint 机制(JDBC 的 Connection.setSavepoint()),外层事务提交时嵌套事务一起提交。注意:NESTED 只在 DataSourceTransactionManager 下有效,JTA 不支持。
@Transactional(propagation = Propagation.REQUIRED)
public void outerMethod() {
orderService.createOrder(order); // 加入外层事务
try {
pointService.deductPoints(userId); // NESTED,失败不影响外层
} catch (Exception e) {
log.warn("扣积分失败,后续补偿");
}
}
Tips: 面试常考 REQUIRED vs REQUIRES_NEW vs NESTED 三者区别。
标准回答:
五种基本类型:String(SDS)、List(quicklist=ziplist+linkedlist)、Hash(ziplist/ht)、Set(intset/ht)、ZSet(ziplist/skiplist+ht)。Redis 6+ 还有 Stream(消息流)、HyperLogLog(基数统计)、Bitmap/Bitfield、GEO(ZSet + GeoHash)。底层编码会根据数据量自动转换(如 Hash 元素少时用 ziplist,多时转 ht)。
追问:跳表的实现原理?为什么 ZSet 用跳表不用红黑树?
回答:
跳表是多层有序链表,通过随机层数实现 O(logN) 查找。插入时通过抛硬币决定层数(概率 1/2^n),最高 32 层。选跳表不用红黑树的原因:实现简单、范围查询更高效(链表顺序遍历即可)、内存可调(可通过概率控制节点层数的期望)。Redis 的跳表每个节点还存储了 span 字段用于 rank 查询。
Tips: 能说 "范围查询更高效" 和 "实现简单" 两个理由就够了。
标准回答:
RDB 是某一时刻的全量快照(fork 子进程用 COW 写入 .rdb 文件),恢复速度快但可能丢失两次快照间的数据。AOF 记录每条写命令(appendonly.aof),数据完整性更好但文件更大。Redis 4.0 引入混合持久化:AOF 重写时前半段用 RDB 格式(快),后半段用 AOF 增量命令(全),兼顾速度和安全。
追问:AOF 重写(rewrite)的触发条件和流程?
回答:
触发条件:auto-aof-rewrite-percentage(AOF 文件大小超过上次重写后大小的百分比,默认 100%)和 auto-aof-rewrite-min-size(最小重写大小,默认 64MB),两者同时满足。流程:fork 子进程 → 子进程基于当前内存生成新的 AOF → 父进程继续处理命令写入 AOF 重写缓冲区 → 子进程完成后父进程将缓冲区追加到新 AOF → 原子替换旧文件。
Tips: 混合持久化是 Redis 4.0 的特性,面试加分点。
标准回答:
B+ 树相比 B 树:非叶子节点只存键不存数据,单个页能容纳更多键,树更矮(通常 3-4 层即可存千万级数据);所有数据在叶子节点且通过链表相连,范围查询只需顺序扫描链表。相比 Hash 索引:支持范围查询、排序、最左前缀匹配。相比红黑树:IO 次数更少(树矮),磁盘预读友好(页对齐)。
追问:联合索引 (a, b, c) 的最左前缀原则?
回答:
索引按 a→b→c 排列,查询条件必须从最左列开始才能利用索引。等值查询时顺序不影响(优化器会调整),但遇到范围查询(>、<、BETWEEN、LIKE)后右侧列无法使用索引。覆盖索引(SELECT 列都在索引中)可避免回表,是重要的优化手段。
-- 能用索引
SELECT * FROM t WHERE a = 1 AND b = 2 AND c > 3;
-- 只能用 a 索引
SELECT * FROM t WHERE a = 1 AND c = 3; -- b 断了,c 用不上
-- 索引下推(ICP,MySQL 5.6+)
-- 存储层在 (a,b,c) 索引上先按 a 过滤,再按 c 过滤,减少回表次数
Tips: 提到索引下推(ICP)是加分项。
标准回答:
MVCC(多版本并发控制)通过隐藏列(trx_id 事务ID、roll_pointer 回滚指针)+ Undo Log 版本链 + ReadView 实现可重复读(RR)。ReadView 包含:min_trx_id(活跃事务最小ID)、max_trx_id(下一个分配的事务ID)、creator_trx_id(当前事务ID)、m_ids(活跃事务ID列表)。可见性判断:版本 trx_id < min_trx_id 或不在 m_ids 中则可见。
追问:RC 和 RR 级别下 MVCC 的区别?
回答:
核心区别在于 ReadView 的生成时机:RC(读已提交)每次 SELECT 生成新的 ReadView,所以能看到其他事务已提交的最新数据;RR(可重复读)只在第一次 SELECT 时生成 ReadView,后续查询复用,所以同一事务内多次读结果一致。这也是 RR 级别解决不可重复读但可能出现幻读(快照读不感知新行)的原因。
Tips: 能说清 ReadView 生成时机的区别就够了。
标准回答:
三个环节保证:(1) 生产端:confirm 模式(异步确认消息到达 Broker)+ mandatory(消息无法路由时返回);(2) Broker:消息持久化(Exchange/Queue/Message 都设 durable);(3) 消费端:手动 ACK,消费失败 NACK 重回队列或进入死信队列(DLX)。还可以搭配消息补偿表做定时重发。
追问:死信队列的触发条件和使用场景?
回答:
三种触发条件:消息被 NACK 且 requeue=false、消息 TTL 过期、队列达到最大长度。使用场景:消费失败后的延迟重试(TTL + DLX 实现延迟队列)、订单超时取消(下单消息设 TTL,过期进 DLX 触发取消逻辑)、异常消息集中处理。
// 死信队列配置
@Bean
public Queue orderQueue() {
return QueueBuilder.durable("order.queue")
.ttl(30000) // 30秒超时
.deadLetterExchange("dlx.exchange")
.deadLetterRoutingKey("dlx.order")
.build();
}
Tips: TTL + DLX 实现延迟队列是经典方案,必须掌握。
标准回答:
Kafka:高吞吐、依赖 ZooKeeper/KRaft、支持 Exactly-Once(事务消息)、分区有序、适合大数据和日志场景。RocketMQ:延迟消息原生支持、事务消息、消息过滤(Tag/SQL92)、可靠重试、适合电商和金融场景。Kafka 适合大数据量日志/流处理,RocketMQ 适合业务消息(订单、支付)。
追问:Kafka 如何保证消息的顺序性?
回答:
Kafka 只保证单分区内有序。发送时指定相同的 key(如 orderId)路由到同一分区,消费者单线程消费该分区。如果需要多线程消费提升吞吐,可以用内存队列分发:拉取消息后按 key hash 到不同内存队列,每个队列单线程处理。
Tips: 别说 "Kafka 保证全局有序",它只保证分区内有序。
标准回答:
Nacos 支持 AP 和 CP 切换(临时实例用 Distro 协议 AP,持久实例用 Raft 协议 CP),Eureka 只有 AP。Nacos 还集成了配置中心(热配置推送),Eureka 只有服务发现。Nacos 支持服务分组、权重路由、健康检查多样化(TCP/HTTP/gRPC),Eureka 只有心跳。Eureka 已停止维护(2.x 闭源),Nacos 持续更新。
追问:Nacos 的临时实例和持久实例有什么区别?
回答:
临时实例(ephemeral=true):客户端主动心跳保活,不健康自动剔除,适合微服务实例(上下线频繁)。持久实例(ephemeral=false):服务端主动探测健康状态,不健康仅标记不剔除,适合数据库、缓存等基础设施。默认临时实例,注册时通过 ephemeral 参数指定。
Tips: 提到 AP/CP 切换机制是区分度。
标准回答:
Sentinel 核心是插槽链(Slot Chain):NodeSelectorSlot → ClusterBuilderSlot → StatisticSlot(滑动窗口统计)→ AuthoritySlot → SystemSlot → FlowSlot(限流)→ DegradeSlot(熔断)。限流算法支持 QPS 和线程数两种模式。滑动窗口用 LeapArray 结构(环形数组 + 时间窗口),默认 1 秒分 2 个 500ms 窗口。
追问:滑动窗口和令牌桶算法的区别?Sentinel 为什么选滑动窗口?
回答:
滑动窗口统计最近时间窗口内的请求数,超过阈值直接拒绝,实现简单且不需要预分配令牌。令牌桶允许突发流量(桶中有积累的令牌),更平滑但需要后台线程填充。Sentinel 选滑动窗口因为:实现轻量(无额外线程)、统计精确(可配置窗口精度)、支持多种流控效果(快速失败/排队等待/慢启动)。
Tips: 能说出 Sentinel 的插槽链顺序和滑动窗口实现,面试官会觉得你深入读过。
标准回答:
Gateway 基于 WebFlux(Netty + Reactor),核心是 Filter Chain:GlobalFilter + GatewayFilter 组成。请求流程:RoutePredicate 匹配路由 → Pre Filter 链 → 转发到下游服务 → Post Filter 链。内置过滤器:AddRequestHeader、RequestRateLimiter、CircuitBreaker、LoadBalancer(集成 LB)。
追问:如何实现一个统一的鉴权过滤器?
回答:
@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String token = exchange.getRequest().getHeaders().getFirst("Authorization");
if (StringUtils.isBlank(token)) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete();
}
// 校验 JWT
try {
Claims claims = JwtUtil.parseToken(token);
ServerHttpRequest request = exchange.getRequest().mutate()
.header("X-User-Id", claims.getSubject())
.build();
return chain.filter(exchange.mutate().request(request).build());
} catch (Exception e) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete();
}
}
@Override
public int getOrder() { return -1; } // 最高优先级
}
Tips: GlobalFilter 的 getOrder() 越小优先级越高,-1 表示最先执行。
标准回答:
Docker 镜像由多个只读层(Layer)叠加而成,每条 Dockerfile 指令生成一层。容器运行时在镜像顶部添加可写层(Container Layer),文件修改用 COW(Copy-On-Write)策略:修改下层文件时先复制到可写层再修改。共享相同基础层的镜像节省磁盘空间,push/pull 时只传输变化的层。
追问:如何优化 Dockerfile 减少镜像层数和体积?
回答:
(1) 合并 RUN 指令(用 && 连接);(2) 多阶段构建(multi-stage build),编译阶段和运行阶段分开;(3) 利用构建缓存:把变化少的指令(如 COPY pom.xml + RUN mvn dependency:resolve)放前面;(4) 使用 .dockerignore 排除无关文件;(5) 选用精简基础镜像(eclipse-temurin:17-jre-alpine 代替完整 JDK)。
# 多阶段构建
FROM maven:3.9-eclipse-temurin-17 AS build
COPY pom.xml /app/
RUN mvn dependency:resolve
COPY src /app/src
RUN mvn package -DskipTests
FROM eclipse-temurin:17-jre-alpine
COPY --from=build /app/target/*.jar /app/app.jar
ENTRYPOINT ["java", "-jar", "/app/app.jar"]
Tips: 多阶段构建和缓存优化是必考点。
标准回答:
Pod 生命周期阶段:Pending → Running → Succeeded/Failed → Unknown。Pod 内容器生命周期:Wait(等待调度/拉镜像)→ Running → Terminated。关键钩子:postStart(容器创建后立即执行)、preStop(容器终止前执行,用于优雅关闭)。探针:livenessProbe(存活检测,失败重启容器)、readinessProbe(就绪检测,失败从 Service 摘流)、startupProbe(启动检测,成功后才执行其他探针)。
追问:preStop 和应用优雅关闭如何配合?
回答:
preStop 在 kubelet 发送 SIGTERM 之前执行,用于在容器收到信号前做准备工作(如从注册中心注销、等待流量排空)。执行完 preStart 后 kubelet 才发送 SIGTERM,应用收到后开始优雅关闭(Spring Boot 的 @PreDestroy、shutdown hook)。terminationGracePeriodSeconds(默认 30s)是总超时,超时后发送 SIGKILL 强制终止。
lifecycle:
preStop:
exec:
command: ["sh", "-c", "sleep 10"] # 等待流量排空
Tips: preStop + sleep 是 K8s 优雅发布的经典配置。
标准回答:
倒排索引是 "词项 → 文档列表" 的映射。写入时经过:字符过滤 → 分词(Tokenizer)→ Token 过滤 → 建立词项字典(Term Dictionary,FST 结构)+ 倒排表(Posting List,FOR 压缩)。查询时通过 FST 快速定位词项,获取对应的文档 ID 列表,再合并评分返回。ES 的 segment 是不可变的,查询时并行扫描所有 segment。
追问:ES 的写入流程和实时性?
回答:
写入请求先到主分片的 IndexBuffer(内存缓冲),refresh(默认 1 秒)后写入新的 segment(可搜索);flush 时 segment 持久化到磁盘并写入 translog。所以 ES 近实时(NRT):写入后最多等 1 秒可被搜到。bulk 写入可调大 refresh_interval 降低 refresh 频率提升吞吐。
Tips: 近实时的原因就是 refresh 间隔,这是 ES 的核心概念。
标准回答:
MyBatis 是半自动 ORM,需手写 SQL 和映射文件;MyBatis-Plus 在 MyBatis 之上封装了通用 CRUD(BaseMapper)、条件构造器(LambdaQueryWrapper)、分页插件、代码生成器等,减少样板代码。MP 的核心增强:自动填充、逻辑删除、乐观锁插件、多租户插件,都是通过拦截器(Interceptor)实现的。
追问:MyBatis 的一级缓存和二级缓存?
回答:
一级缓存是 SqlSession 级别,默认开启,同一 SqlSession 中相同查询命中缓存;增删改操作会清空该 SqlSession 的缓存。二级缓存是 Mapper 级别,需手动开启(<cache/>),跨 SqlSession 共享,实体类必须可序列化。生产中一般不用二级缓存(多表关联时缓存一致性难保证),靠 Redis 做分布式缓存。
Tips: 明确说 "生产不用二级缓存,用 Redis" 是实战经验的体现。
标准回答:
Spring Event 基于观察者模式:ApplicationEventPublisher 发布事件 → @EventListener 注解监听。默认同步执行(在发布者线程中),加 @Async 注解可异步执行(需开启 @EnableAsync)。Spring 4.2+ 支持任意对象作为事件(不必须继承 ApplicationEvent),支持泛型事件、条件过滤(condition)、SpEL 表达式。
追问:Spring Event 和 MQ 消息队列的区别?适用场景?
回答:
Spring Event 是进程内事件,无网络开销,但不可跨应用、不可持久化、应用重启丢失。MQ 是跨进程的异步消息,支持持久化、重试、消费确认。选择:单应用内解耦(如用户注册后发积分、发通知)用 Event;跨服务异步通信用 MQ。Event 适合低延迟、强一致场景;MQ 适合最终一致性、流量削峰场景。
// 事件定义 + 发布 + 监听
public record OrderCreatedEvent(Long orderId, BigDecimal amount) {}
@Service
public class OrderService {
@Autowired
private ApplicationEventPublisher publisher;
public void createOrder(Order order) {
orderMapper.insert(order);
publisher.publishEvent(new OrderCreatedEvent(order.getId(), order.getAmount()));
}
}
@Component
public class PointsListener {
@EventListener
@Async("eventExecutor")
public void onOrderCreated(OrderCreatedEvent event) {
pointsService.grant(event.orderId());
}
}
Tips: 用 record 定义事件是 Spring 6 + Java 17 的优雅写法。
标准回答:
Spring 通过三级缓存解决单例 Bean 的属性注入循环依赖:singletonObjects(成品 Bean)、earlySingletonObjects(半成品 Bean,提前暴露)、singletonFactories(Bean 工厂,用于生成早期引用)。A 依赖 B、B 依赖 A 时:A 实例化后放入三级缓存 → 填充属性发现需要 B → B 实例化后填充属性发现需要 A → 从三级缓存获取 A 的早期引用 → B 创建完成 → A 填充 B 完成。
追问:为什么构造器注入无法解决循环依赖?
回答:
构造器注入在实例化阶段就需要依赖,此时 Bean 还没创建出来(连半成品都没有),三级缓存中没有早期引用可以暴露。解决方案:(1) 改用 setter/字段注入;(2) 用 @Lazy 延迟加载其中一个依赖(注入代理对象,首次使用时才真正创建)。Spring Boot 2.6+ 默认禁止循环依赖(spring.main.allow-circular-references=false)。
Tips: 能提到三级缓存的名称和 Spring Boot 2.6 默认禁止循环依赖。
标准回答:
常见失效场景:(1) 同类内部方法调用(self-invocation,未经过代理对象);(2) 方法非 public(Spring AOP 只代理 public 方法);(3) 异常被 catch 吞掉未抛出;(4) 抛出 checked 异常但未配置 rollbackFor;(5) 数据库引擎不支持事务(MyISAM);(6) 传播行为配置不当(NOT_SUPPORTED/NEVER)。
追问:为什么同类内部调用会导致事务失效?如何解决?
回答:
因为 @Transactional 基于 AOP 代理,内部调用走的是 this 而非代理对象,不经过切面增强。解决方案:(1) 注入自身(@Autowired 注入自己,Spring 通过三级缓存支持);(2) 使用 AopContext.currentProxy() 获取当前代理对象(需 @EnableAspectJAutoProxy(exposeProxy=true));(3) 将方法拆分到不同的 Service 类中(推荐)。
// 方案1:注入自身
@Service
public class OrderService {
@Autowired
private OrderService self; // 注入自身代理
public void createOrder(Order order) {
orderMapper.insert(order);
self.deductStock(order); // 走代理,事务生效
}
@Transactional(rollbackFor = Exception.class)
public void deductStock(Order order) {
stockMapper.deduct(order.getSkuId(), order.getQty());
}
}
Tips: "同类内部调用失效" 是最高频的 @Transactional 失效场景,必须掌握。
| 考察方向 | 题号 | 核心关键词 |
|---|---|---|
| Spring核心 | Q01, Q02, Q03, Q19, Q20 | Bean生命周期、AOP、自动配置、循环依赖、事务失效 |
| Spring事务 | Q04, Q20 | 传播行为、失效场景 |
| Redis | Q05, Q06 | 数据结构、跳表、RDB/AOF |
| MySQL | Q07, Q08 | B+树、MVCC、ReadView |
| 消息队列 | Q09, Q10 | RabbitMQ可靠性、Kafka顺序性 |
| 微服务 | Q11, Q12, Q13 | Nacos、Sentinel、Gateway |
| 容器化 | Q14, Q15 | Docker分层、K8s Pod |
| 数据层 | Q16, Q17 | ES倒排索引、MyBatis缓存 |
| 事件驱动 | Q18 | Spring Event vs MQ |