Java面试30天突击：从八股文到AI大模型应用的全栈攻略

最新推荐文章于 2026-07-19 16:32:46 发布

原创最新推荐文章于 2026-07-19 16:32:46 发布 · 293 阅读

本内容遵循CC 4.0 BY-SA版权协议

最近在帮几位朋友准备 Java 面试，发现大家普遍存在一个误区：面对海量的知识点，不知道从哪里开始，更不知道如何高效串联。特别是现在面试风向变化很快，除了传统的 Java 基础、并发、JVM、MySQL、Spring，还增加了 AI 大模型应用、复杂场景题等新内容，让很多同学感到焦虑。

本文旨在为你提供一份为期 30 天的系统性突击计划。这份计划不是简单罗列知识点，而是结合当前企业招聘热点（包括 AI 大模型、场景题、八股文等），为你规划一条清晰、高效的学习路径。无论你是准备校招还是社招，都能从中找到适合自己的节奏和重点，用一个月的时间，构建起稳固的知识体系，从容应对面试挑战。

1. 面试趋势分析与 30 天规划总览

在开始具体学习前，我们必须先看清“战场”。当前的 Java 后端面试，早已不是背几道八股文就能通关的时代了。面试官更倾向于考察候选人的 知识体系完整性 、 问题解决能力 和 技术视野 。

1.1 当前 Java 面试的核心考察维度

根据近期的招聘需求和面试反馈，我们可以将考察点归纳为以下几个层次：

基础功底（必考） ：这是立身之本。包括 Java 核心语法、集合框架、并发编程（JUC）、JVM 内存模型与调优、MySQL 索引与事务、Spring 框架核心原理。这部分内容必须扎实，任何模糊都可能成为被淘汰的理由。
系统设计能力（高频） ：常以“场景题”形式出现。例如：“如何设计一个秒杀系统？”、“微博的关注feed流怎么实现？”、“分布式ID生成方案有哪些？”。这要求你不仅能说出技术名词，更要理解其背后的权衡（Trade-off）。
项目经验与深度（关键区分点） ：面试官会深挖你的项目，问“为什么用这个技术？”、“遇到了什么坑？”、“如果流量增加10倍怎么优化？”。你需要能用 STAR 法则清晰阐述，并展现你的思考深度和技术选型能力。
新技术视野（加分项） ：尤其是 AI 大模型应用开发 相关。越来越多的公司开始探索 AI 赋能业务，面试中可能会问及你对大模型原理（如 Transformer）的粗浅理解、是否了解 LangChain/Spring AI 等开发框架、以及如何将 AI 能力（如 Agent、RAG）集成到现有 Java 后端系统中。这体现了你的学习能力和技术前瞻性。

1.2 30 天突击学习路线图

基于以上分析，我们制定一个分阶段、可执行的 30 天计划。该计划遵循“夯实基础 -> 构建体系 -> 实战模拟 -> 查漏补缺”的节奏。

第一阶段：核心基础巩固（第 1-10 天）
- 目标：确保八股文类问题回答准确、流畅。
- 内容：Java 集合、并发、JVM、MySQL、Spring 核心。
第二阶段：系统设计与项目复盘（第 11-20 天）
- 目标：能够应对系统设计场景题，并深入阐述自己的项目。
- 内容：分布式基础概念、缓存、消息队列、设计模式、项目深度梳理。
第三阶段：新技术拓展与面试实战（第 21-28 天）
- 目标：了解 AI 大模型等前沿技术，并进行全真面试模拟。
- 内容：AI 大模型应用基础、Spring AI 初探、高频场景题串讲、模拟面试。
第四阶段：心态调整与最终复盘（第 29-30 天）
- 目标：调整状态，回顾易错点，准备简历和自我介绍。

接下来，我们将深入每个阶段的核心知识点，并提供具体的学习方法和面试回答要点。

2. 第一阶段：核心八股文深度攻坚（第1-10天）

这个阶段的目标是“无死角”。每天聚焦一个主题，不仅要记住答案，更要理解背后的“为什么”。

2.1 Java 集合框架（第1-2天）

集合是使用最频繁的 API，也是面试的起点。

核心考点：

