企业官网建设流程全解析

距离面试还有两周，Java 八股文背了又忘，场景题一开口就乱，Spring 源码翻了几页就犯困。如果你正处于这个状态，这篇文章就是为你准备的。

2026 年的 Java（AI）岗位面试，早就不是“背几篇面经就能过”的时代，但也不是非要啃完整本《深入理解 Java 虚拟机》才敢上场。这里说“邪修版”，并不是鼓励走捷径、抄答案，而是指在时间极度有限的情况下，放弃面面俱到的系统学习，改用“面试命中率优先”的精准打法：把最高频的考点压缩成答题框架，把场景题变成可套用的分析模板，把项目经验整理成能讲清楚、有数据支撑的故事。

这篇文章适合谁？准备 Java 后端岗、Java AI 应用岗面试，但时间已经非常紧张；八股文背了不少，遇到场景题不会组织语言；有项目经验，但不知道如何把并发、JVM、MySQL、Spring 的知识点串联进项目讲解。下面我会按面试考察权重，依次拆解 Java 基础、并发编程、JVM、MySQL、Spring 五条主线，每条主线都给出核心结论、答题模板和速记方式，最后补充 AI 岗位的额外准备和场景题方法论。

1. “邪修版”突击思路到底是什么

1.1 先看清面试考察的本质

面试官在 40 到 60 分钟里，真正想判断的只有三件事：基础扎不扎实、有没有真实项目经验、能不能顺畅沟通协作。

基础扎实，不是说要求你把每本经典书从头背到尾，而是要求你对高频核心知识点有准确、有条理的理解。比如 JVM，面试官大概率不会问你某个垃圾回收器源码里默认参数是多少，而是问“线上 OOM 怎么排查”“G1 和 CMS 有什么区别”。这类问题考的是知识框架和排查思路，不是记忆精度。

项目经验，考察的是你能否把做过的事情讲清楚：背景、方案、难点、量化结果。很多候选人项目其实做得不错，但一开口就变成流水账，“我做了个商城系统，里面有订单模块，用了 Redis 缓存”，这样的描述等于没有描述。真正有效的表述是：“订单模块在高峰期 QPS 达到 500，原先每次查询都打数据库，平均耗时 120ms，后来引入 Redis 缓存热点数据，命中率约 85%，接口平均耗时降到 20ms。”有数字、有对比、有方案，面试官才能继续追问。

沟通协作能力，在技术面试里体现为：面对不会的问题时，你是当场懵掉，还是能说出自己的分析思路；面对场景题时，你是上来就写方案，还是先确认边界条件再给结论。这两点直接决定了你的技术上限能否被面试官感知到。

1.2 突击期时间分配策略

假设你只有 14 天，每天能投入 4 小时，总时间约 56 小时。这个量不可能系统学完八本书，但足够把面试命中率拉到比较高的水平。

建议按下面的比例分配：

这个比例不是绝对的。如果你项目里 MySQL 用得多，可以压缩 Spring 时间补给 MySQL；如果你面的是 AI 应用岗，还要额外留出时间了解 Spring AI、大模型 API 集成等方向。核心原则只有一个：把时间花在“面试官一定会问”的内容上，而不是花在“你觉得很有意思”的内容上。

1.3 八股文、场景题、项目的权重怎么排

从近两年面试反馈来看：纯八股文的价值在下降，场景题和项目深挖的比例明显上升。一面还在问“HashMap 底层结构”“synchronized 和 ReentrantLock 的区别”，但二面和三面几乎全是场景题和项目追问。

所以“邪修版”的策略是：

• 八股文：用最短时间背熟结论和关键参数，不求源码级理解，但必须能用自己的话讲出来。
• 场景题：掌握几个万能分析框架，遇到新题能套用。比如限流、缓存、异步、分布式锁，这些场景反复出现。
• 项目：准备两个拿得出手的模块，每个模块能讲 5 分钟以上，并且能应对追问。

把这三块串起来，比单背八股文要有效得多。后面每个章节，我都会按照“结论 + 示例 + 怎么答”的结构来写，你拿到之后可以直接背、直接练。

2. Java 基础：高频考点与答题模板

2.1 JDK、JRE、JVM 的区别这样答

这几乎是 Java 面试的第一题，也是最容易答得啰嗦的一题。很多候选人说了一大堆，面试官只记住了“JVM 是虚拟机”。合格的回答应该分三层：先给整体关系，再给各自职责，最后落到“为什么需要这样分层”。

JDK（Java Development Kit）是 Java 开发工具包，包含 JRE、编译器 javac、诊断工具 jps/jmap/jstack 等，面向开发者。

