veyliss | Blog

redis核心原理与实战应用

Wed, 20 May 2026 00:00:00 GMT

Redis 常被用作缓存、分布式锁、排行榜、计数器和会话存储。它的核心优势不是“能存数据”这么简单，而是用内存访问、丰富数据结构、持久化和高可用机制，支撑高并发场景下的读写性能与系统稳定性。

这篇文章按实际使用路径整理 Redis：先看基础能力，再看高可用与缓存问题，最后整理一致性、性能优化和典型场景。

一、Redis 基础概念

数据类型支持

Redis 支持多种常用数据结构：

String：适合缓存简单值、计数器、分布式锁标记。
Hash：适合存储对象字段，例如用户信息。
List：适合队列、消息列表、时间线等场景。
Set：适合去重、集合交并差。
Sorted Set（ZSet）：适合排行榜、权重排序、延迟队列。

这些结构让 Redis 不只是一个 Key-Value 缓存，而是可以承接一部分高频读写业务逻辑。

持久化机制

Redis 主要有两种持久化方式：RDB 和 AOF。

RDB（快照）

定期生成内存快照，例如通过 bgsave 命令。
优点：文件体积较小，数据恢复速度快。
缺点：如果 Redis 异常退出，可能丢失最后一次快照之后的数据。

AOF（追加日志）

记录每一次写操作命令，例如 SET key value。
优点：数据安全性更高，可以配置更高频率的落盘。
缺点：文件体积更大，恢复速度通常慢于 RDB。

实际生产中常见策略是 RDB + AOF 组合使用：RDB 用于快速恢复，AOF 用于降低数据丢失风险。

二、主从同步与高可用

主从同步方式

Redis 主从同步分为全量同步和增量同步。

全量同步

通常发生在从节点初次连接主节点，或断线时间过长无法增量追赶时：

主节点生成 RDB 文件。
主节点把 RDB 文件发送给从节点。
从节点清空旧数据并加载 RDB。
主节点继续把同步期间缓冲区中的写操作发送给从节点。

增量同步

当从节点短暂断线后重新连接，可以通过 psync 根据复制偏移量（offset）同步缺失的写操作，避免重新做一次全量同步。

高可用实现

Redis 常见高可用方案主要有两类：

哨兵模式（Sentinel）：监控主从节点状态，在主节点故障时自动完成故障转移。
集群模式（Cluster）：通过分片存储数据，提升容量上限，并支持水平扩展。

哨兵更偏向主从高可用，集群更偏向容量扩展和分片治理。

三、缓存问题与解决方案

缓存击穿

缓存击穿指的是一个热点 Key 在高并发访问时突然过期，大量请求同时打到数据库。

常见解决方案：

热点 Key 不设置过期时间，通过后台任务主动刷新。
互斥锁或分布式锁，只允许一个请求回源重建缓存。
逻辑过期，缓存中保存过期时间，由后台异步刷新数据。

缓存穿透

缓存穿透指的是大量请求访问不存在的数据，缓存无法命中，请求直接落到数据库。

常见解决方案：

布隆过滤器：在请求进入缓存和数据库之前过滤明显不存在的 Key。
缓存空对象：对不存在的数据短时间缓存空值，避免重复打到数据库。
参数校验：拦截非法 ID、异常参数和明显无效请求。

缓存雪崩

缓存雪崩指的是大量 Key 在同一时间过期，导致请求集中打到数据库。

常见解决方案：

随机过期时间，避免大量 Key 同时失效。
限流降级，在数据库压力过高时保护核心服务。
多级缓存或集群部署，减少单点缓存失效带来的冲击。

四、数据一致性与 Redis-MySQL 同步

双写一致性方案

业务中常见的数据源组合是 MySQL 存储主数据，Redis 作为缓存。这里的核心问题是：数据库更新后，缓存如何保持一致。

常见方案：

先写 MySQL，再更新 Redis：逻辑直接，但并发下可能出现旧值覆盖新值。
先写 MySQL，再删除 Redis：更常见，后续请求回源数据库并重建缓存。
延迟双删：写库后删除缓存，短暂延迟后再次删除，降低并发读写导致的脏缓存概率。
最终一致性：通过消息队列或 Canal 监听 MySQL Binlog，把数据变更异步同步到 Redis。

业务场景适配

对实时一致性要求很高的场景，需要更严格的事务或强一致方案。
对短暂延迟可接受的场景，通常使用缓存删除、消息队列、Binlog 同步等最终一致性方案。

缓存一致性没有绝对通用答案，重点是结合业务对“延迟、正确性、复杂度”的要求做取舍。

五、Redis 性能优化

慢查询排查

Redis 提供 slowlog 用于排查慢查询。常见优化方向：

避免 KEYS *、SORT、大范围 SUNION 等高复杂度命令。
对批量操作使用 Pipeline，减少网络往返。
控制单次命令处理的数据规模，避免阻塞主线程。

内存淘汰策略

当内存达到 maxmemory 限制时，Redis 会根据配置的淘汰策略处理 Key。

常见策略：

noeviction：内存不足时拒绝写入。
volatile-lru：只在设置了过期时间的 Key 中淘汰最近最少使用的 Key。
volatile-lfu：只在设置了过期时间的 Key 中淘汰最近最不常用的 Key。
allkeys-lru：在所有 Key 中淘汰最近最少使用的 Key。
allkeys-lfu：在所有 Key 中淘汰最近最不常用的 Key。
allkeys-random：在所有 Key 中随机淘汰。

缓存场景通常更常见 allkeys-lru 或 allkeys-lfu，但具体选择要看访问分布和业务容忍度。

BigKey 与 HotKey

BigKey 指单个 Key 占用过大内存或包含过多元素，会导致网络传输、删除、迁移和持久化变慢。

HotKey 指少数 Key 被高频访问，容易造成单点压力。

优化方向：

拆分过大的 Hash、List、Set、ZSet。
避免一次性读取或删除大 Key。
对热点数据做本地缓存、多副本缓存或请求合并。

六、线程模型与内存管理

单线程模型

Redis 的命令执行主要是单线程模型，这让它避免了大量锁竞争，命令执行顺序也更容易理解。

Redis 6.0 之后引入多线程处理网络 I/O，但命令执行本身仍然保持单线程语义。因此，慢命令、大 Key 操作、复杂聚合仍然可能阻塞 Redis。

过期键删除策略

Redis 对过期 Key 主要使用两种删除策略：

惰性删除

获取 Key 时检查是否过期，过期则删除。
优点：不主动消耗额外资源。
缺点：如果过期 Key 长时间不被访问，可能继续占用内存。

定期删除

Redis 定期随机抽样部分 Key，删除其中已经过期的 Key。
优点：可以主动清理过期数据。
缺点：不保证所有过期 Key 都会立刻被删除。

Redis 默认使用 惰性删除 + 定期删除 的组合策略。

七、Redis 变慢的排查方向

Redis 变慢时，可以从以下方向排查：

硬件资源

检查内存是否耗尽，是否发生 Swap，例如使用 free -m。
检查磁盘 I/O，尤其是 AOF 写入和重写期间。
使用 SSD 替代传统磁盘，降低持久化带来的 I/O 压力。

命令复杂度

排查是否使用了 KEYS、SORT、SUNION 等高复杂度命令。
检查是否存在大批量读取、大批量删除或大集合遍历。
对批量请求使用 Pipeline，减少网络延迟。

AOF 重写阻塞

AOF 重写期间可能与 fsync 竞争磁盘资源。可以根据场景配置：

no-appendfsync-on-rewrite yes

这个配置可以降低 AOF 重写期间的写入阻塞风险，但也会增加极端情况下的数据丢失窗口，需要结合业务容忍度评估。

缓存雪崩或击穿

如果数据库和 Redis 同时出现压力波动，需要排查是否存在：

大量 Key 同时过期。
热点 Key 突然失效。
缓存重建逻辑没有互斥保护。

八、Redis vs Memcached

特性	Redis	Memcached
数据类型	String、Hash、List、Set、ZSet 等	主要支持简单 Key-Value
持久化	支持 RDB、AOF	不支持持久化
内存回收	支持多种淘汰策略	支持 LRU 等缓存淘汰机制
原子操作	支持较丰富的原子操作	支持有限原子操作
线程模型	命令执行以单线程为主，Redis 6.0 后支持 I/O 多线程	多线程网络模型
场景适用	复杂缓存、计数、排行榜、分布式锁	简单缓存、高吞吐 Key-Value

简单说：如果只是做非常简单的缓存，Memcached 也可以胜任；如果需要更丰富的数据结构、持久化、高可用和分布式能力，Redis 更适合。

九、典型场景应用

Redis 常见业务场景包括：

缓存：存储热点数据，减少数据库压力。
会话保持：存储用户 Session 或登录态。
排行榜：通过 ZSet 实现 Top N 榜单。
限流降级：通过计数器、滑动窗口或令牌桶实现接口限流。
分布式锁：使用 SET key value NX PX 等命令实现基础锁能力。
延迟队列：通过 ZSet 分数存储执行时间，实现定时任务调度。

总结

Redis 的核心价值在于 高性能访问、灵活数据结构、持久化能力和分布式支持。

实际使用 Redis 时，需要重点关注四件事：

数据结构是否选对。
缓存异常场景是否有兜底方案。
Redis 与数据库之间是否能接受最终一致性。
是否避免了慢命令、BigKey、HotKey 和集中过期。

理解这些核心机制后，Redis 就不只是一个缓存组件，而是高并发系统中非常重要的性能与稳定性基础设施。

接触 Vibe Coding 八个多月后的感受

Wed, 20 May 2026 00:00:00 GMT

接触 Vibe Coding 已经八个多月了。

回头看，这段时间给我带来的变化非常大。它不只是让我多认识了一些 AI 工具，也不只是让我写代码的速度变快了。更重要的是，它改变了我看待开发这件事的方式。

以前我更关注技术本身。

我会想这个功能应该怎么实现，代码怎么写，框架怎么选，接口怎么设计，数据库结构怎么拆。很多时候，注意力会自然落在“如何把代码写出来”这件事上。

而现在，我越来越多地开始关注产品本身。

这个功能为什么要做？用户会怎么使用？流程是不是顺？页面是不是清楚？这个需求背后真正要解决的业务问题是什么？这些问题慢慢变得比“代码怎么写”更靠前。

这就是 Vibe Coding 对我最大的影响。

从开发辅助开始

在更早的时候，我使用 AI 的方式其实很简单。

去年的上半年，AI 对我来说更多还是一个开发辅助工具。它主要停留在 Web 式的 Chat 形态里，我会问它一些问题，让它帮我解释概念、检索资料、分析报错、生成一些代码片段。

那个阶段的 AI 很像一个随时在线的助手。

它能帮我查东西，也能帮我补充思路，但大多数时候，真正的开发过程还是由我自己主导。我要自己拆任务、自己打开项目、自己修改文件、自己调试和验证。

AI 参与了过程，但没有真正进入开发工作流的中心。

那时候我对它的理解也很朴素：它可以提高效率，可以减少搜索成本，可以帮我更快理解一些不熟悉的知识。

但我还没有意识到，它会在后面改变整个开发方式。

Agent 概念开始爆发

后来，Agent 的概念越来越火。

我开始看到各种 CLI 工具出现，也开始频繁听到 token、上下文、模型网关、提示词、工具调用、代码代理这些词。AI 不再只是一个聊天窗口，它开始进入终端、进入编辑器、进入项目目录，甚至可以直接阅读代码、修改文件、运行命令、检查结果。

这和以前完全不一样。

以前是我把问题复制给 AI，然后把答案再搬回项目里。现在则更像是 AI 直接坐进了项目现场，和我一起看代码、改代码、验证代码。

这时我也开始加入 Vibe Coding 的行列。

刚开始的时候，我其实并不知道这些工具应该怎么用。面对各种模型、API、CLI、代理配置，我会有点茫然。它们看起来都很强，但真正落到自己的项目里，还是需要一段适应过程。

我需要理解它们的边界。

哪些事情可以交给它？哪些事情必须自己判断？什么时候应该让它改代码？什么时候只是让它分析？上下文应该怎么给？任务应该怎么拆？

这些并不是看一篇教程就能立刻掌握的。

工具链慢慢成形

后来我逐渐知道了 New API 这类整合型网关，也开始理解它们在 AI 工作流中的意义。

模型越来越多，不同模型有不同能力、价格和使用限制。如果每一个工具都单独配置，就会很分散。整合型网关的意义在于，它能把不同模型入口统一起来，让工具调用变得更稳定，也更容易管理。

再后来，我接触到了 Claude Code 这类工具。

它让我真正感受到“AI 参与编码”这件事和普通问答的区别。

普通问答更像是你问一句，它答一句。CLI 编码工具则更像是你把它放进项目里，它可以沿着任务往前走：阅读文件、理解结构、修改代码、运行检查、再根据结果继续调整。

这时候，AI 就不只是回答问题，而是在参与完成工作。

当然，这并不意味着我可以完全放手。

相反，我越来越感觉到，使用这类工具时，人要承担更高层次的判断。你要知道目标是什么，知道验收标准是什么，知道哪里不能乱动，知道生成的代码是否符合项目长期维护的方向。

AI 可以很快，但方向仍然要由人来定。

从关注代码到关注产品

过去我做一个东西，第一反应常常是技术问题。

页面怎么写？接口怎么接？状态怎么管理？样式怎么调？

现在我会先想产品问题。

这个页面存在的目的是什么？用户第一眼应该看到什么？如果他想继续阅读，路径是不是顺？如果他在移动端打开，会不会困惑？如果内容越来越多，列表是否还能承载？如果未来要部署、维护、持续写文章，流程是不是足够轻？

这种变化很明显。

因为当 AI 可以承担大量具体编码工作后，我的注意力就被释放出来了。我不再需要把所有精力都压在每一行代码上，而是可以站得稍微高一点，看整个产品的结构和体验。

这并不是说技术不重要。

技术仍然重要，而且越到后面越重要。只是技术不再是唯一中心。它更像是实现产品目标的手段，而不是最终目的。

以前我可能会因为某个技术点很有意思就想做点东西。现在我会先问：这个东西解决了什么问题？它对用户、对内容、对长期维护有什么价值？

业务流程变得更重要

Vibe Coding 也让我更关注业务流程。

一个功能不是孤立存在的。它前面有入口，后面有结果，中间有状态变化和用户决策。只把某个页面写出来，并不代表功能真的完成。

比如一个博客站，不只是能展示文章就够了。

还要考虑：

新文章怎么创建。
分类和标签怎么维护。
首页如何呈现内容价值。
列表页如何让读者快速判断是否要点进去。
文章页如何让阅读体验稳定。
部署后如何只专注维护内容。

这些都不是单纯的代码问题，而是产品流程问题。

当 AI 能帮我更快完成具体实现后，我反而会花更多时间思考这些流程是否合理。

我会更在意一个功能放在系统里是不是自然，一个页面是不是为后续内容增长留好了空间，一个交互是不是符合读者直觉。

这其实是更接近产品视角的思考。

AI 让我更聚焦结果

这八个多月里，我最大的感受是：AI 把很多“执行层面的阻力”变小了。

以前想到一个功能，可能要先考虑技术栈、查文档、写样板代码、调样式、修报错。很多时候，还没真正验证想法，就已经被实现细节消耗掉了。

现在不同了。

我可以更快把想法变成可运行的东西，再通过实际效果判断它是否值得继续优化。

这会让开发节奏发生变化。

以前更像是先想很久，再动手实现。现在更像是先做出一个版本，然后不断观察、调整、迭代。