ArrayList vs LinkedList ：底层数组 vs 双向链表。从时间复杂度（随机访问 O(1)/O(n)，头插 O(n)/O(1)）和内存占用（连续空间 vs 节点开销）分析。
HashMap 原理 ：这是重中之重。必须能画图并详细说明。
- 数据结构 ：JDK 1.8 后是数组+链表/红黑树。
- 哈希计算 ： (h = key.hashCode()) ^ (h >>> 16) 为什么？为了混合高位特征，减少哈希碰撞。
- put 流程 ：计算索引 -> 若桶为空则直接插入 -> 若为链表，遍历并比较 key (先比 hash，再比 == 或 equals ) -> 若找到则覆盖，尾插法新增 -> 链表长度 >= 8 且数组长度 >= 64，树化。
- 扩容机制 ：负载因子（默认0.75），扩容为2倍，重新计算索引 index = (n - 1) & hash 。注意，这是高效取模运算。
- 线程不安全 ：举例说明并发 put 可能导致数据丢失或死循环（JDK 1.7 头插法问题）。
ConcurrentHashMap 如何保证线程安全 ：
- JDK 1.7：分段锁（Segment）。
- JDK 1.8： synchronized 锁桶头节点 + CAS。 size() 方法使用 LongAdder 思想的分段计数。
Iterator 与快速失败（Fail-Fast） ： modCount 机制。使用 CopyOnWriteArrayList 解决遍历时修改的问题。

面试回答示例： 问：HashMap 的负载因子为什么是 0.75？答：这是一个时间和空间的权衡。负载因子过高（比如1.0），虽然空间利用率高，但哈希冲突概率急剧增加，导致链表变长，查询性能下降（趋向O(n)）。负载因子过低（比如0.5），冲突减少，查询快，但空间浪费严重，扩容会更频繁。0.75 是统计学和实验得出的一个较好的平衡点，在理想情况下，链表长度超过8的概率极低。

2.2 Java 并发编程（第3-5天）

并发是区分初中级工程师的关键。

核心考点：

线程状态与生命周期 ：NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED。能通过代码示例说明如何进入这些状态。
synchronized 与 ReentrantLock ：
- synchronized ：JVM 内置锁，自动释放，可重入。优化包括偏向锁、轻量级锁、重量级锁。
- ReentrantLock ：API 级锁，需要手动 lock() / unlock() ，支持公平锁、可中断、超时、条件变量（ Condition ）。
volatile 关键字 ：保证可见性（写操作立即刷新到主内存，读操作从主内存读取），禁止指令重排序。 不保证原子性 （如 i++ ）。
JUC 工具包 ：
- AtomicInteger ：CAS 原理， Unsafe 类。
- CountDownLatch ：一个线程等待多个线程。
- CyclicBarrier ：多个线程互相等待。
- Semaphore ：控制并发访问的线程数。
- ThreadPoolExecutor ： 必须掌握核心参数 （corePoolSize, maximumPoolSize, workQueue, keepAliveTime, handler）。常用队列： LinkedBlockingQueue （无界）、 ArrayBlockingQueue （有界）、 SynchronousQueue （直接交接）。拒绝策略：AbortPolicy, CallerRunsPolicy 等。
AQS（AbstractQueuedSynchronizer） ：并发包的基础。理解其内部 FIFO 队列和 state 状态的管理。 ReentrantLock , Semaphore , CountDownLatch 都是基于 AQS 实现的。

代码示例：线程池创建与使用

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 自定义线程池
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                2, // 核心线程数
                5, // 最大线程数
                60L, TimeUnit.SECONDS, // 空闲线程存活时间
                new ArrayBlockingQueue<>(10), // 任务队列（有界，容量10）
                Executors.defaultThreadFactory(), // 线程工厂
                new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略：由调用者线程执行
        );

        for (int i = 0; i < 20; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " 执行任务 " + taskId);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown(); // 平滑关闭
    }
}

2.3 JVM 与性能调优（第6-7天）

JVM 问题常在线上排查时被问到。

核心考点：

内存区域 ：程序计数器、Java 虚拟机栈、本地方法栈、堆、方法区（元空间）。重点区分堆（对象实例）和方法区（类信息、常量、静态变量）。
垃圾回收算法 ：
- 标记-清除：产生碎片。
- 复制：用于新生代（Eden, S0, S1）。
- 标记-整理：用于老年代。
垃圾收集器 ：
- 新生代：Serial, ParNew, Parallel Scavenge。
- 老年代：CMS（并发标记清除，低停顿），G1（区域化分代式），ZGC（超低停顿）。
- 掌握 CMS 和 G1 的工作流程。
类加载机制 ：加载 -> 验证 -> 准备 -> 解析 -> 初始化 -> 使用 -> 卸载。双亲委派模型及其打破（如 JDBC, Tomcat）。
性能调优工具与参数 ：
- 命令： jps , jstat , jmap , jstack 。
- 图形工具：JConsole, VisualVM。
- 常用参数： -Xms , -Xmx , -Xmn , -XX:+HeapDumpOnOutOfMemoryError 。