JRE（Java Runtime Environment）是 Java 运行时环境，包含 JVM 和 Java 核心类库，面向运行 Java 程序的用户，不包含开发工具。

JVM（Java Virtual Machine）是 Java 虚拟机，负责把字节码翻译成机器码并执行，是 Java“一次编写，到处运行”的关键。

推荐答题模板：“JDK 是开发环境，JRE 是运行环境，JVM 是 JRE 的核心。我们平时写代码用的 javac 命令来自 JDK，编译后生成 class 字节码，最后由 JVM 解释或编译执行。所以只跑程序装 JRE 就行，要开发就必须装 JDK。”这里还可以补一句：“HotSpot 是 Oracle JDK 默认的虚拟机实现，但 JVM 本身是一套规范，除了 HotSpot 还有 OpenJ9 等实现。”这句话能体现你理解的是规范而不是某个具体产品。

2.2 面向对象三大特性怎么答才不啰嗦

封装、继承、多态，每个人都能说出名词，但面试官想听的是“你如何在代码里体现它”。

封装，是把数据和操作数据的方法包装在一起，对外隐藏内部实现，只暴露必要的接口。举例：一个 UserService 内部用 Redis 缓存用户信息，外部调用方不需要知道缓存逻辑，只需要调 getUserById 方法。这样做的好处是降低耦合、便于修改。

继承，是子类复用父类的属性和方法，Java 只支持单继承，但可以通过接口实现多类型能力。要注意的是，面试官经常追问：“继承和组合怎么选？”规范答案是优先使用组合，因为继承会暴露父类实现细节，父类一改子类就崩，组合则更灵活。

多态，是同一个行为在不同对象上有不同表现。Java 多态靠继承、接口实现和动态绑定完成。推荐用一个简单例子说明：

// 文件路径：com/example/demo/DemoMain.java public class DemoMain { public static void main(String[] args) { Animal animal = new Dog(); animal.speak(); // 输出：汪汪 } } class Animal { public void speak() { System.out.println("动物叫"); } } class Dog extends Animal { @Override public void speak() { System.out.println("汪汪"); } }

这段代码里，animal 的静态类型是 Animal，实际对象是 Dog，运行时调用的是 Dog 的 speak 方法，这就是动态绑定。答题时把这段逻辑说清楚，比背“多态分为编译时多态和运行时多态”更有说服力。

2.3 集合框架必背结论

集合是 Java 基础的必考内容，面试官最常问的集中在 HashMap、ArrayList、LinkedList 三个上面。

HashMap 的高频考点包括：底层是数组加链表加红黑树，JDK 1.8 之后链表长度超过 8 且数组长度大于等于 64 时转红黑树；默认初始容量 16，加载因子 0.75；put 流程是计算 hash、定位桶、判断是否冲突、判断是否扩容；线程不安全，多线程环境可能出现数据覆盖或死循环。

ArrayList 和 LinkedList 的区别也是高频题。ArrayList 底层是动态数组，随机访问快，增删慢；LinkedList 底层是双向链表，增删快，随机访问慢。但实际工作中，LinkedList 的使用频率远低于 ArrayList，因为大多数场景是“尾部追加 + 按索引遍历”，ArrayList 的缓存局部性和内存占用都更好。这一点可以作为加分项说出来。

String 相关的问题也要准备：String 是不可变类，StringBuffer 线程安全，StringBuilder 线程不安全但性能更好。字符串拼接在循环里不要用 +，要使用 StringBuilder，这是最常见的扣分点之一。

// 正确示例：循环拼接使用 StringBuilder StringBuilder sb = new StringBuilder(); for (int i = 0; i < 1000; i++) { sb.append(i); } String result = sb.toString();

3. 并发编程：从八股到场景题

3.1 线程池参数和拒绝策略必须背熟

并发编程里线程池是最高频考点，没有之一。面试官会直接问：“线程池有哪些参数？执行流程是什么样的？拒绝策略有哪些？”这三个问题必须一气呵成答完。

线程池核心参数有七个：corePoolSize 核心线程数、maximumPoolSize 最大线程数、keepAliveTime 非核心线程空闲存活时间、unit 时间单位、workQueue 任务队列、threadFactory 线程工厂、handler 拒绝策略。

执行流程是：提交任务后，先判断核心线程是否已满，未满则创建核心线程执行；已满则放入任务队列；队列也满了，再创建非核心线程执行；线程数达到 maximumPoolSize 仍然处理不过来，触发拒绝策略。这个流程可以用下面这段代码加深理解：