AI 给我的不是简单的偷懒，而是更短的反馈周期。

当反馈周期变短，人就更容易围绕结果做判断，而不是长时间停留在假设里。

但人依然是关键

使用 Vibe Coding 越久，我越觉得人并没有变得不重要。

相反，人变得更重要。

因为 AI 可以生成代码，但它不一定知道什么是适合你的。它可以给出方案，但它不知道你真正想要的产品气质。它可以完成任务，但它不会天然理解你的长期规划。

所以，人需要做这些事情：

定义目标。
拆解任务。
判断取舍。
控制范围。
验收结果。
维护产品方向。

如果没有这些判断，AI 很容易把事情做得很快，但不一定做得正确。

这也是我慢慢学到的一点：Vibe Coding 不是随便让 AI 写代码，而是学会用清晰的目标和上下文引导它，把人的判断和 AI 的执行力结合起来。

对我的改变

这段经历让我发生了几个明显变化。

第一，我更愿意从产品角度看问题。

我不再只问“这个功能怎么写”，而是会先问“这个功能为什么存在”。

第二，我更重视流程。

页面、内容、工具、部署、维护，它们应该连成一条顺畅的链路，而不是一个个孤立的点。

第三，我对学习 AI 相关知识更有动力。

从模型到上下文，从 CLI 工具到网关，从提示词到任务拆解，这些内容不再只是概念，而是会真实影响我每天的开发方式。

第四，我开始更相信个人项目的可能性。

以前一个人做完整产品会觉得很重。现在虽然仍然不轻松，但至少很多原本消耗人的细节可以被 AI 分担。一个人的上限，正在被工具重新拉高。

写在最后

接触 Vibe Coding 的这八个多月，对我来说像是一次开发方式的迁移。

我从把 AI 当作问答工具，慢慢转向把它当作开发协作者。也从更关注技术实现，逐渐转向关注产品本身、业务流程和最终结果。

这种变化不是一夜之间发生的。

它是在一次次尝试工具、配置模型、修改项目、验证结果的过程中慢慢形成的。

现在的我依然还在学习 AI，也还在摸索更适合自己的工作流。但有一点已经很明确：未来的开发不会再回到过去那种完全依赖手工推进的状态。

AI 会继续进入开发流程，而我需要做的，是学会站在更高的位置使用它。

把注意力从代码细节里适当抽出来，更多地放到产品、体验、流程和价值上。

这可能就是 Vibe Coding 最吸引我的地方。

它不是让我不再关心技术，而是让我终于有更多精力去关心技术背后真正要完成的事情。

梦开始的地方

Mon, 18 May 2026 00:00:00 GMT

这是我创建项目的第一篇博客文章。

在这个博客里，我将分享我的技术学习历程、项目经验以及一些随笔思考。希望通过这个平台，能够记录下我的成长轨迹，也能与志同道合的朋友们交流和分享。

我的名字叫做 veyliss，这是我“梦开始的地方”。我希望在这里能够记录下我的梦想和努力的过程，也希望能够激励自己不断前行。无论是技术上的突破，还是生活中的点滴，我都希望能够在这里留下足迹。

在许多年前我就曾想着自己搭建真正属于自己的博客网站，记录自己的学习和成长。如今这个想法终于实现了，我感到非常兴奋和满足。这个博客不仅是一个记录工具，更是一个激励自己不断前进的动力源泉。

我相信，通过这个博客，我能够更好地总结和反思自己的学习过程，也能够与更多的人分享我的经验和见解。无论是技术上的问题，还是生活中的思考，我都希望能够在这里找到共鸣和支持。

最后，感谢每一个来到这个博客的朋友们，希望你们能够在这里找到有价值的内容，也希望我们能够在这里一起成长和进步。让我们一起在这个梦开始的地方，书写属于我们的故事吧！

回顾 2025

Wed, 31 Dec 2025 00:00:00 GMT

回望 2025 年，时间像被按下了快进键。

这一年走得很快，也走得并不轻松。很多事情在开始时都带着热情，真正走到最后却发现，能完整收尾的并不算多。想做的项目、想沉淀的知识、想持续推进的计划，有些还停留在半成品阶段，有些甚至只是短暂地闪过念头。

这并不是一个让人完全满意的年份。

但它也不是毫无意义的一年。

工作带来的真实成长

这一年里，有一段连续而紧张的工作经历。

那几个月很充实，也很消耗人。每天都在处理新的任务，面对新的问题，试着把一些看起来并不容易的事情往前推进。工作中，我尽力认真对待每一项安排，也不断尝试挑战自己原本觉得困难的部分。

这段经历让我收获了不少东西。

我积累了更真实的工作经验，也接触到了很多优秀的同事和前辈。从他们身上，我看到了更成熟的处理方式、更稳定的职业节奏，以及面对复杂问题时更清晰的判断。

这些东西不是单靠看教程、写练习就能得到的。它们来自具体的工作现场，来自一次次沟通、交付、修改和复盘。

不过遗憾也很明显。

个人能力确实在提升，但还没有达到自己期待中的飞跃。和行业里真正优秀的人相比，差距依然存在，而且并不小。意识到这一点的时候，会有一点失落，但也会更清楚自己接下来应该往哪里用力。

疲惫也是这一年的关键词

下班后的疲惫，是这一年很真实的一部分。

这种疲惫不只是身体上的，更是精神上的。忙碌一天之后，大脑长时间处在紧绷状态。回到住处，整个人像被抽空了能量，明明知道还有很多东西值得学习，却很难再把自己重新拉回专注状态。

我曾经计划利用业余时间继续学习新知识，补足能力短板，也想持续推进一些个人项目。可是很多时候，打开资料、看到待办列表，就会先感到一阵无力。

于是一些计划被推迟，一些想法被搁置，一些原本应该继续打磨的东西，也慢慢停在了半路。

这并不值得美化。

它只是提醒我：人的精力是有限的，自我提升也不能只靠一时热情。真正能走得远的，应该是更稳定、更可持续的节奏。

知识体系仍然需要建立

这一年，我也多次想过要构建自己的知识体系。

我越来越能感受到，零散学习带来的问题很明显。今天看一点后端，明天补一点前端，后天又去了解新的工具和概念，短期内似乎学了很多，但如果没有整理和连接，这些知识很容易散落在各处。

我希望能把这些零散的知识点串联起来。

不是为了把自己包装得很厉害，而是希望在未来遇到问题时，能更快找到方向，知道某个知识点在整个技术体系里处于什么位置，也能把过去踩过的坑、做过的项目、解决过的问题留下来。

这也是我后来越来越想认真维护博客和知识库的原因。

文字不是为了证明什么，而是为了给自己留下路径。现在的记录，也许会成为未来某个阶段重新出发时的坐标。

遇见更多不同的人

2025 年，我结识了很多圈内朋友。

他们来自不同领域，有交易所、Web3、外卖行业、传统行业、SaaS 领域，也有来自大厂的朋友。还有一些自由职业者，他们的工作方式和生活状态让我产生过很多羡慕与向往。

和这些人交流，会明显感觉到世界比自己日常接触到的范围更大。

不同的人在不同赛道里寻找机会，也在用各自的方式处理工作、生活和成长之间的关系。有的人很专注，有的人很灵活，有的人已经找到了相对自由的节奏，也有人还在变化里持续摸索。

这些交流让我意识到，职业发展不是只有一条路。

稳定工作是一种选择，持续深耕是一种选择，做项目、做产品、做自由职业，也都是不同的选择。重要的是，自己要逐渐知道想过怎样的生活，并为之积累足够的能力。

AI 时代正在加速到来

2025 年也是 AI 快速爆发的一年。

越来越多行业开始投入 AI 相关研发，尝试用 AI 提升效率、优化流程、创造新的业务价值。无论是技术研发、内容生产，还是产品设计、数据分析，AI 都在逐渐进入日常工作。

这不是一个遥远的趋势，而是正在发生的变化。

我能明显感觉到，未来互联网生态会和 AI 更紧密地连接在一起。很多岗位的工作方式会被改变，很多工具会被重做，很多原本依赖人工经验的流程，也会被新的方式重新组织。

这对个人来说既是压力，也是机会。

压力在于，原本掌握的技能可能很快变得不够用。机会在于，如果能更早理解这些变化，并把 AI 当成能力放大器，就有可能在新的阶段找到更好的位置。

写在最后

2025 年并不是一个完成度很高的年份。

它有遗憾，有拖延，有没有收尾的项目，也有很多没有真正落实的计划。但它同样留下了工作经验、人际连接、行业观察和对自我节奏的重新认识。

我不想把这一年写得过于漂亮。

因为真实的成长并不总是热血的。很多时候，它只是一次次发现自己的不足，然后在疲惫里慢慢调整方向。

如果要给 2025 年一个总结，我想它更像是一个提醒：

不要只依赖热情，也不要害怕缓慢。

真正重要的，是在每一次停顿之后，还能重新开始。

Java 校招面试题复盘清单

Wed, 29 Oct 2025 00:00:00 GMT

这是一份 Java 校招面试题复盘清单。

它不适合当作“背诵稿”逐字记忆，更适合当作复习地图：先知道面试会问哪些方向，再把每个问题整理成可以讲清楚的核心答案。

Java 校招面试通常会围绕三部分展开：

模块	占比	重点
技术基础	约 40%	Java、Spring、MySQL、Redis、JVM、并发
项目深挖	约 40%	项目背景、技术选型、难点、优化、问题排查
学习能力	约 20%	最近在学什么、为什么做 Java、如何解决问题

如果项目里有 Elasticsearch，那么 ES 往往会成为面试官重点追问的方向。

Java 基础

HashMap 的底层原理是什么

HashMap 底层主要是数组、链表和红黑树。

当放入一个 key-value 时，会先根据 key 的 hashCode() 计算 hash，再定位到数组下标。如果该位置没有元素，就直接放入；如果已经有元素，就会形成链表或红黑树。

在 Java 8 之后，当链表长度达到一定阈值，并且数组容量足够大时，链表会转换为红黑树，用来提高查询效率。

可以这样回答：

HashMap 通过 hash 定位数组下标，数组中每个位置叫 bucket。发生 hash 冲突时，Java 8 以前主要用链表，Java 8 之后链表过长会转为红黑树。扩容时会重新计算元素位置，所以 HashMap 的性能和初始容量、负载因子、hash 分布都有关系。

HashMap 为什么线程不安全

HashMap 没有做同步控制，多线程同时读写时可能出现数据覆盖、状态不一致、扩容异常等问题。

常见风险：

多个线程同时 put，可能覆盖彼此写入。
扩容时结构变化，其他线程同时访问可能拿到异常结果。
统计数量 size 可能不准确。

所以多线程场景通常使用 ConcurrentHashMap。

ConcurrentHashMap 如何实现线程安全

Java 8 中，ConcurrentHashMap 主要通过 CAS 和 synchronized 保证线程安全。

它不是给整张表加一把大锁，而是尽量缩小锁粒度。

常见回答：

Java 8 的 ConcurrentHashMap 底层也是数组、链表和红黑树。插入时，如果桶为空，会通过 CAS 放入节点；如果桶不为空，会对桶头节点加 synchronized，只锁当前桶。这样既保证线程安全，又比 Hashtable 整表加锁性能更好。

ArrayList 和 LinkedList 的区别

ArrayList 底层是动态数组，LinkedList 底层是双向链表。

对比项	ArrayList	LinkedList
底层结构	动态数组	双向链表
随机访问	快，按下标访问 O(1)	慢，需要遍历
中间插入删除	需要移动元素	找到节点后修改指针
内存占用	相对较少	每个节点要存前后指针
常用场景	查询多	插入删除多，但实际也要看位置

面试里要注意：不要简单说 LinkedList 插入删除一定快。因为如果要先按索引找到位置，遍历本身也有成本。

String、StringBuilder、StringBuffer 的区别

String 是不可变对象，每次修改都会产生新字符串。

StringBuilder 是可变字符序列，线程不安全，但性能较好。

StringBuffer 也是可变字符序列，方法加了同步，线程安全，但性能通常低于 StringBuilder。

常见选择：

少量字符串拼接：直接用 String。
单线程大量拼接：用 StringBuilder。
多线程共享拼接对象：用 StringBuffer，但实际业务中较少这样用。

equals 和 == 的区别

== 比较的是两边是否相等。

对于基本类型，比较的是值。

对于引用类型，比较的是对象地址。

equals() 是对象方法，默认实现也是比较地址，但很多类会重写它，比如 String 会比较字符串内容。

equals-demo.java

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b); // false
System.out.println(a.equals(b)); // true

Java 中的异常体系是什么

Java 异常体系的顶层是 Throwable。

它下面主要分为：

Error：严重错误，程序通常不主动处理，比如 OutOfMemoryError。
Exception：程序可以捕获和处理的异常。

Exception 又分为：

checked exception：编译期异常，必须处理或声明抛出。
unchecked exception：运行时异常，继承自 RuntimeException，例如空指针、数组越界。

面试里可以补一句：业务开发中不要滥用异常控制正常流程，异常更适合表示非预期情况。

什么是反射

反射是 Java 在运行时获取类信息、创建对象、调用方法、访问字段的能力。

常见应用场景：

Spring 创建 Bean、依赖注入。
MyBatis 映射对象字段。
注解解析。
测试框架调用测试方法。
动态代理。

反射灵活，但也有缺点：性能相对普通调用更低，可读性和安全性更差。

Java 并发

什么是线程，什么是进程

进程是操作系统资源分配的基本单位。一个应用程序运行起来通常就是一个进程。

线程是 CPU 调度的基本单位，一个进程中可以包含多个线程。

可以这样回答：

进程拥有独立的内存空间，线程共享同一进程的内存资源。线程切换成本通常低于进程，但共享数据也会带来线程安全问题。

synchronized 的原理是什么

synchronized 可以修饰方法或代码块，用来保证同一时间只有一个线程进入临界区。

它依赖对象监视器锁，也就是 monitor。

进入同步代码块时，线程尝试获取对象锁；执行完或异常退出时释放锁。

可以补充：

修饰普通方法，锁的是当前对象 this。
修饰静态方法，锁的是当前类的 Class 对象。
修饰代码块，可以指定锁对象。

volatile 的作用是什么

volatile 主要有两个作用：

保证变量对多线程的可见性。
禁止指令重排序。

它不能保证复合操作的原子性。

比如 count++ 包含读取、加一、写回，不是一个原子操作，所以只加 volatile 仍然不安全。

常见场景：

状态标志位。
单例模式双重检查锁中的实例变量。

什么是线程池

线程池是提前创建并管理一组线程，任务来了以后交给线程池执行。

使用线程池的原因：

避免频繁创建和销毁线程。
控制并发线程数量。
提高响应速度。
统一管理任务队列、拒绝策略和线程生命周期。

ThreadPoolExecutor 核心参数有哪些

ThreadPoolExecutor 常见核心参数：

参数	作用
`corePoolSize`	核心线程数
`maximumPoolSize`	最大线程数
`keepAliveTime`	非核心线程空闲存活时间
`unit`	时间单位
`workQueue`	任务队列
`threadFactory`	线程创建工厂
`handler`	拒绝策略

执行流程可以概括为：

核心线程未满 -> 创建核心线程
核心线程已满 -> 放入任务队列
队列满了 -> 创建非核心线程
线程数达到最大且队列也满 -> 执行拒绝策略

什么是死锁，如何避免

死锁是多个线程互相持有对方需要的资源，导致都无法继续执行。

死锁常见四个条件：