常见问题排查思路：

CPU 飙升 ： top 找到 Java 进程 -> top -Hp [pid] 找到高 CPU 线程 -> printf ‘%x\n’ [tid] 转十六进制 -> jstack [pid] | grep -A 20 [nid] 查看线程栈，定位代码。
内存泄漏（OOM） ： jmap -dump:live,format=b,file=heap.hprof [pid] 导出堆快照，用 MAT 或 JProfiler 分析 GC Roots 引用链，找到无法被回收的对象。

2.4 MySQL 数据库（第8-9天）

数据库是后端系统的基石。

核心考点：

索引：
- B+Tree 结构 ：为什么用 B+Tree 不用 B-Tree？（非叶子节点只存键，叶子节点存数据且链表相连，范围查询效率高）。
- 聚簇索引 vs 非聚簇索引 ：主键索引叶子节点存整行数据；二级索引叶子节点存主键值。
- 最左前缀原则 ：联合索引 (a, b, c) ，能生效的查询条件： a=1 , a=1 and b=2 , a=1 and b=2 and c=3 。 b=2 无法使用该索引。
- 索引失效场景 ：对索引列进行计算或函数操作、类型隐式转换、 like 以 % 开头、 or 条件一侧无索引、 != 或 <> 。
事务与锁 ：
- ACID ：原子性（undo log）、一致性（约束）、隔离性（锁/MVCC）、持久性（redo log）。
- 隔离级别 ：读未提交 -> 脏读；读已提交 -> 不可重复读；可重复读（MySQL 默认） -> 幻读；串行化。
- MVCC ：多版本并发控制。通过 read view 和 undo log 实现非锁定读。 InnoDB 通过 Next-Key Lock（记录锁+间隙锁）解决可重复读级别下的幻读。
SQL 优化 ： EXPLAIN 命令看执行计划。关注 type （system > const > eq_ref > ref > range > index > ALL）、 key 、 rows 、 Extra （Using filesort, Using temporary 需警惕）。

SQL 优化示例：

-- 原SQL（假设有联合索引 (user_id, create_time)）
SELECT * FROM orders WHERE DATE(create_time) = ‘2023-10-01’ AND user_id = 100;

-- 优化后：避免对索引列使用函数
SELECT * FROM orders WHERE create_time >= ‘2023-10-01 00:00:00’ AND create_time < ‘2023-10-02 00:00:00’ AND user_id = 100;

2.5 Spring 框架核心（第10天）

Spring 是 Java 后端开发的事实标准。

核心考点：

IoC 与 DI ：控制反转，由容器管理 Bean 的生命周期和依赖关系。依赖注入的三种方式：构造器、Setter、字段注入。推荐使用构造器注入（强制依赖，利于不可变性和测试）。
AOP ：面向切面编程。概念：切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）。实现原理：动态代理（JDK 基于接口，CGLIB 基于类）。
Bean 生命周期 ：实例化 -> 属性填充 -> Aware 接口回调 -> 初始化前（ @PostConstruct ） -> 初始化（ InitializingBean ） -> 初始化后（AOP 代理） -> 使用 -> 销毁。
事务管理 ： @Transactional 注解。传播行为（PROPAGATION_REQUIRED 等）、隔离级别。原理：基于 AOP，在方法前后进行事务的开启、提交/回滚。注意自调用失效问题（调用同类中另一个事务方法）。

代码示例：Spring 事务配置与使用

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private AccountMapper accountMapper;

    @Transactional(rollbackFor = Exception.class) // 声明式事务
    public void createOrder(Order order) {
        // 1. 插入订单
        orderMapper.insert(order);
        // 2. 扣减账户余额
        accountMapper.deductBalance(order.getUserId(), order.getAmount());
        // 如果此处抛出异常，上面两步操作都会回滚
    }
}

3. 第二阶段：系统设计与项目深度复盘（第11-20天）

基础打牢后，需要提升解决复杂问题的能力，并将知识应用到项目描述中。

3.1 分布式系统基础概念（第11-12天）

核心考点：

