← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标(学完能回答的面试题)核心知识(面试题模拟)面试速记卡(考前30秒速看)练习题(自测)学习资料

L43 - 中间件面试模拟

本节目标(学完能回答的面试题)

本节通过20道高频中间件面试题,覆盖Redis/MySQL/MQ/ElasticSearch四大中间件核心考点,训练场景化答题能力。

核心知识(面试题模拟)


一、Redis篇(6题)

Q1: 缓存三大问题(穿透/击穿/雪崩)

标准答案:


缓存穿透:查询不存在的数据,请求直达数据库
  解决:
  1. 布隆过滤器:拦截不存在的key(有误判率,但可控)
  2. 缓存空值:查不到也缓存null,设短TTL(如60s)
  3. 接口校验:参数合法性校验,防止恶意请求

缓存击穿:热点key过期瞬间,大量请求打到DB
  解决:
  1. 互斥锁:SETNX抢锁,只有抢到锁的线程查DB并缓存
  2. 逻辑过期:不设TTL,数据中加过期时间字段,过期后异步更新
  3. 热点key永不过期 + 异步刷新

缓存雪崩:大量key同时过期,或Redis宕机
  解决:
  1. 过期时间加随机值:TTL = base + random(0~300s)
  2. Redis集群高可用(哨兵/Cluster)
  3. 多级缓存:本地缓存 + Redis + DB
  4. 熔断降级:Sentinel限流保护DB

口述优先级:先说问题本质 → 再说解决方案 → 最后比较优劣

追问链:布隆过滤器的误判率怎么控制? → 互斥锁方案有什么问题? → 你项目中遇到过哪个?

Q2: Redis持久化方案

标准答案:


RDB (Redis Database):
  定时快照,fork子进程写磁盘
  优点:恢复快,文件小
  缺点:可能丢失两次快照间的数据
  触发:save/bgsave/配置自动触发

AOF (Append Only File):
  记录每个写命令,追加到文件
  同步策略:
    always: 每条命令fsync,最安全最慢
    everysec: 每秒fsync(推荐,最多丢1秒)
    no: 由OS决定fsync时机
  
  AOF重写(bgrewriteaof):
    合并冗余命令,压缩文件
    如: SET k v1; SET k v2; SET k v3 → 只保留 SET k v3

Redis 4.0 混合持久化:
  RDB + AOF混合
  重写时:前半部分RDB格式(快) + 后半部分AOF增量
  兼顾恢复速度和数据安全

生产建议:
  开启AOF(everysec) + RDB(每小时)
  或 Redis 4.0+ 混合持久化

Q3: Redis Cluster原理

标准答案:


Redis Cluster数据分布:
  16384个hash slots
  每个节点负责一部分slot
  key → CRC16(key) % 16384 → 确定slot → 确定节点

集群架构(最少6节点):
  3 Master + 3 Slave
  Master间通过Gossip协议通信
  Slave实时复制Master数据

故障转移:
  1. 节点间ping/pong检测(Gossip)
  2. 超过cluster-node-timeout标记为PFAIL
  3. 多数Master确认 → 标记FAIL
  4. 对应Slave发起选举 → 成为新Master

局限性:
  不支持多key跨slot操作(除非hash tag)
  批量操作需要mget → 优化为hash tag或客户端分组

追问链:为什么是16384个slot而不是更多? → 客户端如何知道key在哪个节点? → 集群扩容怎么做?

Q4: Redis和DB双写一致性

标准答案:


四种策略:

1. Cache Aside(推荐):
   读:先读缓存→miss读DB→写缓存
   写:先更新DB→再删缓存
   
2. 延迟双删:
   写:删缓存→更新DB→(延迟500ms)→再删缓存
   解决:删除缓存后、更新DB前,有读请求又把旧数据写回缓存

3. 监听binlog异步删缓存:
   Canal监听MySQL binlog→删除Redis缓存
   最终一致性,延迟可控

4. 读/写穿透(Read/Write Through):
   应用只操作缓存,缓存层负责读写DB

强一致性?Redis不可能和DB强一致(除非分布式锁+串行化,性能极差)
一般接受最终一致性(延迟<100ms可接受)

Q5: Redis的底层数据结构

标准答案:


五大数据类型对应的底层结构:

  String → SDS(Simple Dynamic String)
           编码: int(整数) / embstr(<44字节) / raw(>44字节)
  
  List   → quicklist(双向链表 + 每个节点是ziplist)
  
  Hash   → ziplist(元素少/小) / hashtable(元素多)
  
  Set    → intset(全整数且少) / hashtable
  
  ZSet   → ziplist(元素少) / skiplist+hashtable(元素多)
           skiplist: O(logN)查询,hashtable: O(1)查分值

  Redis 7.0: listpack替代ziplist,更省内存

Q6: Redis分布式锁实现

标准答案:


# 加锁(原子操作)
SET lock:order:123 unique_value NX PX 30000
# NX: 不存在才设置  PX: 过期时间30秒
# unique_value: 每个客户端唯一标识(UUID)

# 解锁(Lua脚本保证原子性)
if redis.call('get', KEYS[1]) == ARGV[1] then
    return redis.call('del', KEYS[1])
else
    return 0
end

# 看门狗续期(Redisson实现)
# 锁默认30秒,每10秒(1/3)检查并续期
# 避免业务未执行完锁就过期

二、MySQL篇(6题)

Q7: 索引失效的场景

标准答案:


常见索引失效10种场景:
  1. 联合索引不满足最左前缀: INDEX(a,b,c) → 查b=1 (失效)
  2. 索引列使用函数: WHERE YEAR(create_time) = 2024 (失效)
  3. 隐式类型转换: varchar列 WHERE phone = 13800000000 (失效)
  4. LIKE左模糊: WHERE name LIKE '%张' (失效)
  5. OR条件一侧无索引: WHERE a=1 OR b=2(b无索引,全表)
  6. NOT IN / NOT EXISTS (部分场景)
  7. 索引列做运算: WHERE id + 1 = 10 (失效)
  8. 全表扫描更快(MyServer判断,数据量小时)
  9. IS NULL / IS NOT NULL (取决于数据分布)
  10. ORDER BY未使用索引列

口述技巧:先说最左前缀 → 再说运算/函数/转换 → 最后说优化器选择

EXPLAIN关键字段:
  type: system > const > eq_ref > ref > range > index > ALL
  key: 实际使用的索引
  rows: 预估扫描行数
  Extra: Using index(覆盖索引) / Using filesort(额外排序) / Using temporary(临时表)

Q8: MVCC原理

标准答案:


MVCC (Multi-Version Concurrency Control):
  依赖三个组件:隐藏列 + undo log + ReadView

每行隐藏列:
  DB_TRX_ID: 最后修改该行的事务ID
  DB_ROLL_PTR: 回滚指针,指向undo log中上一个版本

ReadView (RC/RR级别创建时机不同):
  creator_trx_id: 创建该ReadView的事务ID
  m_ids: 创建时所有活跃(未提交)事务ID列表
  min_trx_id: 活跃事务中最小的ID
  max_trx_id: 下一个将要分配的事务ID

可见性判断:
  1. trx_id == creator_trx_id → 自己的修改,可见
  2. trx_id < min_trx_id → 事务已提交,可见
  3. trx_id >= max_trx_id → 事务在ReadView创建后开始,不可见
  4. min_trx_id <= trx_id < max_trx_id:
     在m_ids中 → 未提交,不可见
     不在m_ids中 → 已提交,可见

RC vs RR:
  RC: 每次SELECT创建新ReadView → 能看到其他已提交事务的修改
  RR: 只在第一次SELECT创建ReadView → 同一事务内结果一致

追问链:RR级别如何解决幻读? → 快照读和当前读的区别? → GAP Lock的作用?

Q9: 分库分表方案

标准答案:


垂直拆分:
  垂直分库:按业务拆(订单库、用户库、商品库)
  垂直分表:将大字段拆到扩展表(商品基本信息+商品详情)

水平拆分:
  水平分库:同一个表的数据按规则分散到不同库
  水平分表:同一个库内按规则拆成多个表

分片策略:
  1. Range(范围): 1-100万在表1,100-200万在表2
     优点:扩容方便  缺点:热点问题
  2. Hash(取模): id % 4 → 分4个表
     优点:数据均匀  缺点:扩容需要迁移数据
  3. 一致性Hash: 减少扩容迁移量

中间件:
  ShardingSphere (Apache开源,Java生态)
  MyCat (国内开源)

分库分表后的问题:
  分布式ID: 雪花算法/Leaf
  跨库JOIN: 应用层组装 / 冗余字段
  分布式事务: Seata
  聚合查询: 汇总表 / ES

三、MQ篇(4题)

Q10: 如何保证消息不丢失

标准答案:


三个环节都可能丢失消息:

1. 生产者 → Broker:
   RabbitMQ: confirm模式,等待ACK
   RocketMQ: 同步发送+重试,事务消息
   Kafka: acks=all,等待所有ISR副本确认

2. Broker存储:
   RabbitMQ: 消息持久化(durable queue + persistent message)
   RocketMQ: 默认同步刷盘
   Kafka: replication.factor >= 3, min.insync.replicas=2

3. 消费者:
   手动ACK(不要自动ACK)
   业务处理完成后再确认
   失败重试 + 死信队列

口述框架:先说三个环节 → 再说每个环节的方案 → 最后总结

Q11: 消息顺序性如何保证

标准答案:


问题:多个Consumer并行消费,消息可能乱序

全局有序(性能差,不推荐):
  1个Topic只有1个Queue,1个Consumer串行消费