// 文件路径：com/example/demo/ThreadPoolDemo.java import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class ThreadPoolDemo { public static void main(String[] args) { ThreadPoolExecutor executor = new ThreadPoolExecutor( 2, // 核心线程数 5, // 最大线程数 60L, // 空闲存活时间 TimeUnit.SECONDS, // 时间单位 new ArrayBlockingQueue<>(10), // 任务队列 new ThreadPoolExecutor.AbortPolicy() // 拒绝策略 ); for (int i = 0; i < 20; i++) { int taskId = i; executor.execute(() -> { System.out.println(Thread.currentThread().getName() + " 执行任务 " + taskId); }); } executor.shutdown(); } }

这里 2 个核心线程加 10 个队列容量，前 12 个任务不会触发额外线程，第 13 到第 15 个任务会创建非核心线程，超过 15 个后触发拒绝策略，默认策略是抛异常。这个数字关系的推演过程，面试官非常喜欢听。

四种拒绝策略分别是：AbortPolicy 直接抛异常、CallerRunsPolicy 让提交任务的线程自己跑、DiscardPolicy 直接丢弃、DiscardOldestPolicy 丢弃队列里最旧的任务再提交。实际项目中更多用 CallerRunsPolicy，因为它能起到天然限流的作用：任务太多时，由业务线程自己执行，业务线程被占满后，新任务自然提交不进来。

3.2 synchronized 和 ReentrantLock 对比

这道题几乎每场必考。标准回答可以从四个维度展开：语法层面、锁特性、公平性、可中断性。

语法层面，synchronized 是 JVM 内置关键字，自动释放锁；ReentrantLock 是 JUC 包里的类，必须手动加锁和释放锁，通常配合 finally 使用。

锁特性，synchronized 在 JDK 1.6 之后引入了偏向锁、轻量级锁、重量级锁的升级过程；ReentrantLock 则基于 AQS 实现，支持公平锁和非公平锁，支持超时获取锁，支持多个 Condition 条件队列。

灵活性，ReentrantLock 可以尝试获取锁，比如 lock.tryLock(3, TimeUnit.SECONDS)，拿不到锁就做其他处理；synchronized 做不到。

// 文件路径：com/example/demo/LockDemo.java import java.util.concurrent.locks.ReentrantLock; public class LockDemo { private static final ReentrantLock lock = new ReentrantLock(); public static void main(String[] args) { boolean acquired = false; try { acquired = lock.tryLock(3, TimeUnit.SECONDS); if (acquired) { System.out.println("获取锁成功，执行业务逻辑"); } else { System.out.println("获取锁超时，降级处理"); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { if (acquired) { lock.unlock(); } } } }

注意 TimeUnit 需要导入，写全 import java.util.concurrent.TimeUnit。这段代码展示的是超时获取锁和 finally 中释放锁的规范写法，能体现你对并发安全细节的把握。

3.3 volatile 和可见性

volatile 是并发编程里的高频小题，但它经常和 synchronized 混在一起问。关键结论是：volatile 保证可见性和禁止指令重排，但不保证原子性。

可见性是指一个线程修改了共享变量，其他线程能立即看到。底层原理是 volatile 变量写操作会插入内存屏障，强制把工作内存中的新值刷回主内存。不保证原子性，最经典的例子就是 i++，它实际是“读取、加一、写回”三步，volatile 只能保证每次读到的值是最新的，但不能保证这三步不被其他线程打断。

面试官常会追问：“那怎么解决原子性问题？”答案是使用 AtomicInteger 或者加锁。

import java.util.concurrent.atomic.AtomicInteger; public class AtomicDemo { private static final AtomicInteger count = new AtomicInteger(0); public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 0; i < 5000; i++) { count.incrementAndGet(); } }); Thread t2 = new Thread(() -> { for (int i = 0; i < 5000; i++) { count.incrementAndGet(); } }); t1.start(); t2.start(); t1.join(); t2.join(); System.out.println(count.get()); // 输出 10000 } }

这段代码用 AtomicInteger 保证多线程累加结果正确。面试时先答 volatile 的原理，再补一句“原子性要靠 synchronized、Lock 或 Atomic 类解决”，基本就能过关。

3.4 场景题：设计一个异步任务批量处理组件

场景题是二面三面的主力题型，下面这个是并发章节最常见的场景之一：“系统每天有大量异步任务需要处理，如何处理？如果任务量突增怎么办？”

推荐按“需求分析、方案设计、容错降级、监控告警”四步答。

需求分析：要明确任务的来源、量级、实时性要求。是用户请求触发的即时任务，还是定时批量任务？峰值 QPS 是多少？允许的最大延迟是多少？