CAP 与 BASE 理论 ：
- CAP：一致性（C）、可用性（A）、分区容错性（P），三者不可兼得，必须舍弃一个。分布式系统必须保证 P，因此在 CP（如 ZooKeeper）和 AP（如 Eureka）之间选择。
- BASE：基本可用（Basically Available）、软状态（Soft State）、最终一致性（Eventually Consistent）。是对 AP 的延伸。
分布式事务 ：
- 2PC（两阶段提交） ：协调者角色，存在同步阻塞和单点问题。
- TCC（Try-Confirm-Cancel） ：业务侵入性强，但性能好。需要实现三个接口。
- 本地消息表 ：利用消息队列的可靠性，实现最终一致性。例如：下单后，在本地数据库插入一条消息记录，后台任务轮询发送到 MQ，库存服务消费并处理。
- 最大努力通知 ：适用于对一致性要求不高的场景，如支付结果回调。
分布式 ID 生成 ：雪花算法（Snowflake，64位：时间戳+机器ID+序列号）、UUID、数据库自增（性能瓶颈）、Redis 自增、Leaf（美团开源）。

3.2 缓存与消息队列（第13-14天）

缓存（Redis）考点：

数据类型与应用场景 ：String（缓存、计数器）、Hash（对象存储）、List（消息队列、最新列表）、Set（标签、共同好友）、ZSet（排行榜）。
持久化 ：RDB（快照，恢复快，可能丢数据）、AOF（日志，数据安全，文件大）。生产环境通常混合使用。
高可用 ：主从复制、哨兵模式（Sentinel，监控与自动故障转移）、集群模式（Cluster，数据分片）。
缓存问题 ：
- 缓存穿透 ：查询不存在的数据。解决：布隆过滤器、缓存空值。
- 缓存击穿 ：热点 key 过期瞬间，大量请求打到 DB。解决：互斥锁（Redis SETNX ）、永不过期（逻辑过期）。
- 缓存雪崩 ：大量 key 同时过期。解决：随机过期时间、集群部署、服务降级。
Redis 为什么快 ：内存操作、单线程避免上下文切换、IO 多路复用、高效数据结构。

消息队列（Kafka/RocketMQ）考点：

作用：解耦、异步、削峰。
核心概念 ：生产者、消费者、Broker、Topic、Partition、Offset、Consumer Group。
消息可靠性 ：
- Kafka ：生产者 acks=all （所有 ISR 副本确认），消费者手动提交位移。
- RocketMQ ：事务消息、顺序消息、重试队列、死信队列。
如何保证顺序性 ：Kafka 同一分区内消息有序。RocketMQ 可保证全局或分区顺序。

3.3 项目复盘与 STAR 法则（第15-17天）

这是面试的核心环节。你需要准备 1-2 个你最熟悉的项目，并按照 STAR 法则进行结构化描述。

S（Situation） ：项目背景。是什么业务？为了解决什么问题？团队规模如何？
T（Task） ：你的任务。你在这个项目中具体负责什么？
A（Action） ：你采取的行动。 这是重点！ 要详细说明你用了什么技术、为什么选它、遇到了什么困难、如何解决的。例如：“为了解决高并发下的库存超卖问题，我引入了 Redis 分布式锁。但发现 setnx 命令在锁超时释放时存在误删其他线程锁的风险，于是将锁的值设为随机 UUID，释放时先 GET 再比较，保证原子性，最终使用 Lua 脚本实现。”
R（Result） ：行动的结果。带来了什么量化提升？例如：“系统 QPS 从 500 提升到 3000，订单超卖率降至 0。”

准备一个“项目难点”清单 ，并想好答案：

项目中最大的技术挑战是什么？
如何做技术选型的？（为什么用 Redis 不用 Memcached？为什么用 Kafka 不用 RabbitMQ？）
如果流量增加 10 倍，系统瓶颈在哪里？如何优化？
线上出现过什么故障？如何排查和解决的？

3.4 设计模式与代码实践（第18-20天）

设计模式体现代码设计能力，不要求全部精通，但常用的一定要懂。

必须掌握的模式：

单例模式 ：手写双重检查锁（DCL）并说明 volatile 的作用（防止指令重排序导致拿到未初始化完全的对象）。
工厂模式 ：简单工厂、工厂方法、抽象工厂。Spring 的 BeanFactory 就是工厂模式的体现。
代理模式 ：静态代理、动态代理（JDK、CGLIB）。这是 Spring AOP 的基础。
模板方法模式 ：定义一个算法骨架，子类重写特定步骤。JdbcTemplate, RedisTemplate 中广泛应用。
策略模式 ：定义一系列算法，使其可相互替换。常用于消除大量的 if-else 。