互斥。
请求并保持。
不可剥夺。
循环等待。

避免方式：

固定加锁顺序。
减少锁范围。
使用超时锁。
避免嵌套锁。
使用并发工具类代替手写锁。

JVM

JVM 的内存结构是什么

JVM 运行时数据区主要包括：

程序计数器。
Java 虚拟机栈。
本地方法栈。
堆。
方法区。

线程私有：

程序计数器。
Java 虚拟机栈。
本地方法栈。

线程共享：

堆。
方法区。

堆和栈的区别

栈主要存放方法调用相关信息，比如局部变量表、操作数栈、方法出口等。

堆主要存放对象实例，是垃圾回收重点关注的区域。

对比项	栈	堆
线程关系	线程私有	线程共享
存储内容	方法调用、局部变量	对象实例
生命周期	随方法调用入栈出栈	由 GC 管理
常见错误	`StackOverflowError`	`OutOfMemoryError`

什么是垃圾回收

垃圾回收是 JVM 自动回收不再使用对象的机制。

判断对象是否可回收，主流方法是可达性分析：从 GC Roots 出发，能到达的对象是存活对象，不能到达的对象可以被回收。

常见 GC Roots：

虚拟机栈中的引用。
方法区中的静态变量引用。
常量引用。
本地方法栈中的引用。

常见 GC 算法有哪些

常见算法：

标记-清除：先标记垃圾，再清除，可能产生内存碎片。
复制算法：把存活对象复制到另一块区域，适合新生代。
标记-整理：标记后整理存活对象，减少碎片。
分代收集：按对象生命周期分区，不同区域用不同算法。

什么情况下会发生 OOM

OOM 是内存不足导致的错误。

常见原因：

创建了大量对象，堆空间不足。
大对象过多。
内存泄漏，旧对象一直被引用。
线程过多导致栈空间不足。
元空间加载类过多。

排查时通常会看日志、堆 dump、GC 情况和对象引用链。

JVM 调优一般关注哪些参数

常见关注点：

堆大小：-Xms、-Xmx
新生代大小：-Xmn
元空间大小：-XX:MetaspaceSize
GC 收集器选择。
GC 日志。
停顿时间和吞吐量。

调优不是盲目改参数，而是先看现象：内存是否够、GC 是否频繁、停顿是否过长、对象是否异常增长。

Spring

什么是 IoC

IoC 是控制反转。

原本对象由程序自己创建和管理，现在交给 Spring 容器创建和管理。

DI 依赖注入是 IoC 的一种实现方式。比如一个 Service 依赖 Mapper，不需要自己 new，而是由 Spring 注入。

什么是 AOP

AOP 是面向切面编程，用来把通用逻辑从业务代码中抽离出来。

常见场景：

日志。
权限校验。
事务。
监控统计。
接口耗时。

核心思想是：不修改业务方法本身，在方法执行前后织入增强逻辑。

Bean 的生命周期是什么

简化流程：

实例化 -> 属性注入 -> 初始化前后处理 -> 初始化方法 -> 使用 -> 销毁

常见扩展点：

构造方法。
属性填充。
BeanPostProcessor。
InitializingBean 或 init-method。
DisposableBean 或 destroy-method。

为什么使用 Spring Boot

Spring Boot 主要解决传统 Spring 项目配置繁琐的问题。

优势：

自动配置。
内置 Web 容器。
starter 依赖简化。
快速创建项目。
方便监控和部署。

一句话回答：

Spring Boot 让 Spring 项目更容易启动和维护，它通过自动配置和 starter 机制减少大量 XML 或手动配置。

Spring Boot 自动配置原理是什么

自动配置的核心是根据类路径、配置文件和条件注解，自动创建合适的 Bean。

常见关键词：

starter。
auto configuration。
@EnableAutoConfiguration。
条件注解，比如 @ConditionalOnClass、@ConditionalOnMissingBean。

面试中可以这样说：

Spring Boot 会根据引入的依赖和当前环境判断是否满足条件，如果满足，就把对应配置类里的 Bean 注册到容器中。

什么是 RESTful API

RESTful API 是一种接口设计风格。

核心思想：

使用 URL 表示资源。
使用 HTTP 方法表示操作。
使用状态码表示结果。

示例：

GET /users/1      查询用户
POST /users       创建用户
PUT /users/1      更新用户
DELETE /users/1   删除用户

MySQL

MySQL 索引是什么

索引是帮助 MySQL 快速查找数据的数据结构。

可以理解为书的目录。没有索引时，数据库可能要全表扫描；有索引时，可以更快定位数据。

索引能提高查询效率，但会增加写入成本和存储空间。

MySQL 为什么使用 B+Tree

B+Tree 适合磁盘存储和范围查询。

原因：

树高度低，减少磁盘 IO。
非叶子节点只存索引，能放更多 key。
叶子节点之间有链表，范围查询效率高。
查询性能稳定。

什么是覆盖索引

覆盖索引指查询需要的字段都能从索引中获得，不需要回表查询。

比如有联合索引 (name, age)：

SELECT name, age FROM user WHERE name = 'xiaoxi';

如果查询字段都在索引里，就可能走覆盖索引。

什么情况下索引会失效

常见情况：

对索引列使用函数。
对索引列做计算。
使用左模糊匹配，例如 LIKE '%abc'。
联合索引不符合最左前缀原则。
隐式类型转换。
OR 条件使用不当。

什么是事务

事务是一组数据库操作的集合，要么全部成功，要么全部失败。

比如下单时：

创建订单。
扣减库存。
扣减余额。

这些操作应该作为一个整体处理。

MySQL 事务的 ACID

特性	含义
Atomicity 原子性	事务要么全部成功，要么全部失败
Consistency 一致性	事务前后数据满足约束
Isolation 隔离性	并发事务之间互相隔离
Durability 持久性	事务提交后数据持久保存

什么是 MVCC

MVCC 是多版本并发控制。

它通过保存数据的多个版本，让读写尽量不互相阻塞。

在 InnoDB 中，MVCC 主要依赖：

隐藏字段。
undo log。
ReadView。

常见作用是支持可重复读和快照读。

Redis

Redis 为什么这么快

常见原因：

数据主要在内存中。
使用高效数据结构。
单线程命令执行避免大量锁竞争。
IO 多路复用。
C 语言实现，执行效率高。

Redis 有哪些数据结构

常见类型：

String。
Hash。
List。
Set。
Sorted Set。
Bitmap。
HyperLogLog。
Geo。
Stream。

什么是缓存穿透

缓存穿透是请求的数据在缓存和数据库中都不存在，导致请求持续打到数据库。

解决方式：

缓存空对象。
布隆过滤器。

什么是缓存击穿

缓存击穿是热点 Key 过期瞬间，大量并发请求同时打到数据库。

解决方式：

互斥锁。
逻辑过期。

什么是缓存雪崩

缓存雪崩是大量 Key 同时过期，或者 Redis 整体不可用，导致大量请求涌向数据库。

解决方式：

过期时间加随机值。
多级缓存。
限流降级。
Redis 高可用。

Elasticsearch

什么是 Elasticsearch

Elasticsearch 是一个分布式搜索和分析引擎，常用于全文搜索、日志检索、商品搜索等场景。

它底层基于 Lucene，对外提供 REST API，支持分布式、倒排索引和复杂查询。

什么是倒排索引

倒排索引是从词到文档的映射。

普通索引更像：

文档 -> 包含哪些词

倒排索引更像：

词 -> 出现在哪些文档中

这就是 ES 做全文搜索快的重要原因。

ES 中 index、type、document 是什么

index 类似一类数据的集合。

document 是一条 JSON 数据。

type 在早期版本中用于区分类型，但新版本已经逐步移除，不建议在新项目中依赖 type。

可以类比：

ES	关系型数据库
index	table 或 database 的某种集合概念
document	row
field	column

什么是 DSL 查询

DSL 是 Elasticsearch 的查询语言，使用 JSON 描述查询条件。

示例：

es-dsl.json

{
  "query": {
    "match": {
      "title": "redis"
    }
  }
}

bool query 有哪些条件

常见条件：

must：必须匹配，影响评分。
should：可选匹配，可能影响评分。
filter：必须匹配，但不参与评分，适合过滤条件。
must_not：必须不匹配。

为什么 Elasticsearch 搜索比 MySQL 快

ES 在全文搜索场景下更快，主要因为它使用倒排索引。

MySQL 更擅长结构化数据查询和事务处理，全文检索不是它最核心的场景。

可以这样回答：

ES 会先对文本分词，再建立词到文档的倒排索引。查询关键词时，可以快速定位包含该词的文档。MySQL B+Tree 索引更适合精确匹配和范围查询，对复杂全文搜索、相关性评分和分词检索不如 ES 合适。

系统与运维基础

什么是 Docker

Docker 是容器化技术，可以把应用和依赖打包成镜像，再以容器方式运行。

它解决了“本地能跑，服务器不能跑”的环境一致性问题。

Docker 和虚拟机有什么区别

对比项	Docker	虚拟机
隔离方式	进程级隔离	硬件级虚拟化
启动速度	快	慢
资源占用	较少	较多
系统内核	共享宿主机内核	每个虚拟机有完整操作系统
适用场景	应用部署、微服务	强隔离、多系统环境

Linux 常用命令有哪些

常见命令：

linux-commands.sh

ls
cd
pwd
mkdir
rm
cp
mv
cat
tail -f app.log
grep "error" app.log
ps -ef
top
df -h
free -m
chmod
chown

面试时如果结合项目部署经历回答，会比单纯背命令更好。

什么是 REST API

REST API 是基于 REST 风格设计的接口。

它通常使用 HTTP 协议，通过 URL 表示资源，通过 HTTP 方法表示操作。

这个问题和 Spring 里的 RESTful API 本质相同。

什么是微服务架构

微服务是把一个大系统拆成多个小服务，每个服务负责一个相对独立的业务能力。

优点：

服务独立部署。
技术栈可以更灵活。
方便水平扩展。
团队边界更清晰。

缺点：

服务间调用复杂。
分布式事务困难。
监控、链路追踪、部署复杂度提高。

什么是 API 网关

API 网关是系统入口，负责把外部请求转发到内部服务。

常见功能：

路由转发。
鉴权。
限流。
熔断。
日志。
跨域处理。

项目深挖：Elasticsearch 项目

如果你的项目重点是 Elasticsearch，面试官很可能会围绕项目继续追问。

可以提前准备这些问题：

问题	准备方向
为什么项目要用 ES	MySQL 搜索能力不足、全文检索、分词、排序、性能
数据怎么同步到 ES	同步写、异步消息、定时补偿
ES 和 MySQL 数据不一致怎么办	重试、补偿任务、最终一致性
索引怎么设计	index、mapping、分词器、字段类型
搜索结果怎么排序	相关性评分、业务权重、时间、热度
查询慢怎么优化	filter、分页限制、字段选择、索引设计

面试时不要只说“我用了 ES”。更好的说法是：

我在项目中用 Elasticsearch 解决全文检索问题。MySQL 更适合事务和结构化查询，但对分词搜索、相关性排序支持有限。所以把需要搜索的数据同步到 ES，通过倒排索引提升搜索效率。项目里还需要考虑 MySQL 和 ES 的数据一致性，比如通过消息队列异步同步，并配合定时任务补偿。

学习能力问题

学习能力问题通常不会太难，但很考验真实感。

常见问题：

最近在学什么技术？
为什么选择 Java？
遇到不会的问题怎么解决？
看过哪些技术文档？
项目里最有收获的地方是什么？

回答建议：

不要只说“我在学 Java”。
要说具体学了什么、为什么学、怎么实践。
最好能和项目或面试岗位关联起来。

例如：

最近我在补 Redis 和 Elasticsearch。Redis 主要关注缓存穿透、击穿、雪崩以及数据结构的使用场景；Elasticsearch 主要学习倒排索引、DSL 查询和数据同步。因为我的项目里有搜索场景，所以我想把搜索链路和缓存链路都理解得更完整。

复习优先级

如果时间有限，可以按这个顺序准备：

Java 基础：集合、字符串、异常、反射。
MySQL：索引、事务、MVCC、索引失效。
Redis：数据结构、缓存问题、常用命令。
Spring Boot：IoC、AOP、自动配置、REST API。
JVM：内存结构、GC、OOM。
并发：线程池、锁、volatile、死锁。
Elasticsearch 项目：倒排索引、DSL、数据同步、搜索优化。
Docker 和 Linux：能讲清楚部署和常用命令即可。

小结

Java 校招面试不是只背八股。

基础题要能答清楚概念，项目题要能讲清楚自己做了什么、为什么这样做、遇到了什么问题、怎么解决。

这份清单的重点不是一次性背完，而是把每个问题都整理成三层：

一句话结论
核心原理
项目或使用场景

这样回答时会更稳，也更像真的理解过。

爬虫与 JS 逆向面试题复盘

Tue, 16 Sep 2025 00:00:00 GMT

这是一组爬虫和 JS 逆向相关的面试题。

这类面试不会只问“会不会用 requests”，更常见的是从一个具体业务场景开始追问：怎么登录、怎么抓动态接口、怎么处理反爬、百万级数据怎么调度、数据怎么进入后续处理链路。

这篇文章按面试题复盘的方式整理，重点是把回答讲得更清楚、更工程化。

同时要先明确一点：爬虫和逆向要遵守法律、站点协议和数据合规要求。面试中可以讲技术思路，但不应该表达绕过风控、攻击站点或采集敏感数据的意图。更稳的说法是：在授权范围内做数据采集和接口分析。

自动登录怎么选

题目：

登录有两种方式，一种是账号密码登录，并且需要输入动态 token；另一种是二维码登录。如果要自动登录，你会选择哪种方式，为什么？说说实现方法。

我的回答倾向是：优先选择账号密码加 token 的方式。

原因：

账号密码登录更适合程序化请求。
登录流程相对稳定，便于抓包分析。
登录成功后可以拿到 token、cookie 或 session。
二维码登录通常依赖人工扫码，不适合长期自动化任务。

可以这样回答：

我会优先选择账号密码加 token 的登录方式。因为它更容易通过请求和响应模拟，流程上可以先请求登录页或初始化接口，拿到登录所需的 token、cookie，再携带账号密码和动态 token 请求登录接口。登录成功后保存 cookie 或 access token，后续请求统一带上认证信息。二维码登录更适合人工确认，自动化成本更高，而且很多二维码登录会绑定设备、时效和扫码确认，不适合爬虫任务长期稳定运行。

一个简化流程：

请求登录页或初始化接口
   |
获取 token / csrf / cookie
   |
提交账号、密码、动态 token
   |
登录成功
   |
保存 cookie 或 access token
   |
后续请求携带认证信息

需要注意：如果动态 token 是验证码、短信码、二次验证，不能假设可以无成本自动化。面试里可以强调“在授权账号和合规场景下处理登录态”。

前端动态渲染的网站怎么爬

题目：

这种前端返回数据的网站，如何爬取数据？

现在很多网站是前端框架渲染，HTML 源码里没有完整数据。此时不要急着解析页面，而是先看网络请求。

常规步骤：

打开 Chrome DevTools。
进入 Network 面板。
过滤 XHR / Fetch 请求。
找到真正返回 JSON 数据的接口。
分析 URL、请求方法、参数、Headers、Cookie。
用 Python 模拟请求。

fetch-api-data.py

import requests

url = "https://example.com/api/list"

headers = {
    "User-Agent": "Mozilla/5.0",
    "Referer": "https://example.com/list",
}

params = {
    "page": 1,
    "size": 20,
}