部分有序(推荐):
  同一业务Key的消息发到同一个Queue
  同一Queue只有一个Consumer消费
  
  RocketMQ:
    发送: MessageQueueSelector按orderId选队列
    消费: MessageListenerOrderly顺序消费
  
  Kafka:
    发送: 指定partition(按key hash)
    消费: 单线程消费每个partition
    多线程处理: 用内存队列按key分发到同一线程

Q12: 消息积压怎么处理

标准答案:


紧急处理:
  1. 快速扩容Consumer数量(不超过Queue数量)
  2. 如果Consumer处理慢,先写到一个新的临时Topic(大容量)
  3. 临时Topic用更多Consumer并行消费

根本原因排查:
  Consumer消费慢 → 代码bug/下游超时/DB慢查询
  Producer突发流量 → 限流+削峰
  Consumer宕机 → 告警+自动重启

预防措施:
  监控Consumer Lag(积压量)
  设置合理的告警阈值
  压测确定消费能力上限

Q13: 如何避免消息重复消费(幂等)

标准答案:


消息重复是不可避免的(网络重试、消费者重启等)

幂等方案:
  1. 全局唯一ID + Redis SETNX: 
     SETNX msg:consume:msgId 1 EX 3600
  2. 数据库唯一索引: 
     INSERT时DuplicateKeyException → 幂等返回成功
  3. 状态机: 
     UPDATE SET status='PAID' WHERE id=x AND status='UNPAID'
  4. 乐观锁/版本号
  5. 业务层去重表

推荐:Redis SETNX(高性能) + DB唯一索引(强保证)

四、ElasticSearch篇(2题)

Q14: ES倒排索引原理

标准答案:


正排索引: 文档ID → 内容
倒排索引: 词项(Term) → 文档ID列表

示例:
  Doc1: "Java面试指南"
  Doc2: "Java并发编程"
  Doc3: "Python数据分析"

倒排索引:
  ┌─────────┬──────────────┐
  │  Term   │ Posting List │
  ├─────────┼──────────────┤
  │ Java    │ [Doc1, Doc2] │
  │ 面试    │ [Doc1]       │
  │ 指南    │ [Doc1]       │
  │ 并发    │ [Doc2]       │
  │ 编程    │ [Doc2]       │
  │ Python  │ [Doc3]       │
  └─────────┴──────────────┘

查询"Java" → 直接定位到[Doc1, Doc2] → O(1)

优化结构:
  Term Dictionary: 排序的Term列表(FST压缩)
  Term Index: 前缀树索引,快速定位Term在Dictionary中的位置
  Posting List: Roaring Bitmap压缩存储

Analyzer分词器:
  Character Filter → Tokenizer → Token Filter
  中文常用: ik_max_word / ik_smart

Q15: ES写入和查询流程

标准答案:


写入流程:
  1. 客户端 → 协调节点(Coordinating Node)
  2. 路由: hash(routing) % numberOfPrimaryShards → 确定主分片
  3. 主分片写入 → 同步到副本分片
  4. 写入内部:
     Index Buffer → Refresh(1秒) → Segment(可搜索)
     同时写Translog(保证持久性)
     Flush: Segment持久化 + 清空Translog

查询流程(分两阶段):
  Query阶段:
    协调节点 → 请求所有相关分片 → 每个分片返回docID+排序值
  Fetch阶段:
    协调节点 → 合并排序 → 取Top N的docID → 去对应分片取完整文档

深分页问题:
  from + size: 协调节点需要收集 from+size 条数据排序
  from=10000, size=10 → 每个分片返回10010条 → 协调节点处理N×10010
  
  解决: search_after(游标) / scroll(批量导出)

评分标准


┌────────┬──────────────────────────────────────┐
│ 等级   │ 标准                                  │
├────────┼──────────────────────────────────────┤
│ A 优秀 │ 三大问题解决方案对比+底层原理+实战经验  │
│ B 良好 │ 能说清原理,追问到底层略有模糊          │
│ C 合格 │ 知道概念和基本用法                      │
│ D 不合格│ 只用过API,原理完全不清楚               │
└────────┴──────────────────────────────────────┘

高频挂点提醒:
  ❌ 缓存三大问题只背名字不说解决方案
  ❌ MVCC说不清ReadView的可见性判断
  ❌ 消息不丢失只说一个环节,漏掉三个环节
  ❌ ES倒排索引说不清Term Dictionary和Posting List

面试速记卡(考前30秒速看)

练习题(自测)

1. 口述缓存穿透、击穿、雪崩的区别和解决方案(限时3分钟)

2. MVCC在RC和RR下的行为差异是什么?

3. 消息积压100万条,如何紧急处理?

4. Redis Cluster的16384个slot是如何分配和迁移的?

5. ES的深度分页问题有哪些解决方案?

学习资料