代码示例：双重检查锁单例

public class Singleton {
    private static volatile Singleton instance; // 必须 volatile

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查，避免不必要的同步
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查，确保唯一
                    instance = new Singleton(); // 非原子操作：1.分配内存 2.初始化 3.引用赋值。volatile 防止2和3重排序。
                }
            }
        }
        return instance;
    }
}

4. 第三阶段：新技术拓展与面试实战（第21-28天）

在基础扎实的前提下，了解前沿技术能让你脱颖而出。

4.1 AI 大模型应用开发入门（第21-23天）

对于 Java 后端开发者，不需要深入大模型算法，但需要了解如何将其能力集成到系统中。

核心概念：

大模型基础 ：了解 Transformer 架构（自注意力机制）的粗浅思想。知道什么是 Token、上下文长度、生成与对话。
Prompt Engineering ：如何设计提示词（Prompt）来更好地引导模型输出。例如 Few-shot（少样本）学习、思维链（Chain-of-Thought）提示。
AI Agent ：一个能感知环境、进行决策、执行动作的智能体。核心模式是 ReAct （Reasoning and Acting）：思考（Thought）-> 行动（Action，如调用工具）-> 观察（Observation）的循环。
RAG（检索增强生成） ：解决大模型知识过时和幻觉问题。流程：用户提问 -> 从知识库（向量数据库）检索相关文档 -> 将文档作为上下文与大模型问题一起生成答案。
开发框架 ：
- LangChain（Python 生态主流） ：用于构建基于大模型的应用程序链。
- Spring AI（Java 生态新星） ：Spring 官方项目，提供了与 OpenAI、Azure OpenAI 等模型交互的模板和抽象，让 Java 开发者能更方便地集成 AI 能力。

Spring AI 快速体验示例：

添加依赖（Spring Boot 3.x）：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    <version>0.8.1</version> <!-- 请使用最新版本 -->
</dependency>

配置


   application.yml

：

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}
      chat:
        options:
          model: gpt-3.5-turbo

编写一个简单的聊天服务：

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.stereotype.Service;

@Service
public class AIChatService {

    private final ChatClient chatClient;

    public AIChatService(ChatClient.Builder builder) {
        this.chatClient = builder.build();
    }

    public String chat(String message) {
        return chatClient.prompt()
                .user(message)
                .call()
                .content();
    }
}

在 Controller 中调用：

@RestController
@RequestMapping("/ai")
public class AIController {
    @Autowired
    private AIChatService chatService;

    @PostMapping("/chat")
    public String chat(@RequestBody String question) {
        return chatService.chat(question);
    }
}

面试回答思路： 当被问到“你对 AI 大模型在业务中的应用有什么想法？”时，可以这样回答： “我认为大模型可以作为我们后端系统的‘智能增强层’。例如，在客服系统中，我们可以用 RAG 技术构建一个智能问答助手，将产品手册和历史工单存入向量数据库，让模型基于这些精准知识来回答用户问题，避免‘胡说八道’。在内部，我们可以用 Agent 的思路，让模型学会调用我们的订单查询、物流跟踪等 API，自动处理一些简单的用户请求，提升效率。作为 Java 后端，我的关注点是如何通过像 Spring AI 这样的框架，安全、高效、可观测地将这些 AI 能力集成到我们现有的微服务架构中。”

4.2 高频系统设计场景题串讲（第24-25天）

准备几个经典场景题的答题模板。

场景一：如何设计一个秒杀系统？

架构原则 ：分层过滤、削峰填谷、柔性可用。
前端：静态化页面、按钮防重复点击、验证码。
网关层 ：限流（令牌桶、漏桶）、黑名单。
服务层 ：
- 缓存预热 ：秒杀开始前，将商品库存加载到 Redis。
- 库存扣减 ：使用 Redis Lua 脚本保证原子性，防止超卖。
- 请求队列 ：将下单请求放入消息队列（如 Kafka）异步处理，实现削峰。
- 流量隔离 ：秒杀服务独立部署，避免影响主站。
数据层 ：最终一致性。扣减 Redis 库存后，发消息给 MQ，由消费者异步写数据库。
降级与熔断 ：如果数据库压力大，触发熔断，后续请求直接返回“秒杀结束”。

场景二：如何设计一个短链接系统？