方案设计：用线程池处理异步任务，核心线程数和最大线程数根据任务类型配置。如果是 IO 密集型任务，线程数可以设为 CPU 核数的两倍左右；如果是 CPU 密集型，设为 CPU 核数加一。任务队列使用有界队列，避免无限堆积导致 OOM。

容错降级：任务执行失败要有重试机制，重试次数用有上限的计数，超过则进入死信队列或者记录日志告警。任务量突增导致线程池和队列都满时，触发拒绝策略，优先选择 CallerRunsPolicy 或自定义策略。

监控告警：线程池的活跃线程数、队列积压量、任务执行失败率都要暴露指标，接入监控系统。用 Micrometer 或 Spring Boot Actuator 都可以实现。

这样答下来，即使你没有真正做过这套系统，面试官也能看到你具备完整的系统设计思维。这也是“邪修版”方法论里最重要的能力：把零散知识点组织成一个可执行的方案。

4. JVM：内存模型与调优面试要点

4.1 运行时数据区怎么讲才清晰

JVM 内存模型是 JVM 面试的基座。推荐从“线程私有 vs 线程共享”两个维度切入。

线程私有的部分包括程序计数器、虚拟机栈、本地方法栈。程序计数器记录当前线程执行的字节码行号，是唯一不会 OOM 的区域；虚拟机栈保存栈帧，每个方法调用对应一个栈帧，栈帧里有局部变量表、操作数栈、动态链接、方法出口，递归过深会抛出 StackOverflowError；本地方法栈服务于 native 方法。

线程共享的部分包括堆和方法区。堆是对象实例分配的主要区域，也是垃圾回收的主要区域，可以细分为新生代和老年代；方法区在 JDK 8 之后改名为元空间，存储在 JVM 之外的本机内存，主要存放类元信息、常量、静态变量等。

答题时可以主动画一张表帮助自己组织语言：

这张表一列出来，再配合“JDK 8 之前方法区叫永久代，之后改为元空间”这个细节，就能覆盖 80% 的 JVM 内存基础题。

4.2 垃圾回收器与 G1 的考点

垃圾回收的问题，面试官更关注你对“分代回收”和“G1 原理”的理解。

新生代垃圾回收使用复制算法，对象在 Eden 区分配，Minor GC 后存活对象挪到 Survivor 区，经历一定次数后晋升老年代。老年代使用标记整理或标记清除算法，触发 Major GC 或 Full GC。

G1 是 JDK 9 之后的默认垃圾回收器，它的核心设计是把堆划分为多个大小相等的 Region，每个 Region 可以动态扮演 Eden、Survivor、Old 的角色。G1 能通过记录每个 Region 的垃圾回收收益，优先回收垃圾最多的 Region，所以可以在最大停顿时间内完成回收。G1 引入了 Remembered Set 来记录跨 Region 引用，回收时只需要扫描相关 Region，减少了全堆扫描开销。

常见追问是“G1 和 CMS 有什么区别”。保守的回答是：CMS 基于标记清除，会产生内存碎片，需要配置碎片整理；G1 基于 Region 和复制算法，从整体上看有助于减少碎片，且停顿时间更可控。如果你简历里没有写深入调优经验，就不要编造具体参数，如实说“G1 适合大堆、对停顿时间有要求的场景”就够了。

4.3 线上 OOM 排查思路

OOM 排查是 JVM 面试的压轴题，也是场景题的高频来源。先把排查步骤背下来，再配合命令熟练度，就能答出彩。

第一步，拿到堆转储文件。启动参数中加上 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/data/logs/app.hprof，发生 OOM 时自动生成 dump 文件。如果服务已经崩溃，可以用 jmap -dump:format=b,file=app.hprof 手动导出。

第二步，用 MAT 或 VisualVM 分析 dump。重点看支配树里占用内存最大的对象，判断是对象太多、集合没有释放、还是缓存无上限。

第三步，结合业务代码定位。比如一次查询把全表数据加载到内存，或者用静态 Map 做缓存但从不清理，都会导致堆内存不断增长。

第四步，修复并验证。修复后放到测试环境模拟流量，观察内存曲线是否恢复平稳。生产环境任何变更都要走审批和灰度流程，不能直接动线上。

# 查看 Java 进程 jps -l # 查看堆内存使用情况 jmap -heap <pid> # 导出堆转储文件，需要授权并在低峰期操作 jmap -dump:format=b,file=/tmp/app.hprof <pid>

注意：jmap 导出堆转储会触发 Full GC 并暂停应用，生产环境务必谨慎，最好在低峰期执行。这句话一定要说，面试官会认为你有生产意识。

4.4 类加载机制速记