response = requests.get(url, headers=headers, params=params, timeout=10)
data = response.json()

print(data)

如果接口参数是动态生成的，就继续分析 JS。

如果页面确实没有接口，或者数据必须通过浏览器运行后才出现，可以考虑 Selenium 或 Playwright。但大规模采集时，优先分析接口，因为浏览器自动化成本更高。

百万级数据怎么爬

题目：

面对百万甚至千万数据量的爬取，你的爬取策略是怎么样的？爬取到的数据如何存储？

这题考察的是系统设计，而不是单机脚本。

可以从四层回答：

任务拆分。
并发控制。
反爬与容错。
数据存储和后续处理。

一个比较完整的链路是：

任务调度 -> 爬虫采集 -> Kafka -> Flink 清洗 -> 数据存储

如果只是普通项目，可以存 MySQL 或 CSV；如果是百万、千万规模，就要考虑分批写入、去重、失败重试、数据清洗和存储扩展。

可以这样回答：

面对百万级数据，我不会用一个单机脚本顺序爬。一般会先把任务拆成分页任务、关键词任务或 ID 区间任务，放到任务队列里，由多个爬虫节点并发消费。采集时会限制请求频率，设置超时重试和代理池，避免单点 IP 或账号压力过大。采集到的数据先进入 Kafka，后续由 Flink 做实时清洗，再写入 MySQL、ES 或数据仓库。对于失败任务会记录状态，后续补偿重试。

平时用什么工具分析网站接口

常用 Chrome DevTools 的 Network 面板。

主要看：

XHR / Fetch 请求。
请求 URL。
请求方法。
Query 参数和 Request Payload。
Headers。
Cookie。
Response。
Initiator 调用来源。

如果参数是动态生成的，会继续去 Sources 面板断点调试，或在 JS 文件中搜索参数名。

如何判断网站是否有反爬

可以从几个现象判断：

请求参数里存在动态加密参数。
接口依赖 token、cookie、签名或时间戳。
请求频率过高会被封 IP。
返回内容出现验证码、空数据或风控页面。
同一个接口在浏览器能访问，程序请求失败。
Headers 缺失时返回异常。

可以这样回答：

我会先比较浏览器正常请求和程序模拟请求的差异。如果同样的 URL 在浏览器里返回正常，但程序里返回空数据、验证码、403 或风控响应，就说明可能存在反爬。再继续分析是否有动态参数、token 校验、cookie 校验、频率限制或行为检测。

XPath 和 CSS Selector 的区别

XPath 和 CSS Selector 都能定位 HTML 节点。

对比项	XPath	CSS Selector
语法	类似路径表达式	类似 CSS 选择器
能力	更强，支持轴、文本、复杂路径	简洁，适合常见选择
可读性	复杂表达式可读性一般	简单场景更清晰
爬虫常用度	很常用	也常用

面试可以说：

简单页面我会用 CSS Selector，因为语法简洁；复杂定位，比如按文本、层级、相邻节点查找时，我更倾向 XPath。

做过 JS 逆向吗

可以按流程回答：

使用 Network 抓包找到目标接口。
确认哪个参数是动态生成的。
全局搜索参数名。
在 Sources 面板下断点。
观察 Call Stack 调用链。
找到最终生成参数的函数。
用 Python 或 Node 复现算法。

更完整的回答：

我在项目中遇到过接口参数由 JS 加密生成的情况。处理时先通过 Network 找到接口和异常参数，然后在 JS 文件中搜索参数名。如果搜索不到，就从请求发起位置或 XHR 断点入手，在 Sources 里下断点，结合 Call Stack 分析调用链，找到参数生成函数。确定算法后，再用 Python 或 Node 复现，最后和浏览器生成结果对比，确保请求参数一致。

这类回答要强调“分析和复现授权接口参数”，不要说成攻击或绕过安全系统。

JS 混淆怎么分析

JS 混淆后，变量名和函数名可能没有意义，所以不要期待完全看懂所有代码。

常见思路：

不全量还原，只找关键链路。
通过 XHR/fetch 断点定位请求发起位置。
使用 Call Stack 看调用链。
打印关键变量。
对关键函数做输入输出对比。
必要时把关键函数拎出来运行。

可以这样回答：

遇到混淆 JS 时，我不会从头读完整文件，而是围绕目标接口定位关键参数。通过断点、调用栈、关键变量打印和函数输入输出分析，逐步缩小范围，最终定位生成参数的函数。

为什么不用 Selenium

Selenium 是浏览器自动化工具，适合复杂页面、需要真实浏览器环境的场景。

但它的问题也明显：

启动浏览器成本高。
并发能力弱。
资源占用大。
速度慢。
大规模采集不划算。

所以一般优先分析接口直接请求。只有接口很难复现、页面强依赖浏览器环境、或需要真实交互时，才考虑 Selenium 或 Playwright。

面试回答：

Selenium 可以用，但我不会作为首选。因为大规模采集更关注吞吐和稳定性，直接请求接口效率更高。Selenium 更适合登录、复杂交互或无法绕开浏览器渲染的页面。

如何保证爬虫长期稳定运行

长期稳定运行靠的不是一个脚本，而是容错和监控。

常见机制：

请求超时。
失败重试。
指数退避。
异常捕获。
失败任务记录。
账号状态检测。
IP 或代理状态检测。
任务监控。
健康检查。
失败告警。

可以这样回答：

我会为爬虫设计超时重试、异常捕获、失败任务记录和任务监控机制。如果请求失败，会根据错误类型决定重试、切换账号、切换代理或标记任务失败。系统层面会有健康监测和失败上报，保证爬虫可以长期稳定运行。

爬虫规模是多少

如果项目里支持 500万+ / 日 的采集规模，可以这样回答：

系统支持 500 万以上日采集量。采集任务不是由单个脚本完成，而是通过任务调度系统统一拆分和分发，多节点并发执行。采集结果进入 Kafka，再由 Flink 进行实时清洗和处理。

面试时不要只报数字，最好补上支撑数字的架构。

系统架构是什么

整体链路可以这样描述：

调度系统
   |
   v
爬虫节点
   |
   v
Kafka
   |
   v
Flink
   |
   v
MySQL / Elasticsearch / 数据仓库

各模块职责：

模块	作用
调度系统	生成任务、分配任务、协调账号
爬虫节点	执行采集、解析数据、处理重试
Kafka	解耦采集和处理，缓冲流量
Flink	实时清洗、过滤、转换
存储层	存储清洗后的业务数据

这类回答会比“我用 Scrapy 分布式”更有工程感。

调度系统怎么工作

调度系统主要负责任务生成和账号协调。

你笔记中的规模是：

1400+ 爬虫任务。
400+ 账号 Cookie。
任务信息存储在 Redis。

可以这样回答：

调度系统会把采集目标拆成具体任务，任务状态存储在 Redis 中。爬虫节点从 Redis 获取任务，执行后回写任务状态。账号 Cookie 也由调度系统统一管理，分配任务时会根据账号状态选择可用账号，避免单个账号压力过大。

为什么任务放 Redis

Redis 适合做任务队列和状态缓存。

原因：

读写性能高。
支持 List、Set、Hash、Sorted Set 等结构。
适合存任务状态、账号状态和临时调度数据。
操作简单，延迟低。

可以补一句：

如果任务需要更强的可靠性、确认机制和重试语义，也可以引入消息队列；Redis 更适合轻量级任务调度和状态管理。

如何处理账号失效

账号失效的表现：

登录失败。
Cookie 失效。
返回 401、403。
返回验证码或风控页面。
请求结果为空或异常。

处理方式：

标记账号不可用。
暂停该账号任务。
重新调度任务。
切换可用账号。
触发重新登录或人工处理。

可以这样回答：

系统会根据响应状态和页面内容判断账号是否异常。一旦发现 Cookie 失效或登录状态异常，就标记账号状态，避免继续分配任务，同时把未完成任务重新放回队列，交给其他可用账号处理。

Python 爬虫常用库

常用库：

requests：发送 HTTP 请求。
httpx：支持同步和异步请求。
scrapy：爬虫框架。
lxml：解析 HTML，支持 XPath。
beautifulsoup4：HTML 解析。
selenium：浏览器自动化。
playwright：现代浏览器自动化。

项目里如果主要使用 requests + XPath，可以这样说：

普通接口采集我主要使用 requests，请求接口后用 XPath 或 JSON 解析数据。如果是复杂任务调度和大规模采集，会考虑 Scrapy 或自研调度系统。

如何处理请求超时

基本做法：

request-timeout.py

import requests

try:
    response = requests.get(
        "https://example.com/api",
        timeout=(3, 10),
    )
    response.raise_for_status()
except requests.Timeout:
    # 记录超时并重试
    pass
except requests.RequestException:
    # 记录其他请求异常
    pass

可以配合：

固定次数重试。
指数退避。
失败任务入库。
切换代理或账号。

如何控制爬虫速度

常见方式：

设置请求间隔。
限制并发数量。
使用任务队列控制消费速度。
对单域名限速。
对单账号限速。
对异常响应动态降速。

面试里可以说：

控制速度不只是 sleep，而是结合并发数、任务队列、账号维度和站点响应来动态调整，避免触发反爬，也保护目标站点和自身系统。

为什么使用 Docker

Docker 的价值：

保证运行环境一致。
方便部署。
方便横向扩展多个爬虫节点。
便于隔离依赖。
适合配合 CI/CD。

爬虫系统里尤其适合把爬虫节点容器化。需要扩容时，可以快速启动多个容器实例。

Kafka 在系统中作用

Kafka 主要承担数据通道和缓冲层。

作用：

解耦采集和处理。
缓冲高峰流量。
支持高吞吐数据传输。
方便后续多个消费者处理数据。

可以这样回答：

爬虫采集速度和后续清洗入库速度不一定一致，所以中间用 Kafka 解耦。爬虫只负责把原始数据写入 Kafka，Flink 再从 Kafka 消费并清洗处理。

Redis 在项目中用来做什么

Redis 在项目中可以承担：

任务队列。
任务状态缓存。
账号 Cookie 管理。
去重集合。
临时失败记录。
限速计数。

面试回答：

Redis 主要用于调度层，保存任务队列、任务状态和账号 Cookie。因为它读写快，并且数据结构丰富，适合管理这种高频变化的临时状态。

项目中最难的部分是什么

可以回答 JS 加密参数逆向。

更完整的说法：

最难的是 JS 加密参数逆向。因为网站 JS 做了混淆，不能直接通过阅读代码看懂逻辑。我通过 Network 定位接口和动态参数，再用 Sources 下断点，结合调用栈分析参数生成流程，最后把关键算法用 Python 或 Node 复现出来。这个过程比较考验调试能力和耐心。

如果网站增加新的反爬怎么办

处理步骤：

先复现问题，确认是哪些请求失败。
对比正常浏览器请求和爬虫请求差异。
判断新增机制：token、cookie、签名、频率、验证码、行为检测。
如果是参数变化，重新调试 JS。
如果是频率问题，调整限速和调度策略。
如果涉及强验证或合规风险，停止采集或走授权接口。

可以这样回答：

我会先分析新增反爬属于哪一类，再决定策略。如果是参数签名变化，就重新定位 JS 生成逻辑；如果是频率限制，就降低并发、调整账号和代理策略；如果是登录态或 Cookie 变化，就更新账号状态检测和重新登录流程。对于验证码或强风控场景，需要评估合规性，不能盲目绕过。

面试回答模板

如果面试官让你整体介绍这个爬虫项目，可以这样组织：

这个项目主要做大规模数据采集。整体链路是爬虫采集、Kafka 缓冲、Flink 清洗、最终写入存储。爬虫侧通过 Chrome DevTools 分析接口，优先直接请求接口而不是 Selenium。调度系统负责管理 1400 多个任务和 400 多个账号 Cookie，任务状态存储在 Redis。系统支持超时重试、失败任务记录、账号失效检测和健康监控。项目中比较难的是 JS 加密参数逆向，我通过断点调试、调用栈分析和算法复现解决过接口动态参数问题。

小结

爬虫和逆向面试题，重点不是只会某个库，而是能把采集链路讲完整：

接口分析 -> 登录态处理 -> 参数逆向 -> 任务调度 -> 并发控制 -> 数据通道 -> 清洗入库 -> 监控补偿

如果能把这条链路讲清楚，再结合自己实际做过的规模、账号调度、Kafka/Flink、Redis 和 Docker，回答就会更像真实项目经验，而不是零散知识点。

一道 gRPC 简易计算器面试题复盘

Fri, 11 Apr 2025 00:00:00 GMT

这是我曾经做过的一道面试题中的一个小项目：用 Go + gRPC + gRPC-Web + Next.js 做一个简易计算器。

题目本身不复杂，只有加、减、乘、除四种运算。但它真正考察的不是“会不会写计算器”，而是能不能把前后端通信、接口契约、错误处理和跨端调用讲清楚。

项目地址：GolangNextGrpcSimpleCalculator

题目要做什么

这道题可以理解为：

前端输入两个数字和一个运算符，通过 gRPC-Web 调用 Go 后端，后端完成计算并返回结果。

最小功能闭环包括：

前端页面可以输入两个操作数。
前端可以选择 +、-、*、/ 四种运算符。
前端通过 gRPC-Web 调用后端。
后端使用 Go 实现 gRPC 服务。
后端根据请求参数返回计算结果。
除数为 0 或未知运算符时，需要返回错误。

如果只是做一个普通 HTTP 接口，这题可能很快就结束了。但这里要求使用 gRPC，就会多出一层“接口契约”的设计：前后端都要围绕 .proto 文件生成代码。

项目结构

这个项目大致可以拆成两部分：

calculator-backend/
- calculator/
  - calculator.proto
- main.go
- calculator_test.go
- go.mod
calculator-frontend/
- app/
  - generated/
    calculator/
    …
  - page.tsx
- calculator/
  - calculator.proto
- package.json

后端负责定义和实现计算服务，前端负责生成 gRPC-Web 客户端代码并发起调用。

这里最核心的文件有三个：

文件	作用
`calculator.proto`	定义服务、请求结构、响应结构
`main.go`	实现 Go gRPC 服务，并包装成 gRPC-Web HTTP 服务
`page.tsx`	在 Next.js 页面中创建请求并调用后端

先定义接口契约

gRPC 的入口通常不是先写控制器，而是先写 .proto。

calculator.proto

syntax = "proto3";

package calculator;

option go_package = "github.com/2760439882/calculator-backend/calculator;calculator";

service Calculator {
  rpc Calculate(CalculationRequest) returns (CalculationResponse);
}

message CalculationRequest {
  double operand1 = 1;
  double operand2 = 2;
  string operator = 3; // "+", "-", "*", "/"
}

message CalculationResponse {
  double result = 1;
}

这份协议里有三个关键信息：

Calculator 是服务名。
Calculate 是远程调用方法。
CalculationRequest 和 CalculationResponse 分别是请求和响应结构。

这就是 gRPC 和普通 REST 接口很不一样的地方。REST 接口经常先约定 URL 和 JSON 字段，而 gRPC 会先约定服务方法和强类型消息结构。

后端实现计算服务

后端使用 Go 实现 Calculator 服务。

main.go

type server struct {
    pb.UnimplementedCalculatorServer
}

func (s *server) Calculate(
    ctx context.Context,
    req *pb.CalculationRequest,
) (*pb.CalculationResponse, error) {
    var result float64

    switch req.Operator {
    case "+":
        result = req.Operand1 + req.Operand2
    case "-":
        result = req.Operand1 - req.Operand2
    case "*":
        result = req.Operand1 * req.Operand2
    case "/":
        if req.Operand2 == 0 {
            return nil, fmt.Errorf("division by zero")
        }
        result = req.Operand1 / req.Operand2
    default:
        return nil, fmt.Errorf("unknown operator")
    }

    return &pb.CalculationResponse{Result: result}, nil
}