功能：长链转短链，短链访问重定向到长链。
短链生成 ：分布式 ID（雪花算法）转 62 进制（a-zA-Z0-9），或使用 Hash（如 MurmurHash）后取前几位，需处理碰撞。
存储：KV 存储（如 Redis）存映射关系 shortUrl -> longUrl 。数据库持久化。
重定向 ：301（永久）或 302（临时）。统计用 302，便于跟踪。
高并发 ：Redis 缓存热点短链。布隆过滤器判断短链是否存在。

4.3 全真模拟面试与简历优化（第26-28天）

模拟面试：

找朋友或录下自己的回答。
严格按照时间（30-60分钟）。
涵盖：自我介绍、基础八股、项目深挖、场景设计、算法题（可选）。
结束后复盘：哪里卡壳了？哪里表达不清晰？哪个知识点忘了？

简历优化：

量化成果 ：将“优化了系统性能”改为“通过引入 Redis 缓存和 SQL 优化，将接口平均响应时间从 200ms 降低到 50ms，QPS 提升 3 倍”。
技术关键词 ：明确写出你用的技术栈，如 Spring Cloud Alibaba, Redis, Kafka, Docker, Kubernetes。
项目描述按 STAR 法则 ：精炼地写在简历上。
针对性投递 ：根据目标公司的 JD（职位描述），微调简历，突出对方需要的技术栈和经验。

5. 第四阶段：心态调整与最终复盘（第29-30天）

第29天 ：停止学习新知识。快速过一遍自己的笔记和错题集。准备好自我介绍（1分钟和3分钟版本），反复练习直到自然流畅。
第30天 ：放松心情，检查面试所需物品（身份证、简历、纸笔）。提前熟悉面试地点或线上软件。保持自信，告诉自己已经做好了充分准备。

6. 常见面试问题与避坑指南

问题类别	典型问题	避坑指南 / 回答要点
Java基础	HashMap 扩容为什么是2的幂？	答：为了高效计算索引 `(n-1) & hash` 。2的幂次方减一的二进制全是1，与操作能均匀分布。
并发	volatile 能保证原子性吗？	答：不能。它只保证可见性和有序性。 `i++` 这类复合操作需要加锁或使用原子类。
JVM	对象一定在堆上分配吗？	答：不一定。如果经过逃逸分析，发现对象没有逃逸出方法，可能会在栈上分配（栈上替换）。
MySQL	为什么推荐使用自增主键？	答：1. 插入性能高（顺序写入）。2. 减少页分裂。3. 对于聚簇索引，主键长度影响二级索引大小。
Spring	@Autowired 和 @Resource 区别？	答： `@Autowired` 按类型注入，配合 `@Qualifier` 按名称。 `@Resource` 默认按名称，找不到再按类型。
项目	你这个项目有什么不足？	答：切忌说“没有不足”。可以坦诚说一个非核心的、且有思考改进方案的不足。例如：“早期版本缓存更新策略是定时刷新，存在短暂不一致，后续计划改为基于 Binlog 的实时更新。”
场景题	微信朋友圈怎么设计？	答：分发布和拉取。发布写 DB 和缓存；拉取用推拉结合模式：活跃好友用推模式（写扩散），非活跃好友用拉模式（读扩散）。重点讲推拉结合的权衡。
AI相关	什么是 RAG？	答：检索增强生成。先检索相关知识片段，再让大模型基于这些片段生成答案。用于解决模型知识过时和幻觉问题。可以结合向量数据库（如 Milvus）来讲。

7. 学习资源与工具推荐

书籍：《Java 核心技术卷 I》、《深入理解 Java 虚拟机》、《MySQL 是怎样运行的》、《Spring 实战》。
在线课程 ：各大平台（如极客时间、慕课网）的专栏课程，体系化学习效果好。
官方文档 ：Spring, Redis, Kafka 等的官方文档永远是第一手资料。
开源项目 ：在 GitHub 上搜索 spring-boot-demo , miaosha 等关键词，学习优秀的代码实践。
面试题库 ：牛客网、LeetCode（算法）、搜罗各大公司的面经。
模拟工具 ：用 Postman 测试 API，用 Docker 快速搭建 Redis/MySQL 环境，用 Arthas 进行线上诊断。

坚持执行这个 30 天计划，每天保持 3-4 小时的高效学习，你一定能建立起坚实的知识体系。面试不仅是知识的考察，更是心态和表达能力的比拼。保持自信，清晰沟通，将你的技术思考过程展现给面试官。最后，记住技术之路是一场马拉松，即使某次面试失利，积累下的知识和经验也是你宝贵的财富。祝你面试顺利，拿到心仪的 Offer！

标签