类加载机制在 JVM 面试里出现频率也不低。核心考点是双亲委派模型。

当一个类加载请求到达时，子加载器不会自己先加载，而是把请求委托给父加载器，逐层向上，最终由引导类加载器尝试加载。只有父加载器无法加载时，子加载器才自己加载。这样做的好处是保证 Java 核心类的安全性，比如 java.lang.String 始终由引导类加载器加载，避免用户自定义的 String 类覆盖核心类。

常见追问是“双亲委派模型怎么打破”。典型场景是 Tomcat 的 WebAppClassLoader，它为了实现 Web 应用之间的类隔离，会优先加载应用自身的类。回答时提到 SPI 机制（如 JDBC DriverManager）也是打破双亲委派的典型场景即可，不需要深入源码。

5. MySQL：索引、事务、锁的高频考点

5.1 索引失效场景必须避坑

MySQL 索引是数据库面试的核心，而“索引失效场景”几乎是必考题。先把最常见的失效场景列出来：

• 对索引列使用函数或计算，例如 WHERE YEAR(create_time) = 2026，会让索引失效，应改成范围查询。
• 隐式类型转换，例如索引列是 varchar，查询条件传入数字。
• 最左前缀原则不满足，联合索引 (a, b, c) 查询条件没有带上 a。
• 使用 LIKE 且通配符在开头，例如 LIKE '%abc'。
• 使用 OR 连接非索引列条件。

拿最典型的联合索引举例：

-- 假设已经创建联合索引 idx_user_name_age (name, age) -- 索引生效 SELECT * FROM user WHERE name = 'zhangsan' AND age = 25; -- 索引生效，但只用到了 name 列 SELECT * FROM user WHERE name = 'zhangsan'; -- 索引失效：跳过了 name 列，只查 age SELECT * FROM user WHERE age = 25;

答完失效场景后，主动补一句“用 EXPLAIN 看执行计划，type 字段如果是 ALL 说明全表扫描，key 字段为 NULL 说明索引没用上”，会明显加分。

EXPLAIN SELECT * FROM user WHERE age = 25;

5.2 事务隔离级别与 MVCC

MySQL 事务题最常考的是隔离级别和 MVCC。InnoDB 默认隔离级别是可重复读，四个级别分别是读未提交、读已提交、可重复读、串行化。隔离级别越高，并发能力越低。

MVCC（多版本并发控制）是 InnoDB 实现读己提交和可重复读的核心机制。每一行记录有隐藏列 trx_id 和 roll_pointer，分别记录最后修改它的事务 ID 和回滚段指针。普通读（快照读）通过 ReadView 判断哪些版本可见，可重复读模式下 ReadView 在事务第一次查询时生成，整个事务期间复用；读己提交模式下每次查询都生成新的 ReadView。这就是为什么可重复读能解决不可重复读，却仍然无法解决幻读——在快照读下看不到新插入的行，但当前读（SELECT ... FOR UPDATE）仍可能读到新行。

间隙锁和 next-key lock 也是高频考点。可重复读级别下，InnoDB 默认使用 next-key lock 来解决当前读的幻读问题，它锁住的不只是记录本身，还包括记录前面的间隙。回答时可以提一句，这也是为什么可重复读级别下并发插入容易死锁，建议在业务允许时评估是否降低隔离级别。

5.3 死锁场景题：怎么分析、怎么解决

死锁是 MySQL 场景题的高频方向。面试官会问：“系统突然出现大量死锁，怎么排查？怎么解决？”

排查思路按下面几步走：

第一步，查看死锁日志。执行 SHOW ENGINE INNODB STATUS，关注 LATEST DETECTED DEADLOCK 部分，里面会明确写出两个事务分别持有哪些锁、等待哪些锁。

第二步，分析事务里的 SQL 执行顺序。最常见的原因是两个事务以不同顺序更新多张表，比如事务 A 先更新 order 再更新 user，事务 B 先更新 user 再更新 order，互相持有对方的下一把锁。

第三步，修复。最直接的方案是让所有事务都按照相同的顺序访问资源，比如统一先更新 user 再更新 order；其次是缩短事务时间，减少锁持有时间；再次是评估是否需要降低隔离级别，或者缩小锁范围。

SHOW ENGINE INNODB STATUS;

生产环境排查死锁需要授权，且不要把日志直接贴到公开文档里，脱敏后再处理。

5.4 SQL 优化实战

SQL 优化题不需要背太多古法，要形成一个“先看执行计划、再对症下药”的思路。