这段实现很适合面试时讲，因为它虽然简单，但覆盖了服务端接口实现的几个基本点：

方法签名来自 .proto 生成代码。
请求参数来自 CalculationRequest。
返回值必须符合 CalculationResponse。
错误可以通过 error 返回给调用方。
除法需要额外处理除数为 0 的情况。

真正的业务逻辑只有一个 switch，但重点是：这个 switch 被放在了 gRPC 服务方法里，前端不会直接知道后端怎么计算，只知道自己要调用 Calculate。

为什么要用 gRPC-Web

浏览器不能像 Go、Java、Node 服务端那样直接发起原生 gRPC 请求。原生 gRPC 基于 HTTP/2，而浏览器端直接使用 gRPC 会受到限制。

所以前端调用 gRPC 服务时，通常需要一层 gRPC-Web。

这个项目里，Go 后端把原始 gRPC 服务包装成了 gRPC-Web 服务：

main.go

grpcServer := grpc.NewServer()
pb.RegisterCalculatorServer(grpcServer, &server{})

wrappedGrpc := grpcweb.WrapServer(grpcServer)

httpServer := http.Server{
    Addr: ":8080",
    Handler: cors.New(cors.Options{
        AllowedOrigins: []string{"http://localhost:3000"},
        AllowedMethods: []string{"GET", "POST", "OPTIONS"},
        AllowedHeaders: []string{
            "Content-Type",
            "X-Grpc-Web",
            "X-User-Agent",
            "grpc-timeout",
        },
        AllowCredentials: true,
    }).Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if wrappedGrpc.IsGrpcWebRequest(r) ||
            wrappedGrpc.IsAcceptableGrpcCorsRequest(r) ||
            wrappedGrpc.IsGrpcWebSocketRequest(r) {
            wrappedGrpc.ServeHTTP(w, r)
            return
        }

        http.NotFound(w, r)
    })),
}

这里有两个面试时值得说清楚的点。

第一，后端并不是直接写一个普通 HTTP JSON 接口，而是先创建 grpc.NewServer()，再通过 grpcweb.WrapServer() 包装。

第二，因为前端运行在 http://localhost:3000，后端运行在 http://localhost:8080，所以需要配置 CORS。否则浏览器会先把请求挡掉，根本到不了 gRPC-Web 服务。

前端如何调用

前端是 Next.js 页面。因为要在浏览器里响应用户输入和发起请求，所以页面文件使用了 'use client'。

page.tsx

'use client';

import { useState } from 'react';
import { CalculatorClient } from './generated/calculator/calculator_grpc_web_pb';
import { CalculateRequest } from './generated/calculator/calculator_pb';

const client = new CalculatorClient('http://localhost:8080', null, null);

export default function Home() {
  const [operand1, setOperand1] = useState('');
  const [operand2, setOperand2] = useState('');
  const [operator, setOperator] = useState('+');
  const [result, setResult] = useState<number | null>(null);
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(false);

  const handleCalculate = () => {
    setLoading(true);
    setResult(null);
    setError(null);

    const req = new CalculateRequest();
    req.setOperand1(parseFloat(operand1));
    req.setOperand2(parseFloat(operand2));
    req.setOperator(operator);

    client.calculate(req, {}, (err, response) => {
      setLoading(false);

      if (err) {
        setError('请求失败: ' + err.message);
        return;
      }

      setResult(response.getResult());
    });
  };
}

这里的关键不是 useState，而是这三步：

使用生成的 CalculatorClient 创建客户端。
使用生成的 CalculateRequest 创建请求对象。
调用 client.calculate()，在回调里处理结果或错误。

这说明前端并没有手写请求路径、请求体字段和响应解析逻辑。它依赖 .proto 生成的代码来保证调用结构一致。

这道题真正考什么

如果把这道题当成面试题看，它主要考察下面几类能力。

考点	具体体现
gRPC 基础	是否知道 `.proto`、service、message、生成代码
前后端通信	是否知道浏览器不能直接使用原生 gRPC，需要 gRPC-Web
Go 服务端	是否能注册服务、实现接口、启动服务
错误处理	是否处理除数为 `0`、未知运算符、请求失败
跨域问题	是否知道前后端端口不同会触发 CORS
工程意识	是否能把生成代码、后端代码、前端代码分清楚

所以面试时不要只说“我实现了一个计算器”。更好的说法是：

我用 .proto 定义了计算服务和消息结构，再用 Go 实现 gRPC 服务。因为前端运行在浏览器里，不能直接调用原生 gRPC，所以后端用 gRPC-Web 包装了一层 HTTP 服务，并配置 CORS。前端通过生成的 gRPC-Web Client 创建请求对象，调用后端的 Calculate 方法，最后处理成功结果和错误信息。

这段回答会比“我写了加减乘除”更能说明你理解了题目。

可以继续优化的地方

这个项目作为面试题已经能跑通主流程，但如果继续完善，可以从下面几个方向补强。

第一，输入校验可以提前放在前端。

现在前端直接对输入值 parseFloat()。如果用户没有输入数字，可能得到 NaN。可以在发请求前判断两个操作数是否合法。

第二，后端错误可以使用 gRPC status。

当前代码使用 fmt.Errorf() 返回错误。实际项目里可以使用 status.Error() 搭配 codes.InvalidArgument，这样调用方可以更准确地区分错误类型。

return nil, status.Error(codes.InvalidArgument, "division by zero")

第三，运算符可以使用枚举。

当前 operator 是字符串，优点是直观，缺点是容易传入非法值。如果要更严谨，可以在 .proto 中定义 enum。

enum Operator {
  OPERATOR_UNSPECIFIED = 0;
  ADD = 1;
  SUBTRACT = 2;
  MULTIPLY = 3;
  DIVIDE = 4;
}

第四，配置可以抽出来。

前端里的 http://localhost:8080 和后端 CORS 里的 http://localhost:3000 都是开发环境地址。后续如果部署，最好放进环境变量里。

面试时怎么讲

这道题可以按四步讲：

先说题目目标：前端输入表达式，后端通过 gRPC 完成计算。
再说接口契约：用 .proto 定义 Calculate 方法、请求和响应。
接着说后端实现：Go 实现服务，处理四种运算和异常情况。
最后说浏览器调用：使用 gRPC-Web 生成客户端，前端发起请求并处理结果。

如果面试官继续追问，可以展开这几个点：

gRPC 和 REST 的区别是什么？
为什么浏览器需要 gRPC-Web？
.proto 文件改了以后要做什么？
如果除数为 0，应该怎么返回错误？
如果以后要支持更多运算，应该怎么扩展？

小结

这个项目的价值不在于计算器本身，而在于它用一个很小的功能，把 gRPC 项目里最关键的链路串起来了：

proto 定义 -> 生成代码 -> Go 实现服务 -> gRPC-Web 包装 -> 前端调用 -> 展示结果

对于面试题来说，这种项目很合适。它足够小，能在有限时间内完成；同时又能覆盖接口设计、后端实现、前端调用、跨域和错误处理这些真实工程里会遇到的问题。

React 父子组件通信面试题复盘

Mon, 01 Jan 2024 00:00:00 GMT

这是我曾经遇到过的一道 React 面试题，问题很常见：

React 父子组件之间如何通信？

这个问题看起来很基础，但其实很适合继续追问。因为它背后不只是 props 怎么传，而是 React 的数据流、状态放在哪里、组件边界怎么设计、什么时候用 Context、什么时候才需要状态管理库。

如果只是回答“父传子用 props，子传父用回调函数”，当然没错，但面试里还不够。更好的回答应该能顺着这个问题，把 React 的单向数据流讲清楚。

最直接的回答

React 默认是单向数据流。

父组件可以通过 props 把数据传给子组件；子组件不能直接修改父组件的数据，如果子组件需要影响父组件，就由父组件传一个函数给子组件，子组件调用这个函数，把变化通知给父组件。

可以先用一句话概括：

父传子用 props，子传父用回调函数；如果兄弟组件之间要通信，就把状态提升到它们共同的父组件。

这是这道题的核心答案。

父组件向子组件传值

父传子最简单，就是把数据作为 props 传给子组件。

Parent.tsx

type User = {
  id: number;
  name: string;
};

function Parent() {
  const user: User = {
    id: 1,
    name: 'xiaoxi',
  };

  return <UserCard user={user} />;
}

type UserCardProps = {
  user: User;
};

function UserCard({ user }: UserCardProps) {
  return (
    <section>
      <h2>{user.name}</h2>
      <p>ID: {user.id}</p>
    </section>
  );
}

这里的数据方向很清楚：

Parent state/data -> props -> Child render

子组件只负责接收和展示，不负责决定这个数据从哪里来。

子组件通知父组件

子组件不能直接修改父组件内部的 state。如果子组件需要触发父组件更新，就由父组件把更新函数传下去。

Counter.tsx

import { useState } from 'react';

function Parent() {
  const [count, setCount] = useState(0);

  const handleAdd = () => {
    setCount((value) => value + 1);
  };

  return (
    <div>
      <p>当前数量：{count}</p>
      <CounterButton onAdd={handleAdd} />
    </div>
  );
}

type CounterButtonProps = {
  onAdd: () => void;
};

function CounterButton({ onAdd }: CounterButtonProps) {
  return <button onClick={onAdd}>加一</button>;
}

这个过程可以理解为：

Child click -> call props function -> Parent setState -> Child receives new props

也就是说，子组件并没有“改父组件”，它只是触发了父组件提供的回调。

子组件把数据传给父组件

有时候子组件不只是触发动作，还需要把自己的数据交给父组件。

比如搜索框输入内容，父组件需要拿到关键词：

SearchBox.tsx

import { useState } from 'react';

function Parent() {
  const [keyword, setKeyword] = useState('');

  return (
    <div>
      <SearchBox onSearch={setKeyword} />
      <p>当前搜索词：{keyword}</p>
    </div>
  );
}

type SearchBoxProps = {
  onSearch: (keyword: string) => void;
};

function SearchBox({ onSearch }: SearchBoxProps) {
  const [value, setValue] = useState('');

  const handleSubmit = () => {
    onSearch(value);
  };

  return (
    <div>
      <input value={value} onChange={(event) => setValue(event.target.value)} />
      <button onClick={handleSubmit}>搜索</button>
    </div>
  );
}

这里的 onSearch(value) 就是典型的子传父。

面试时可以强调：React 里子传父不是反向修改数据，而是调用父组件传入的回调。

状态提升

如果两个兄弟组件需要共享数据，通常不是让它们互相调用，而是把状态提升到共同父组件。

StateLifting.tsx

import { useState } from 'react';

function Parent() {
  const [selectedId, setSelectedId] = useState<number | null>(null);

  return (
    <div>
      <ProductList onSelect={setSelectedId} />
      <ProductDetail productId={selectedId} />
    </div>
  );
}

type ProductListProps = {
  onSelect: (id: number) => void;
};

function ProductList({ onSelect }: ProductListProps) {
  return (
    <ul>
      <li onClick={() => onSelect(1)}>商品 1</li>
      <li onClick={() => onSelect(2)}>商品 2</li>
    </ul>
  );
}

type ProductDetailProps = {
  productId: number | null;
};

function ProductDetail({ productId }: ProductDetailProps) {
  if (productId === null) return <p>请选择一个商品</p>;

  return <p>当前商品 ID：{productId}</p>;
}

这就是 React 组件设计里很重要的一点：状态应该放在需要它的最小公共父组件中。

如果状态只属于一个组件，就放在这个组件内部；如果多个子组件都要用，就提升到公共父组件；如果很多层都要用，再考虑 Context 或状态管理库。

受控组件也是父子通信

表单场景里，受控组件其实也是父子通信的一种体现。

父组件控制输入框的值，子组件只负责展示和触发修改。

ControlledInput.tsx

import { useState } from 'react';

function Parent() {
  const [email, setEmail] = useState('');

  return <EmailInput value={email} onChange={setEmail} />;
}

type EmailInputProps = {
  value: string;
  onChange: (value: string) => void;
};

function EmailInput({ value, onChange }: EmailInputProps) {
  return (
    <input
      value={value}
      onChange={(event) => onChange(event.target.value)}
      placeholder="请输入邮箱"
    />
  );
}

这里的核心是：

value 从父组件传给子组件。
onChange 从父组件传给子组件。
子组件触发 onChange，父组件更新状态。
新状态再通过 value 传回来。

所以受控组件不是“输入框自己管理值”，而是父组件管理值。

跨层级通信：Context

如果只是父子组件通信，不需要上来就用 Context。

但如果数据需要跨很多层传递，比如主题、登录用户、语言配置，就可以考虑 Context。

ThemeContext.tsx

import { createContext, useContext } from 'react';

type Theme = 'light' | 'dark';

const ThemeContext = createContext<Theme>('light');

function App() {
  return (
    <ThemeContext.Provider value="dark">
      <Layout />
    </ThemeContext.Provider>
  );
}

function Layout() {
  return <Toolbar />;
}

function Toolbar() {
  const theme = useContext(ThemeContext);

  return <button className={theme}>保存</button>;
}

Context 解决的是 props drilling，也就是一层层传 props 的问题。

但是它不应该被滥用。不是所有父子通信都需要 Context。对于很近的父子组件，直接用 props 更清楚。

ref 和命令式调用

有些场景不是传数据，而是父组件需要调用子组件暴露出来的方法。

比如父组件点击按钮，让子组件内部的输入框聚焦。

这时可以使用 forwardRef 和 useImperativeHandle。

FocusInput.tsx

import { forwardRef, useImperativeHandle, useRef } from 'react';

type FocusInputRef = {
  focus: () => void;
};

const FocusInput = forwardRef<FocusInputRef>(function FocusInput(_, ref) {
  const inputRef = useRef<HTMLInputElement>(null);

  useImperativeHandle(ref, () => ({
    focus() {
      inputRef.current?.focus();
    },
  }));

  return <input ref={inputRef} placeholder="请输入内容" />;
});

function Parent() {
  const inputRef = useRef<FocusInputRef>(null);

  return (
    <div>
      <FocusInput ref={inputRef} />
      <button onClick={() => inputRef.current?.focus()}>聚焦输入框</button>
    </div>
  );
}

不过这种方式要谨慎使用。

React 更推荐声明式的数据流。ref 更适合处理 DOM、聚焦、滚动、播放控制这类命令式场景，不适合作为普通业务数据通信的首选方案。

性能相关：回调函数会不会导致重复渲染

面试官可能继续问：父组件每次渲染都会创建新的回调函数，会不会导致子组件重复渲染？

答案是：可能会，但要结合场景看。

如果子组件使用了 memo，并且传入的回调函数每次都是新引用，子组件可能仍然会重新渲染。这时可以使用 useCallback 稳定函数引用。

MemoCallback.tsx

import { memo, useCallback, useState } from 'react';

const Child = memo(function Child({ onAdd }: { onAdd: () => void }) {
  return <button onClick={onAdd}>加一</button>;
});

function Parent() {
  const [count, setCount] = useState(0);

  const handleAdd = useCallback(() => {
    setCount((value) => value + 1);
  }, []);

  return (
    <div>
      <p>{count}</p>
      <Child onAdd={handleAdd} />
    </div>
  );
}

但不要为了“看起来专业”到处写 useCallback。如果子组件没有性能问题，或者没有使用 memo，盲目使用 useCallback 反而会增加理解成本。