常见优化手段包括：避免 SELECT *，只查需要的列；为 WHERE 条件和 ORDER BY 字段建立合适索引；分页查询深度较大时，用延迟关联优化；避免在索引列上做函数运算；大批量更新或删除时，分批执行，避免一次锁太多行。

举个例子，订单表深度分页查询：

-- 慢查询写法：offset 越大越慢 SELECT * FROM order_info ORDER BY id LIMIT 100000, 20; -- 延迟关联优化：先在索引上定位起始 id，再回表取数据 SELECT o.* FROM order_info o INNER JOIN ( SELECT id FROM order_info ORDER BY id LIMIT 100000, 20 ) tmp ON o.id = tmp.id ORDER BY o.id;

把优化思路讲清楚比背几十条优化口诀更重要。面试官追问“为什么这样快”时，答“子查询只扫了主键索引，回表次数大幅减少”即可。

6. Spring：三级缓存与核心原理

6.1 Bean 生命周期速记

Spring 相关面试题中，Bean 生命周期是绕不开的基础题。不需要从源码逐行讲，但要把关键节点按顺序说出来：实例化、属性填充、初始化、销毁。

具体流程是：Spring 通过反射创建 Bean 实例，然后进行属性填充（依赖注入就在这里完成），接着执行 Aware 回调（例如 BeanNameAware、ApplicationContextAware），再经过 BeanPostProcessor 的前置处理，执行 InitializingBean 接口或 @PostConstruct 方法，再经过 BeanPostProcessor 的后置处理，最终完成 AOP 代理的创建。销毁时，如果实现了 DisposableBean 或配置了 destroy-method，会执行销毁回调。

答题时记住这个口诀：“实例化、注入、Aware、前置、初始化、后置、销毁”，每个节点展开一两句就够了。

6.2 三级缓存如何解决循环依赖

Spring 循环依赖问题属于高频中的高频，几乎逢面必问。先交代背景：如果 A 依赖 B，B 又依赖 A，Spring 如何在不报错的情况下完成创建？

Spring 使用三级缓存来解决单例 setter 注入的循环依赖。三级缓存分别是：

• 一级缓存 singletonObjects：存放完整的、已经初始化完成的单例 Bean。
• 二级缓存 earlySingletonObjects：存放提前暴露的、尚未完成属性填充的早期对象。
• 三级缓存 singletonFactories：存放对象工厂，能在需要时生成早期对象。

关键流程是这样的：创建 A 时，把 A 的工厂放入三级缓存，然后给 A 填充属性，发现需要 B，转去创建 B；创建 B 时，B 填充属性发现需要 A，此时 A 还没创建完，但三级缓存里有 A 的工厂，取出工厂生成 A 的早期对象放入二级缓存，B 拿到 A 的早期引用完成注入；B 创建完成后，A 继续完成后续步骤，最终 A 也完成创建，进入一级缓存。

这里有个非常重要的限制：三级缓存只能解决 setter 注入的循环依赖，不能解决构造器注入的循环依赖，也不能解决 @Async 代理对象的循环依赖。因为构造器注入要求 Bean 在未创建早期对象前就拿到完整对象，而 @Async 会生成代理对象，三级缓存中的早期对象不是最终代理，获取的代理和最终 Bean 不一致。

6.3 Spring 事务失效场景

Spring 事务失效是高频实际场景题。直接把常见的失效原因背下来，再结合自身项目举例。

第一，方法不是 public。Spring 默认基于 JDK 动态代理或 CGLIB 代理，private、final 方法无法被代理增强，事务注解不起作用。

第二，类内部调用。同一个类里，方法 A 调方法 B，B 上有 @Transactional，但 B 是通过 this 调用的，没有经过代理对象，事务失效。解决办法是注入自身代理或把 B 方法放到另一个 Bean 里。

第三，异常被捕获。方法内 try-catch 吞掉了异常，事务感知不到，不会回滚。需要抛出 RuntimeException 或在注解里指定 rollbackFor。

第四，抛出的异常不是 RuntimeException。默认情况下，只有 RuntimeException 和 Error 会触发回滚，受检异常不会。需要显式设置 rollbackFor = Exception.class。

// 正确的写法：指定回滚异常类型 @Transactional(rollbackFor = Exception.class) public void transfer(String from, String to, BigDecimal amount) { accountMapper.decrease(from, amount); accountMapper.increase(to, amount); }

6.4 Spring Boot 自动配置原理

Spring Boot 自动配置原理是高级开发者面试里比较常见的内容。核心机制是 @SpringBootApplication 注解组合了 @EnableAutoConfiguration，而这个注解通过 @Import 引入了 AutoConfigurationImportSelector，它会扫描 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件，加载所有自动配置类。