什么时候用状态管理库

父子通信、兄弟通信、跨层级通信，本质上都是状态在哪里的问题。

可以按下面的顺序判断：

场景	推荐方式
父组件给子组件数据	`props`
子组件通知父组件	回调函数
兄弟组件共享状态	状态提升
多层组件共享稳定数据	`Context`
大量页面共享复杂业务状态	Zustand、Redux、Jotai 等状态管理库

状态管理库不是为了替代 props，而是为了解决更大范围、更复杂的数据共享和更新问题。

比如用户信息、购物车、权限、全局弹窗、复杂筛选条件，这类状态可能会跨多个页面或模块使用，就可以考虑状态管理库。

面试时怎么回答

这道题可以这样回答：

React 是单向数据流。父组件向子组件传值用 props；子组件想影响父组件时，父组件传回调函数给子组件，子组件调用回调并把数据传回去。如果兄弟组件需要共享状态，就把状态提升到共同父组件。如果跨层级传递太深，可以用 Context；如果是跨页面、跨模块的复杂共享状态，再考虑 Redux、Zustand 这类状态管理库。特殊情况下，父组件需要调用子组件内部方法，可以用 ref、forwardRef 和 useImperativeHandle，但这更适合聚焦、滚动这类命令式场景，不是普通数据通信的首选。

如果面试官继续追问，可以展开这些点：

React 为什么强调单向数据流？
状态提升解决什么问题？
Context 和状态管理库有什么区别？
受控组件为什么也是父子通信？
ref 能不能替代 props？
useCallback 是否一定能优化性能？

小结

React 父子通信这道题看似基础，但它可以引申到很多 React 核心思想：

数据从父组件流向子组件。
子组件通过回调通知父组件。
多个组件共享状态时，优先状态提升。
跨层级共享再考虑 Context。
复杂全局状态再考虑状态管理库。
ref 是命令式能力，不是普通数据流的替代品。

所以这道题最重要的不是记住几个 API，而是理解 React 组件之间的数据边界：谁拥有状态，谁负责修改状态，谁只是接收状态并渲染。

Redis 缓存穿透、击穿、雪崩面试题复盘

Mon, 01 Jan 2024 00:00:00 GMT

这是 Redis 面试里非常高频的一类问题：

什么是缓存穿透、缓存击穿和缓存雪崩？它们有什么区别？应该怎么解决？

这三个概念很容易混在一起，因为它们的结果都可能是“请求打到数据库，数据库压力变大”。但它们的根因完全不同。

可以先用一句话区分：

穿透：查的数据根本不存在。
击穿：一个热点 Key 过期。
雪崩：大量 Key 同时过期，或者 Redis 整体不可用。

缓存穿透

缓存穿透指的是：请求的数据在缓存中不存在，在数据库中也不存在。

比如：

请求一个不存在的用户 ID：id = -1
请求一个已经删除的商品
恶意攻击者构造大量非法参数

正常缓存流程一般是：

请求 -> 查 Redis -> Redis 没有 -> 查数据库 -> 写入 Redis -> 返回数据

但如果数据根本不存在，就会变成：

请求 -> 查 Redis -> Redis 没有 -> 查数据库 -> 数据库也没有 -> 返回空

问题在于：下一次同样的非法请求过来，Redis 里还是没有，于是又会打到数据库。

如果有人构造大量不存在的 ID，请求就会绕过缓存，持续打到数据库。

穿透的解决方案

缓存穿透常见有两种解决方案：缓存空对象和布隆过滤器。

缓存空对象

当数据库查不到数据时，也往 Redis 里写一个空值或特殊值，并设置较短过期时间。

cache-null.js

async function getUser(id) {
  const cacheKey = `user:${id}`;

  const cached = await redis.get(cacheKey);
  if (cached !== null) {
    return cached === 'NULL' ? null : JSON.parse(cached);
  }

  const user = await db.queryUserById(id);

  if (!user) {
    await redis.set(cacheKey, 'NULL', 'EX', 60);
    return null;
  }

  await redis.set(cacheKey, JSON.stringify(user), 'EX', 3600);
  return user;
}

这样下一次请求同一个不存在的 ID，就会被 Redis 拦住，不会继续打数据库。

它的优点是简单，缺点是如果恶意请求的非法 ID 极多，Redis 里会出现很多空值缓存。所以空值缓存的过期时间一般要短一些。

布隆过滤器

布隆过滤器适合在请求进入缓存和数据库之前，先判断这个数据是否可能存在。

请求 userId
   |
   v
布隆过滤器判断
   |
   | 不存在 -> 直接拒绝
   |
   | 可能存在
   v
查 Redis / DB

布隆过滤器的特点是：

如果它判断不存在，那就一定不存在。
如果它判断存在，只能说明可能存在。

所以它适合挡掉大量明显非法的请求。

面试里可以这样说：缓存空对象适合兜住少量不存在数据，布隆过滤器适合在入口处拦截大量非法 Key。

缓存击穿

缓存击穿指的是：某一个热点 Key 在过期瞬间，大量并发请求同时打到数据库。

注意，击穿通常是单个 Key。

比如：

某个大促商品详情页
某个热门直播间信息
某个高访问量用户主页
某条热点新闻

这个 Key 平时在 Redis 里，所以数据库压力不大。

但它刚好过期时，大量请求同时进来，发现 Redis 没有，于是一起查数据库。

热点 Key 过期
   |
大量请求同时进入
   |
Redis 都没查到
   |
全部打到数据库

这就是缓存击穿。

击穿的解决方案

缓存击穿常见有两种方案：互斥锁和逻辑过期。

互斥锁

互斥锁的思路是：同一时间只允许一个线程去查数据库并重建缓存，其他线程等待或重试。

mutex-lock.js

async function getProduct(id) {
  const cacheKey = `product:${id}`;
  const lockKey = `lock:product:${id}`;

  const cached = await redis.get(cacheKey);
  if (cached) return JSON.parse(cached);

  const locked = await redis.set(lockKey, '1', 'NX', 'EX', 10);

  if (!locked) {
    await sleep(50);
    return getProduct(id);
  }

  try {
    const product = await db.queryProductById(id);
    await redis.set(cacheKey, JSON.stringify(product), 'EX', 3600);
    return product;
  } finally {
    await redis.del(lockKey);
  }
}

这个方案可以保护数据库，但会让部分请求等待，接口耗时可能变长。

逻辑过期

逻辑过期的思路是：Redis 里的数据不设置物理过期，或者设置很长的物理过期；真正的过期时间写在 value 里。

logical-expire-value.json

{
  "data": {
    "id": 1,
    "name": "热门商品"
  },
  "expireAt": "2026-05-20T20:00:00+08:00"
}

请求到来时：

如果逻辑时间没过期，直接返回数据。
如果逻辑时间过期，当前线程尝试拿锁。
拿到锁的线程异步重建缓存。
当前请求先返回旧数据。

查到缓存
   |
判断逻辑过期
   |
已过期 -> 尝试加锁 -> 异步重建缓存
   |
直接返回旧数据

它的优点是响应速度更稳，不会让大量请求等待数据库。

缺点是用户可能短时间看到旧数据，所以它更适合对实时性要求不那么高的热点数据。

缓存雪崩

缓存雪崩指的是：大量 Key 在同一时间过期，或者 Redis 服务不可用，导致大量请求同时打到数据库。

它和击穿的区别是：

击穿是单个热点 Key。
雪崩是大量 Key，或者缓存层整体出问题。

比如：

批量导入缓存时设置了相同过期时间。
活动开始前预热了一批商品缓存，过期时间完全一样。
Redis 宕机或网络故障。
Redis 集群大面积不可用。

雪崩的危害比击穿更大，因为它不是一个点，而是一片。

雪崩的解决方案

缓存雪崩通常要从多个层面解决。

过期时间加随机值

不要让大量 Key 设置完全一样的过期时间。

random-expire.js

const baseTtl = 3600;
const randomTtl = Math.floor(Math.random() * 300);

await redis.set(cacheKey, value, 'EX', baseTtl + randomTtl);

这样可以把过期时间打散，避免某一秒大量 Key 同时失效。

多级缓存

可以在 Redis 前面加本地缓存，比如 Caffeine、Guava Cache 或进程内缓存。

请求 -> 本地缓存 -> Redis -> 数据库

即使 Redis 短时间抖动，本地缓存也能顶住一部分热点请求。

不过本地缓存也会带来一致性问题，所以一般只适合热点数据或允许短暂不一致的数据。

服务降级和限流

当数据库压力过大时，不能让所有请求继续堆积。

可以做：

数据库访问限流。
熔断降级。
返回兜底数据。
返回“服务器繁忙，请稍后再试”。

降级不是偷懒，而是在系统压力过大时保护核心链路。

Redis 高可用

如果雪崩原因是 Redis 宕机，就需要高可用架构。

常见方案：

Redis 主从复制。
哨兵模式。
Redis Cluster。
多机房或多可用区部署。

高可用解决的是缓存服务不可用的问题，过期时间随机解决的是大量 Key 同时失效的问题。两者关注点不同。

三者对比

维度	缓存穿透	缓存击穿	缓存雪崩
核心原因	数据根本不存在	热点 Key 过期	大量 Key 同时过期或 Redis 宕机
Key 数量	大量不存在 Key	单个热点 Key	多个或大部分 Key
数据库状态	数据库里也没有	数据库里有数据	数据库里有数据
主要危害	绕过缓存打数据库	单个热点打爆数据库	大量请求压垮数据库
主要方案	缓存空对象、布隆过滤器	互斥锁、逻辑过期	过期随机、多级缓存、限流降级、高可用

记忆时可以抓住关键词：

穿透：不存在
击穿：热点
雪崩：大量

面试时怎么回答

这道题可以这样回答：

缓存穿透是请求的数据在缓存和数据库中都不存在，请求会绕过缓存持续打到数据库，常用缓存空对象和布隆过滤器解决。缓存击穿是某个热点 Key 在过期瞬间被大量并发请求访问，导致请求同时打到数据库，常用互斥锁或逻辑过期解决。缓存雪崩是大量 Key 同时过期，或者 Redis 服务不可用，导致大量请求同时涌向数据库，常用过期时间加随机值、多级缓存、限流降级和 Redis 高可用解决。

如果面试官继续追问，可以补充方案取舍：

缓存空对象简单，但要设置较短 TTL，避免缓存污染。
布隆过滤器适合拦截大量非法请求，但存在误判为可能存在。
互斥锁能保护数据库，但会增加等待时间。
逻辑过期响应快，但可能返回旧数据。
过期随机能打散失效时间，但不能解决 Redis 宕机。
Redis 高可用能提升可用性，但不能替代限流和降级。

小结

这类 Redis 面试题的关键，是把三个概念的根因讲清楚。

缓存穿透：缓存没有，数据库也没有。
缓存击穿：缓存没有，但数据库有，而且是热点 Key。
缓存雪崩：大量缓存同时没有，或者 Redis 整体不可用。

只要先分清根因，再说解决方案，就不会混乱。

最后再补一句工程思维：缓存是为了保护数据库，但缓存系统本身也会失效。所以真正可靠的设计，通常不是只靠一个方案，而是缓存策略、限流降级、异步重建和高可用架构一起配合。

深拷贝、浅拷贝与堆栈面试题复盘

Mon, 01 Jan 2024 00:00:00 GMT

这是前端面试里非常常见的一类问题：

什么是深拷贝和浅拷贝？它们和堆、栈有什么关系？

这道题看起来像是在问 API，实际上是在考察你是否理解 JavaScript 的数据类型、内存模型和引用关系。

如果只回答“浅拷贝只拷贝一层，深拷贝会递归拷贝”，只能算答到表面。更完整的回答应该从基本类型和引用类型讲起，再解释为什么对象拷贝容易互相影响。

先说结论

在 JavaScript 中，数据大致可以分成两类：

基本类型：string、number、boolean、undefined、null、symbol、bigint
引用类型：object、array、function、Date、Map、Set 等

基本类型保存的是值本身，赋值时通常是值的复制。

引用类型保存的是对象的引用，赋值时复制的是引用地址，所以多个变量可能指向同一个对象。

浅拷贝只拷贝对象第一层。如果第一层里还有对象，里面的对象仍然共享引用。

深拷贝会把嵌套对象也复制出来，让新对象和旧对象尽量互不影响。

栈和堆怎么理解

面试里常见说法是：

基本类型的值通常放在栈中。
引用类型的对象内容通常放在堆中。
变量里保存的是指向堆中对象的引用。

这是一种帮助理解的简化模型，不需要把它讲得像浏览器引擎源码一样复杂。

可以这样理解：

let name = 'xiaoxi';

栈：
name -> 'xiaoxi'

基本类型比较直接，变量和值之间的关系很简单。

再看对象：

const user = {
  name: 'xiaoxi',
  profile: {
    age: 18,
  },
};

可以理解为：

栈：
user -> 引用地址 0x001

堆：
0x001 -> {
  name: 'xiaoxi',
  profile: 引用地址 0x002
}

0x002 -> {
  age: 18
}

对象本身放在堆里，变量 user 保存的是引用。

赋值不是拷贝对象

很多拷贝问题都从赋值开始。

reference-assignment.js

const user1 = {
  name: 'xiaoxi',
  profile: {
    age: 18,
  },
};

const user2 = user1;

user2.name = 'veyliss';

console.log(user1.name); // veyliss

这里 user2 = user1 并没有创建一个新对象，只是让 user2 和 user1 指向同一个对象。

所以修改 user2.name，user1.name 也会变。

可以理解为：

user1 -> 0x001
user2 -> 0x001

两个变量指向同一个堆对象。

什么是浅拷贝

浅拷贝会创建一个新的外层对象，但里面的引用类型属性仍然和原对象共享。

常见浅拷贝方式：

展开运算符：{ ...obj }
Object.assign()
数组的 slice()、concat()、Array.from()、[...arr]

看一个例子：

shallow-copy.js

const user1 = {
  name: 'xiaoxi',
  profile: {
    age: 18,
  },
};

const user2 = {
  ...user1,
};

user2.name = 'veyliss';
user2.profile.age = 20;

console.log(user1.name); // xiaoxi
console.log(user1.profile.age); // 20

为什么 name 没有互相影响，但 profile.age 互相影响了？

因为 user2 是一个新的外层对象，但 profile 仍然指向同一个内部对象。

可以理解为：

user1 -> 0x001 -> {
  name: 'xiaoxi',
  profile: 0x002
}

user2 -> 0x003 -> {
  name: 'xiaoxi',
  profile: 0x002
}

外层对象不同，内层 profile 相同。

这就是浅拷贝。

什么是深拷贝

深拷贝会递归复制对象中的嵌套对象，让新对象和旧对象不再共享内部引用。

deep-copy-result.js

const user1 = {
  name: 'xiaoxi',
  profile: {
    age: 18,
  },
};

const user2 = structuredClone(user1);

user2.profile.age = 20;

console.log(user1.profile.age); // 18
console.log(user2.profile.age); // 20

这时可以理解为：

user1 -> 0x001 -> profile -> 0x002
user2 -> 0x003 -> profile -> 0x004

外层对象不同，内层对象也不同。

JSON 方法的深拷贝

以前很常见的一种写法是：

json-clone.js

const copy = JSON.parse(JSON.stringify(source));

这种方式简单，但有明显限制。

它适合普通 JSON 数据：

const source = {
  name: 'xiaoxi',
  tags: ['前端', 'JavaScript'],
};

const copy = JSON.parse(JSON.stringify(source));

但它处理不了很多特殊值：

json-clone-limit.js

const source = {
  name: 'xiaoxi',
  createdAt: new Date(),
  sayHello() {
    console.log('hello');
  },
  value: undefined,
};

const copy = JSON.parse(JSON.stringify(source));

console.log(copy.createdAt); // 字符串，不再是 Date
console.log(copy.sayHello); // undefined
console.log(copy.value); // undefined

它的主要问题包括：

Date 会变成字符串。
undefined、函数、symbol 会丢失。
Map、Set 不能按原结构保留。
遇到循环引用会直接报错。

所以面试时不要把 JSON.parse(JSON.stringify()) 说成万能深拷贝。

structuredClone

现代浏览器和 Node.js 中可以使用 structuredClone()。

structured-clone.js

const source = {
  name: 'xiaoxi',
  createdAt: new Date(),
  items: new Map([['count', 1]]),
};

const copy = structuredClone(source);

console.log(copy.createdAt instanceof Date); // true
console.log(copy.items instanceof Map); // true

相比 JSON 方法，structuredClone() 能保留更多内置类型，也能处理循环引用。

structured-clone-cycle.js

const source = {
  name: 'xiaoxi',
};

source.self = source;

const copy = structuredClone(source);

console.log(copy.self === copy); // true

不过它也不是没有限制。函数、DOM 节点这类内容不能直接被结构化克隆。

手写深拷贝

面试里有时会要求手写一个简单版本。

最基础的写法是递归：

simple-deep-clone.js

function deepClone(value) {
  if (value === null || typeof value !== 'object') {
    return value;
  }

  const result = Array.isArray(value) ? [] : {};

  for (const key in value) {
    if (Object.prototype.hasOwnProperty.call(value, key)) {
      result[key] = deepClone(value[key]);
    }
  }

  return result;
}

这个版本可以处理普通对象和数组，但不能处理循环引用，也不能完整处理 Date、Map、Set 等类型。

如果要支持循环引用，可以用 WeakMap 记录已经拷贝过的对象。

deep-clone-with-weakmap.js

function deepClone(value, cache = new WeakMap()) {
  if (value === null || typeof value !== 'object') {
    return value;
  }

  if (cache.has(value)) {
    return cache.get(value);
  }

  if (value instanceof Date) {
    return new Date(value.getTime());
  }

  if (value instanceof Map) {
    const result = new Map();
    cache.set(value, result);

    value.forEach((item, key) => {
      result.set(deepClone(key, cache), deepClone(item, cache));
    });

    return result;
  }

  if (value instanceof Set) {
    const result = new Set();
    cache.set(value, result);

    value.forEach((item) => {
      result.add(deepClone(item, cache));
    });

    return result;
  }

  const result = Array.isArray(value) ? [] : {};
  cache.set(value, result);

  Reflect.ownKeys(value).forEach((key) => {
    result[key] = deepClone(value[key], cache);
  });

  return result;
}

这个版本已经能覆盖不少面试场景：

基本类型直接返回。
普通对象和数组递归复制。
Date 单独处理。
Map、Set 单独处理。
WeakMap 解决循环引用。
Reflect.ownKeys() 可以拿到 symbol key。

但它仍然不是完整工业级实现。比如属性描述符、原型链、不可枚举属性、函数、DOM 节点等，还需要更多额外处理。

浅拷贝和深拷贝怎么选

不是所有场景都需要深拷贝。

场景	推荐方式
只改第一层字段	浅拷贝即可
React 更新一层状态	展开运算符或 `Object.assign()`
嵌套对象也要完全隔离	深拷贝
普通 JSON 数据复制	JSON 方法可以考虑
复杂对象、循环引用	`structuredClone()` 或专门工具
高性能、大数据量场景	尽量避免无脑深拷贝

在 React 里也经常会遇到这个问题。

比如更新用户名称：

setUser((user) => ({
  ...user,
  name: 'veyliss',
}));

这是浅拷贝，足够更新第一层。

如果要更新嵌套字段：

setUser((user) => ({
  ...user,
  profile: {
    ...user.profile,
    age: 20,
  },
}));

这不是对整个对象做深拷贝，而是只拷贝发生变化的路径。这个方式在 React 里更常见，也更可控。

面试时怎么回答

这道题可以这样回答：

JavaScript 里基本类型通常保存值本身，引用类型保存的是对象引用。对象内容可以理解为存在堆中，变量里保存的是引用地址。普通赋值只是复制引用，不会创建新对象。浅拷贝会创建一个新的外层对象，但嵌套对象仍然共享引用；深拷贝会递归复制嵌套对象，让新旧对象尽量不共享引用。常见浅拷贝方式有展开运算符、Object.assign()、数组 slice() 等；常见深拷贝方式有 structuredClone()、JSON 序列化和手写递归。JSON 方法有局限，会丢失函数、undefined，也不能处理循环引用。手写深拷贝时要考虑递归、特殊类型和循环引用，可以用 WeakMap 做缓存。

如果面试官继续追问，可以展开这些点：

赋值、浅拷贝、深拷贝的区别。
为什么浅拷贝会影响嵌套对象。
JSON.parse(JSON.stringify()) 有哪些问题。
structuredClone() 能解决什么，不能解决什么。
手写深拷贝如何处理循环引用。
React 中为什么经常只拷贝变化路径。

小结

深拷贝、浅拷贝和堆栈这道题，本质是在问你是否理解引用。

可以记住这几句话：

基本类型更像“直接保存值”。
引用类型更像“变量保存地址，对象放在堆里”。
赋值复制的是引用。
浅拷贝复制第一层。
深拷贝递归复制嵌套层。
深拷贝不是越多越好，要看业务是否真的需要完全隔离。

面试里把这些关系讲清楚，比单纯背一个手写深拷贝函数更重要。

电商订单过期处理面试题复盘

Mon, 01 Jan 2024 00:00:00 GMT

这是我 2024 年遇到的一道电商面试题，题目大概是：

假如在某个时刻，也就是某一秒内，有数以千计的商品订单同时过期，数据库应该怎么处理？

这道题表面问的是“订单过期”，实际考察的是高并发场景下怎么避免数据库被瞬时写流量打穿。

一个比较稳妥的回答是：不要让数据库自己去扛所有过期判断，也不要用定时任务在同一秒扫大量订单。订单创建时写入延时队列，到期后由消费者接收消息，再做批量更新和后续事件分发。

问题本质

订单过期一般不是一个难逻辑。比如订单超过 30 分钟未支付，就把状态从 WAIT_PAY 改成 CLOSED。

真正的问题在于：如果某个秒级时间点有大量订单同时过期，系统会出现几个压力点：

数据库短时间内出现大量 update。
如果使用定时任务扫描，查询范围可能很大。
单条订单逐个更新会造成大量数据库往返。
过期后还要释放库存、通知用户、同步缓存，容易把主流程拖慢。
消息重复、消费失败、订单已支付等情况都需要正确处理。

所以这道题不能只回答“定时任务扫一下订单表”。那样在低并发下能跑，但在电商场景里不够稳。

整体方案

我当时记录的主思路是四步：

订单创建 -> 写入延时队列 -> 到期消费 -> 批量关闭订单 -> 发布后续业务事件

可以画成这样：

创建订单
   |
   | 写订单表
   v
发送延时消息：orderId + expireTime
   |
   | 到期后投递
   v
订单过期消费者
   |
   | 聚合一小批订单
   v
批量更新订单状态
   |
   | 更新成功后发布事件
   v
释放库存 / 退款 / 通知用户 / 同步 ES 或缓存

核心目标是：把同一秒的大量过期订单，拆成可控的批量写入和异步事件处理。

订单创建时写入延时队列

订单创建成功后，系统先写入订单表，然后把订单 ID 和过期时间写入延时队列。

消息里通常包含：

order-expire-message.json

{
  "orderId": "202401010001",
  "orderType": "NORMAL",
  "expireTime": "2024-01-01T10:30:00+08:00"
}

延时时间可以这样计算：

TTL = expireTime - now()

也就是说，如果订单 30 分钟后过期，就发送一条 30 分钟后投递的延时消息。

这里可以选不同的实现：

方案	说明
RabbitMQ TTL + 死信队列	到期后消息进入死信队列，由消费者处理
RocketMQ 延时消息	原生支持延时消息，适合常见延时等级
Redis ZSet	用过期时间作为 score，消费者按时间拉取
时间轮	适合大量延时任务调度

面试时不用把某个 MQ 的细节讲太深，重点是说明：订单创建时就把“未来要关闭订单”这件事交给延时机制，而不是等数据库定时扫描。

到期后进入消费者

当延时时间到达，消息会被投递到订单过期消费者。

消费者拿到消息后，不能直接无脑关闭订单，而是要先做状态校验：

收到 orderId
   |
查询订单当前状态
   |
如果已支付：忽略
如果已关闭：忽略
如果待支付且已超时：关闭

原因很简单：延时消息到达时，订单可能已经被用户支付了。

所以关闭订单必须是有条件的。不能只根据“消息到了”就关闭。

消费端做批量处理

如果每条消息都单独更新一次数据库，几千条过期订单就会变成几千次 update。

更好的做法是：消费者先把消息暂存到一个批量处理队列里，然后按数量或时间窗口触发批量更新。

常见触发条件：

累积到 100-500 条订单。
或者等待 100ms 左右。
两个条件满足任意一个就执行批量更新。

可以理解为一个小型缓冲区：

消息 1 -> buffer
消息 2 -> buffer
消息 3 -> buffer
...
达到 300 条，批量 update

这样做的好处是明显的：

减少数据库连接和网络往返。
降低数据库瞬时写压力。
消费者可以通过批次大小控制吞吐。
后续可以水平扩展多个消费者。

批量更新要保证幂等

批量更新订单状态时，一定要带上状态条件。

比如只关闭仍然处于待支付状态的订单：

batch-close-orders.sql

UPDATE orders
SET status = 'CLOSED',
    close_reason = 'TIMEOUT',
    closed_at = NOW()
WHERE id IN (...)
  AND status = 'WAIT_PAY'
  AND expire_time <= NOW();

这里的 status = 'WAIT_PAY' 很关键。

它能保证：

已支付订单不会被误关闭。
已关闭订单重复消费也不会重复更新。
延时消息重复投递时，更新操作仍然安全。

这就是幂等。

面试里可以直接说：消息队列天然可能重复投递，所以订单关闭逻辑必须是幂等的。

更新后发布业务事件

订单状态批量更新完成后，不要在同一个流程里把所有后续业务都做完。

应该发布一个订单关闭事件：

order-closed-event.json

{
  "eventType": "ORDER_CLOSED",
  "reason": "TIMEOUT",
  "orderIds": ["202401010001", "202401010002"]
}

然后由不同消费者处理后续业务：

释放库存。
发起退款。
通知用户。
同步订单状态到 ES。
删除或刷新缓存。
写入业务日志。

这样可以把“关闭订单”和“关闭订单后要做什么”拆开。

关闭订单是核心链路，必须尽快完成；释放库存、通知用户、同步缓存这些动作可以异步扩展。

为什么不用定时任务直接扫表

定时任务不是不能用，但它不适合直接承担高并发订单过期主链路。

如果用定时任务每秒扫一次订单表，大概会遇到几个问题：

查询条件依赖 expire_time，数据量大时压力明显。
某一秒过期订单过多时，任务执行时间不可控。
任务失败后需要补偿。
多实例部署时要处理分布式锁和重复扫描。
单表订单量大时，还要考虑分库分表后的扫描范围。

定时任务更适合做兜底补偿，比如每隔一段时间扫描仍然处于 WAIT_PAY 且已经超时的订单，补偿可能丢失的延时消息。

所以更完整的方案是：

延时队列处理主流程
定时任务做兜底补偿

还要注意削峰

题目里说某一秒有数以千计订单过期，这其实就是一个瞬时流量峰值。

除了批量更新，还可以做一些削峰处理：

多消费者并发消费，但限制每个消费者批量写入频率。
将订单按业务线、商户、分库分表键分片处理。
批量更新失败时拆分批次重试。
对数据库连接池和 MQ 消费速度设置上限。
监控积压量，必要时临时扩容消费者。

关键思想是：MQ 可以积压，消费者可以慢慢处理，但数据库不能被突然打爆。

面试时可以这样回答

这道题可以按下面这段话回答：

我不会让数据库在某一秒直接承受大量订单过期更新。订单创建成功后，会把订单 ID 和过期时间写入延时队列，TTL 设置为 expireTime - now()。消息到期后投递给订单过期消费者，消费者先校验订单是否仍是待支付状态，再把消息放入批量缓冲区，按固定数量或固定时间窗口统一批量更新订单状态。更新时 SQL 会带上 status = WAIT_PAY 和过期时间条件，保证幂等，避免误关已支付订单。订单关闭成功后再发布订单关闭事件，由库存、退款、通知、缓存同步等消费者异步处理。定时任务只作为兜底补偿，不作为主流程。

这段回答基本覆盖了面试官想听的几个关键词：

延时队列。
批量处理。
幂等。
削峰。
事件驱动。
兜底补偿。

小结

这道题的重点不是“怎么把订单改成过期”，而是怎么在大量订单同时过期时保护数据库。

比较合理的设计是：

订单创建时写延时队列
到期后消费者接收消息
消费者聚合订单并批量更新
更新时保证幂等
关闭后发布业务事件
定时任务做兜底补偿

电商系统里很多问题都不是单点逻辑难，而是峰值、幂等、补偿、解耦这些工程问题难。这个题目正好把这些点串到了一起。

Vue 请求后端数据与跨域问题

Tue, 16 May 2023 00:00:00 GMT

这篇文章迁移自我早年写在博客园的一篇记录。当时遇到的问题很直接：后端接口已经写好了，Vue 前端应该怎么请求数据？请求时报跨域又应该怎么处理？

现在回头看，这其实是前后端分离开发里非常典型的一步：前端项目跑在一个端口，后端服务跑在另一个端口，浏览器因为同源策略限制，默认不允许它们随便互相请求。

这篇文章按现在的写法重新整理一遍：先用 axios 发起请求，再抽出请求模块，最后处理跨域问题。

场景说明

假设后端提供了一个用户列表接口：

GET http://localhost:8088/user

前端 Vue 项目运行在另一个地址，例如：

http://localhost:8080/

这两个地址的协议、域名或端口只要有一个不同，就不是同源。这里端口不同，所以浏览器会把它们视为跨域请求。

安装 axios

前端请求接口可以使用 axios。

npm install axios

安装后，在需要请求数据的 Vue 页面中引入：

import axios from 'axios';

如果项目使用的是 Vue 2 或 Options API，可以先在 methods 中写一个简单请求方法。

export default {
  methods: {
    fetchUsers() {
      axios
        // 这里填写后端接口地址
        .get('http://localhost:8088/user')
        .then(function (response) {
          // 请求成功后，后端返回的数据在 response.data 中
          console.log(response.data);
        })
        .catch(function (error) {
          // 请求失败时会进入 catch
          console.log(error);
        })
        .finally(function () {
          // 不管成功还是失败，finally 都会执行
          console.log('请求结束');
        });
    },
  },
};

页面上可以绑定一个按钮测试请求：

<button @click="fetchUsers">请求用户数据</button>

点击按钮后，打开浏览器控制台。如果后端接口正常，并且跨域已经允许，就能在控制台看到返回数据。

async 写法

如果你更喜欢同步风格，也可以用 async / await。

import axios from 'axios';