自动配置类通常带有 @ConditionalOnClass、@ConditionalOnMissingBean、@ConditionalOnProperty 等条件注解，只有满足条件时才生效。比如 RedisAutoConfiguration 只有在 classpath 下存在 RedisConnectionFactory 类时才会生效，而且用户自己配置了 RedisTemplate 时，自动配置会退让，避免覆盖用户定义。

答题时强调“约定大于配置”和“条件装配”这两个词，再配合“数据源、Redis、线程池都是通过这种方式自动装配的”举例，基本就能过关。

7. AI 岗位 Java 面试的额外准备

7.1 AI 岗位到底考什么

2026 年的 Java AI 岗位，面试考察范围通常是“Java 基础 + 后端能力 + AI 应用认知”的组合。Java 基础、并发、JVM、MySQL、Spring 这些是底层盘，AI 相关的内容更多集中在应用层：如何把大模型能力接入业务系统，如何设计 RAG 流程，如何处理流式输出，如何管理上下文长度。

如果招聘 JD 里明确写了“了解 Spring AI 优先”，那么你需要花少量时间了解 Spring AI、Spring AI Alibaba 这类框架的基本概念和启动方式。不要把精力浪费在训练大模型上，那不是 Java 岗的核心职责。

7.2 如何把 AI 能力写进项目经验

如果你没有 AI 项目经验，可以从技术调研和 Demo 入手，在简历里体现“你有快速上手 AI 开发的能力”。例如，你可以写：“基于 Spring AI 集成了大模型对话接口，实现流式输出和上下文管理，调研对比了直连 HTTP 调用和框架封装的差异。”这属于真实可验证的经历，面试官追问时你也能讲清楚。

有条件的同学可以自己实现一个简单的 RAG Demo：用 Embedding 模型把文档向量化，存入向量数据库，用户提问时先检索相关文档片段，再拼接 Prompt 交给大模型生成回答。这个流程很经典，也容易在面试中展开。

// 伪代码示例：RAG 检索 + 大模型生成的基本流程 // 1. 把用户问题转为向量 // List<Float> questionVector = embeddingModel.embed(question); // 2. 在向量数据库中检索相似片段 // List<Document> docs = vectorStore.similaritySearch(questionVector, 5); // 3. 拼接上下文，调用大模型生成回答 // String prompt = buildPrompt(question, docs); // String answer = chatClient.call(prompt);

伪代码展示的是思路，具体 API 需要根据你实际使用的框架版本调整。面试中能画出这个流程图、说出每一步的输入输出，就已经领先大多数候选人。

7.3 AI 项目里 Java 开发者的优势

Java 开发者在大模型应用开发中并不是劣势，反而有稳定优势：Java 生态具备成熟的高并发处理、事务管理、消息队列、监控告警能力。大模型接口的响应时间普遍较长，通常在几秒到几十秒，如何不阻塞业务线程、如何做超时控制、如何做流式响应，正是 Java 并发和后端能力的用武之地。

比如调用大模型接口需要控制并发数，避免打爆上游限流；需要设置合理的超时时间，避免用户长时间等待；需要把大模型产生的流式数据封装成 SSE（Server-Sent Events）推送给前端。这些技能点正好可以把并发、HTTP、Spring MVC 的知识串起来，建议在自我介绍时就主动展示。

8. 场景题答题方法论

8.1 先确认边界条件，再给方案

场景题最容易翻车的不是方案不对，而是条件没确认就开始答。举一个例子：“如何设计一个秒杀系统？”如果你上来就写 Redis 扣减库存，面试官很可能会追问：库存量多少？并发量多少？允许超卖吗？所以标准做法是先问清楚需求边界。

推荐的回答模板是：“我先确认几个关键点：第一，预估峰值 QPS 是多少；第二，库存量级是多少；第三，是否允许超卖；第四，对响应时间的要求。确认之后，我再给方案。”这段话一说完，面试官就会觉得你具备系统设计的基本素养。

8.2 三个万能场景题模板

模板一：缓存类问题。凡是涉及缓存穿透、缓存击穿、缓存雪崩的题目，都按“原因 + 解决方案 + 落地注意点”展开。

• 缓存穿透：查询不存在的数据，大量请求打到数据库。方案是缓存空值、布隆过滤器。
• 缓存击穿：热点 key 失效瞬间，大量请求打到数据库。方案是互斥锁、逻辑过期。
• 缓存雪崩：大量 key 同时失效，导致数据库压力陡增。方案是过期时间加随机值、多级缓存、限流降级。

模板二：接口性能优化类。凡是“某个接口很慢，怎么优化”的题目，都按“先定位、后优化”展开。定位手段是链路追踪、慢查询日志、JVM 监控，优化手段是 SQL 索引、缓存、异步化、批量处理。

模板三：分布式一致性类。凡是“多节点数据不一致怎么办”的题目，都先区分是缓存一致性还是数据库一致性，再给方案。缓存一致性可以用 Cache Aside Pattern，先更新数据库再删除缓存；数据库一致性考虑分布式事务，常用最终一致性方案。

8.3 遇到不会的题怎么答

面试中遇到完全不会的题太正常了，关键是不能沉默。推荐三步走：

第一步，复述问题，确认自己理解正确。“你说的这个方案，我理解是……对吗？”

第二步，拆解问题，说能想到的部分。例如问“你知道 Seata 的 AT 模式原理吗？”如果你只知道大概，可以答：“我了解 Seata 是分布式事务框架，AT 模式通过全局事务管理器协调各分支事务，具体是通过事务日志实现补偿回滚。细节我不是很熟，但我知道它是基于数据库本地事务和全局锁实现的。”即使说错，也比沉默好。

第三步，诚实说明盲区，并给出学习路径。“这块我确实没有落地经验，面完我会去补充。如果候选人角度出发，我理解它和 TCC 的核心区别是……”这套话术既能保住基本盘，又不会让面试官觉得你在硬编。

9. 突击期常见问题与避坑清单

9.1 为什么背了很多八股文，还是挂面试

很多人挂在同一个问题上：背的东西和说的是两套语言。八股文背的是书面语，面试要求的是口语化表达。解决方案只有一个：把每个面试题自己复述一遍，录音下来，听听自己的表达是否流畅。不要对着文档背，要对着空气讲。

另一个常见问题是只背不用。面试官问“线程池参数”时，他后面一定会跟一句“你项目里线程池怎么配的”。如果你只背了参数定义，说不出项目中核心线程数为什么是 4、队列为什么是 1000，这题基本就减分了。所以每个知识点都要准备一个“项目关联”说明。

9.2 突击期避坑清单

9.3 模拟面试怎么练最有效

模拟面试不需要找多高的高手，核心是“说出口”。找一个朋友或同学，让他从你整理的面试题清单里随机抽题，你来回答。每题控制在 3 到 5 分钟，回答后让提问者扮演面试官，追问一个细节。这个过程能暴露出大部分表达问题。

另一个方法是录视频复盘。看回放时重点关注三件事：有没有说口头禅、语速是不是过快、回答结构是不是清晰。建议每天至少做一轮 30 分钟的模拟面试，坚持一周，表达水平会有明显变化。

10. 学习路线与最后冲刺建议

10.1 两周冲刺主线表

如果你现在只剩两周，建议按下面的主线推进：

• 第一周前三天：Java 基础 + 集合 + 并发基础，把线程池、锁、volatile 全部过一遍。
• 第一周后四天：JVM 内存模型 + MySQL 索引事务锁 + Spring 核心原理，搭配场景题模板。
• 第二周前三天：项目梳理 + AI 方向补充 + 场景题专项训练。
• 第二周后四天：模拟面试 + 查漏补缺 + 高频题复述。

每天睡前用 20 分钟复盘当天学过的题目，第二天早上用 10 分钟快速过一遍。记忆曲线是客观存在的，突击期更要靠重复来对抗遗忘。

10.2 面试当天和面试后的动作

面试当天不要新学内容，只复习自己的笔记和高频题清单。出发前检查网络、设备、环境，线上面试提前 15 分钟进入会议室调试声音和摄像头。

面试后无论结果如何，当天晚上必须复盘。把没答出来的题写下来，搜索答案，整理进自己的笔记。这些整理出来的内容，比任何面经都更贴合你的弱点，是下一轮面试最有价值的弹药。

10.3 最后一个提醒

“邪修版”突击是为了解决眼前的时间问题，但它不应该是终点。八股文帮你通过面试，真正让你留下来的，是理解原理、写干净代码、能排查线上问题的能力。面试通过之后，建议回头把本文里提到的知识点按系统方式再学一遍：JDK 源码可以读 ArrayList、HashMap、ThreadPoolExecutor；JVM 可以读《深入理解 Java 虚拟机》的对应章节；MySQL 可以学 InnoDB 存储引擎内部结构；Spring 可以自己写一个简化版容器来理解 Bean 生命周期。

如果你正在面试冲刺期，现在就把本文里的答题模板复制到自己的文档里，逐个复述，配合手写代码练习。希望这套“邪修版”打法能帮你用最短时间覆盖最多的面试命中点，顺利拿下 2026 年的 Java（AI）岗位 offer。