export default {
  methods: {
    async fetchUsers() {
      try {
        // await 会等待请求完成
        const response = await axios.get('http://localhost:8088/user');

        // 后端真正返回的数据通常放在 response.data
        console.log(response.data);
      } catch (error) {
        // 网络错误、接口错误、跨域错误都会进入这里
        console.log(error);
      }
    },
  },
};

这种写法在业务代码里更容易读，尤其是请求成功后还有多步处理时。

为什么要封装请求

刚开始写一个请求时，直接在页面里写完整地址没有问题。

但接口一多，就会出现几个问题：

每个页面都要写 http://localhost:8088。
请求地址散落在各个组件里。
后续换服务器地址时，需要到处改。
请求头、错误处理、登录 token 等逻辑难以统一。

所以更常见的做法是：把 axios 实例单独封装起来，再把具体接口拆到 api 目录里。

封装 axios 实例

在 src/utils/request.js 中写入：

import axios from 'axios';

const request = axios.create({
  // 接口服务器地址
  // 后续接口只需要写 /user、/login 这类路径
  baseURL: 'http://localhost:8088',

  // 超时时间，单位是毫秒
  timeout: 10000,
});

// 请求拦截器：请求发出前会先经过这里
request.interceptors.request.use(
  function (config) {
    // 如果后续有 token，可以在这里统一添加
    // config.headers.Authorization = `Bearer ${token}`;
    return config;
  },
  function (error) {
    return Promise.reject(error);
  }
);

// 响应拦截器：后端响应后会先经过这里
request.interceptors.response.use(
  function (response) {
    // 这里先直接返回 response
    // 如果后端有统一结构，也可以只返回 response.data
    return response;
  },
  function (error) {
    // 可以在这里统一处理错误提示、登录过期等问题
    return Promise.reject(error);
  }
);

export default request;

这样封装后，页面里就不需要每次都写完整后端地址了。

封装接口方法

在 src/api/user.js 中写：

import request from '../utils/request';

export function getUserList(params = {}) {
  return request({
    // axios 里字段名是 method，不是 methods
    method: 'GET',

    // 会和 baseURL 拼接成 http://localhost:8088/user
    url: '/user',

    // GET 请求参数
    params,
  });
}

这里要注意一个细节：axios 配置里的请求方式字段是 method，不是 methods。

在 Vue 页面中调用

在页面组件中引入接口方法：

import { getUserList } from '../api/user';

export default {
  data() {
    return {
      tableData: [],
    };
  },

  methods: {
    async loadUsers() {
      try {
        const response = await getUserList();

        // 如果响应拦截器返回的是完整 response，就从 response.data 取数据
        this.tableData = response.data;
      } catch (error) {
        console.log(error);
      }
    },
  },
};

如果希望页面创建时自动请求，可以在 created 生命周期中调用：

import { getUserList } from '../api/user';

export default {
  data() {
    return {
      tableData: [],
    };
  },

  created() {
    // 页面创建时加载数据
    this.loadUsers();
  },

  methods: {
    async loadUsers() {
      const response = await getUserList();
      this.tableData = response.data;
    },
  },
};

如果要在模板中展示：

<template>
  <ul>
    <li v-for="user in tableData" :key="user.id">
      {{ user.name }}
    </li>
  </ul>
</template>

实际字段名要根据后端返回数据决定。

跨域问题是什么

前端请求后端时，如果浏览器控制台出现类似错误：

Access to XMLHttpRequest at 'http://localhost:8088/user'
from origin 'http://localhost:8080'
has been blocked by CORS policy

这就是跨域问题。

它不是 axios 的问题，也不是 Vue 的问题，而是浏览器的同源策略在生效。

同源要求三者完全一致：

协议相同，例如都是 http。
域名相同，例如都是 localhost。
端口相同，例如都是 8080。

下面两个地址端口不同，所以不是同源：

前端：http://localhost:8080
后端：http://localhost:8088

浏览器会拦截前端 JavaScript 对后端的请求，除非后端明确允许这个来源访问。

后端使用 CrossOrigin

如果后端是 Spring Boot，可以在 Controller 上添加 @CrossOrigin。

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

@RestController
@CrossOrigin
public class UserController {

    @GetMapping("/user")
    public List<User> listUsers() {
        return userService.listUsers();
    }
}

这样写表示这个 Controller 允许跨域访问。

如果想限制来源，可以写得更明确：

@CrossOrigin(origins = "http://localhost:8080")
@RestController
public class UserController {
    // ...
}

这比完全放开更安全。

全局跨域配置

如果接口很多，不想每个 Controller 都写 @CrossOrigin，也可以做全局配置。

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry
            // 哪些接口路径允许跨域
            .addMapping("/**")

            // 允许哪个前端地址访问
            .allowedOrigins("http://localhost:8080")

            // 允许哪些请求方法
            .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")

            // 允许携带哪些请求头
            .allowedHeaders("*");
    }
}

开发阶段可以先这样配置。正式环境中，allowedOrigins 不建议随便写成 *，最好明确填写真实前端域名。

前端代理方案

开发环境也可以通过前端代理解决跨域。

如果使用 Vue CLI，可以在 vue.config.js 中配置：

module.exports = {
  devServer: {
    proxy: {
      '/api': {
        // 后端服务地址
        target: 'http://localhost:8088',

        // 是否改变请求来源
        changeOrigin: true,

        // 把 /api/user 重写成 /user
        pathRewrite: {
          '^/api': '',
        },
      },
    },
  },
};

这时 axios 的基础地址可以改成：

const request = axios.create({
  baseURL: '/api',
});

请求：

request({
  method: 'GET',
  url: '/user',
});

浏览器实际请求的是前端开发服务器：

http://localhost:8080/api/user

再由前端开发服务器转发给后端：

http://localhost:8088/user

这样浏览器看到的是同源请求，就不会触发跨域限制。

常见问题

后端能访问，前端却报跨域

浏览器跨域是浏览器限制。你用 Postman、Apifox、curl 能请求成功，不代表浏览器里也能请求成功。

axios 报错是不是后端没返回数据

不一定。跨域错误时，请求可能已经被浏览器拦截，前端拿不到正常响应。要先看浏览器控制台的 Network 和 Console。

请求写对了，但 this 取不到

如果使用普通函数，this 可能发生变化。

getUserList().then(function (response) {
  // 这里的 this 不一定是 Vue 组件实例
  this.tableData = response.data;
});

可以改成箭头函数：

getUserList().then((response) => {
  // 箭头函数不会重新绑定 this
  this.tableData = response.data;
});

或者直接使用 async / await。

小结

Vue 请求后端接口时，可以按这个顺序处理：

使用 axios 先完成一次最简单的请求。
确认后端接口能正常返回数据。
如果浏览器报跨域，让后端配置 CORS，或者在开发环境使用代理。
当接口变多后，把 axios 封装成统一的 request 模块。
按业务拆分 API 文件，页面只调用方法，不直接拼接口地址。

这篇旧文当年只是为了解决“前端怎么拿到后端数据”这个问题。现在重新整理后，它更像是一条前后端分离开发的入门路径：先跑通，再封装，最后处理跨域和工程结构。

原文记录：vue请求后端数据和跨域问题

ServletConfig 接口介绍

Wed, 08 Mar 2023 00:00:00 GMT

这篇文章迁移自我早年写在博客园的一篇记录。当时主要是在学习 Servlet 初始化参数：Servlet 容器初始化 Servlet 时，会创建一个 ServletConfig 对象，并把它交给当前 Servlet 使用。

简单说，ServletConfig 适合保存“只属于某一个 Servlet 的配置”。比如某个 Servlet 自己需要的用户名、开关、路径、默认参数等。

ServletConfig 是什么

当 Web 容器创建并初始化 Servlet 时，会为这个 Servlet 准备一个 ServletConfig 对象。这个对象里包含当前 Servlet 的初始化信息，也可以通过它拿到整个 Web 应用的 ServletContext。

需要记住两点：

一个 Web 应用里可以有多个 Servlet，也就可以有多个 ServletConfig 对象。
一个 Servlet 只对应一个 ServletConfig 对象，所以 Servlet 初始化参数默认只对当前 Servlet 有效。

如果把 Web 应用理解成一个项目，那么：

ServletContext 更像“整个项目的全局上下文”。
ServletConfig 更像“某一个 Servlet 自己的配置说明”。

常用方法

ServletConfig 常用方法不多，重点是下面这几个：

方法	作用
`String getInitParameter(String name)`	根据参数名获取当前 Servlet 的初始化参数值
`Enumeration<String> getInitParameterNames()`	获取当前 Servlet 所有初始化参数名
`ServletContext getServletContext()`	获取当前 Web 应用的 `ServletContext` 对象
`String getServletName()`	获取当前 Servlet 名称，也就是 `web.xml` 中 `<servlet-name>` 的值

这里最常用的是 getInitParameter() 和 getInitParameterNames()。前者适合读取单个配置，后者适合遍历所有配置。

先分清两类参数

Servlet 里有两类参数很容易混在一起：

配置位置	所属对象	读取方式	生效范围
`<context-param>`	`ServletContext`	`getServletContext().getInitParameter()`	整个 Web 应用
`<servlet>` 里的 `<init-param>`	`ServletConfig`	`getServletConfig().getInitParameter()`	当前 Servlet

也就是说，context-param 不是当前 Servlet 的私有配置，它属于整个 Web 应用。ServletConfig#getServletContext() 只是让你可以从当前 Servlet 拿到全局上下文，并不代表这些全局参数属于 ServletConfig。

这个区别非常重要。很多初学 Servlet 的时候，会把“通过 ServletConfig 拿到 ServletContext，再读取全局参数”误认为是在读取 Servlet 自己的初始化参数。

使用 web.xml 配置全局参数

先看全局参数的写法。下面的 admin-email、admin-name、admin-password 都配置在 <context-param> 中，因此它们属于整个 Web 应用。

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>Servlet</servlet-name>
        <servlet-class>main.java.com.Servlet</servlet-class>
    </servlet>

    <context-param>
        <param-name>admin-email</param-name>
        <param-value>123456@qq.com</param-value>
    </context-param>

    <context-param>
        <param-name>admin-name</param-name>
        <param-value>xiaoxi</param-value>
    </context-param>

    <context-param>
        <param-name>admin-password</param-name>
        <param-value>123456</param-value>
    </context-param>

    <servlet-mapping>
        <servlet-name>Servlet</servlet-name>
        <url-pattern>/Servlet</url-pattern>
    </servlet-mapping>
</web-app>

读取这些全局参数时，需要先拿到 ServletContext。

Servlet.java

package main.java.com;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(name = "Servlet", value = "/Servlet")
public class Servlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/plain;charset=UTF-8");

        ServletConfig config = getServletConfig();
        ServletContext servletContext = config.getServletContext();

        String adminEmail = servletContext.getInitParameter("admin-email");
        String adminName = servletContext.getInitParameter("admin-name");
        String password = servletContext.getInitParameter("admin-password");

        response.getWriter().println("admin-email: " + adminEmail);
        response.getWriter().println("admin-name: " + adminName);
        response.getWriter().println("admin-password: " + password);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

这段代码里虽然先调用了 getServletConfig()，但真正读取参数的是 servletContext.getInitParameter()。所以它读取的是全局初始化参数。

使用 web.xml 配置当前 Servlet 参数

如果希望参数只属于当前 Servlet，就应该把参数写到 <servlet> 里的 <init-param> 中。

web.xml

<servlet>
    <servlet-name>MyServlet</servlet-name>
    <servlet-class>java.com.MyServlet</servlet-class>

    <init-param>
        <param-name>name</param-name>
        <param-value>xiaoxi</param-value>
    </init-param>

    <init-param>
        <param-name>admin</param-name>
        <param-value>xiaoxi</param-value>
    </init-param>
</servlet>

这种参数才是 ServletConfig 最典型的使用场景。

MyServlet.java

ServletConfig config = getServletConfig();

String name = config.getInitParameter("name");
String admin = config.getInitParameter("admin");

如果另一个 Servlet 也想使用同名参数，需要在另一个 Servlet 的配置里重新声明。Servlet 私有参数不会自动共享。

使用注解配置初始化参数

除了 web.xml，也可以直接使用 @WebServlet 和 @WebInitParam 配置当前 Servlet 的初始化参数。

这种方式更适合简单项目或示例代码，因为配置和 Servlet 类写在一起，阅读起来更直观。

HelloServlet.java

package main.java.com;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

@WebServlet(
        name = "helloServlet",
        value = "/helloServlet",
        initParams = {
                @WebInitParam(name = "name", value = "测试"),
                @WebInitParam(name = "admin", value = "123456")
        }
)
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");

        ServletConfig config = getServletConfig();
        String servletName = config.getServletName();
        Enumeration<String> initParameterNames = config.getInitParameterNames();

        PrintWriter writer = response.getWriter();
        writer.write("servletName: " + servletName + "<br/>");

        while (initParameterNames.hasMoreElements()) {
            String initParamName = initParameterNames.nextElement();
            String initParamValue = config.getInitParameter(initParamName);

            writer.write(initParamName + ": " + initParamValue + "<br/>");
        }

        writer.close();
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

这里的 initParams 配置只对 HelloServlet 生效。别的 Servlet 不能直接通过自己的 ServletConfig 读取这些参数。

web.xml 和注解怎么选

如果项目很小，或者只是练习 Servlet，使用注解会比较方便。

如果项目配置比较多，或者需要把代码和配置分离，使用 web.xml 会更清晰。尤其是早期 Java Web 项目里，很多 Servlet、Filter、Listener 都会统一写在 web.xml 中。

可以简单按下面的方式判断：

场景	推荐方式
示例代码、学习项目	`@WebServlet`
配置较少的小项目	`@WebServlet` 或 `web.xml` 都可以
多个 Servlet 需要统一管理	`web.xml`
希望参数不写死在 Java 类里	`web.xml`

两种方式本质上都是告诉 Servlet 容器：这个 Servlet 叫什么、映射到哪个路径、初始化时带哪些参数。

常见注意点

第一，context-param 和 init-param 不要混用。

如果一个参数是全站通用的，比如站点名称、管理员邮箱、上传目录，可以放在 <context-param> 中。如果一个参数只服务于某个 Servlet，就放在对应 Servlet 的 <init-param> 中。

第二，读取参数时要找对对象。

// 读取当前 Servlet 的初始化参数
getServletConfig().getInitParameter("name");

// 读取整个 Web 应用的全局参数
getServletContext().getInitParameter("admin-email");

第三，输出中文时记得设置响应编码。

response.setContentType("text/html;charset=UTF-8");

如果不设置编码，浏览器里可能会出现中文乱码。

第四，注意包名差异。

早期 Servlet 项目常见包名是 javax.servlet。如果使用的是 Tomcat 10、Spring Boot 3 或 Jakarta EE 新版本，包名会变成 jakarta.servlet。

// 旧版本常见写法
import javax.servlet.ServletConfig;

// 新版本常见写法
import jakarta.servlet.ServletConfig;

学习旧项目或迁移项目时，这个差异很常见。

小结

ServletConfig 的核心作用，是保存并读取当前 Servlet 的初始化参数。

需要特别分清楚：

ServletConfig 面向当前 Servlet。
ServletContext 面向整个 Web 应用。
<init-param> 是 Servlet 私有配置。
<context-param> 是 Web 应用全局配置。
注解里的 initParams 只对当前 Servlet 生效。

把这几个概念理顺之后，Servlet 初始化参数就不难了。真正容易出错的地方，往往不是 API 本身，而是没有分清“这个配置到底属于谁”。

原文记录：ServletConfig接口介绍