Q116 MongoDB与NoSQL深度实战
20K Java+AI 岗位高频考点 — NoSQL是关系型数据库的重要补充,在大数据、高并发、灵活Schema场景中不可或缺。覆盖MongoDB核心原理、Redis深度实战、Spring Data集成、NoSQL选型对比。
一、MongoDB基础与文档模型
1. MongoDB的核心特性?
| 特性 | 说明 |
| 文档模型 | BSON格式,灵活Schema,嵌套文档 |
| 水平扩展 | 原生分片(Sharding),支持海量数据 |
| 高可用 | 副本集(Replica Set),自动故障转移 |
| 丰富查询 | 支持聚合管道、全文搜索、地理空间 |
| 索引支持 | B-tree、全文、地理空间、哈希、TTL |
2. 嵌套文档vs引用关系?
嵌套(Embedding):适合一对一、一对少量
{
"_id": 1,
"name": "张三",
"address": {"city": "北京", "street": "中关村"} // 嵌套
}
引用(Referencing):适合一对多、多对多
{
"_id": 1, "name": "张三",
"order_ids": [ObjectId("aaa"), ObjectId("bbb")] // 引用
}
选择原则:
- 总是一起读 → 嵌套
- 经常单独访问 → 引用
- 文档不超过16MB → 嵌套
- 需要原子更新 → 嵌套在同一文档
3. MongoDB的BSON格式?
BSON = Binary JSON,二进制编码的JSON
扩展类型(JSON没有的):
- Date、ObjectId、Binary、Regex
- Int32、Int64、Decimal128
- Timestamp、MinKey、MaxKey
ObjectId组成(12字节):
4字节时间戳 + 3字节机器ID + 2字节进程ID + 3字节计数器
优势:比JSON解析更快,支持更多数据类型
4. MongoDB CRUD操作?
// Spring Data MongoDB
@Document(collection = "users")
public class User {
@Id private String id;
private String name;
private int age;
private List<String> hobbies;
}
// Repository
public interface UserRepository extends MongoRepository<User, String> {
List<User> findByAgeBetween(int min, int max);
List<User> findByNameRegex(String regex);
}
// MongoTemplate复杂查询
@Autowired MongoTemplate mongoTemplate;
public List<User> complexQuery() {
Query query = new Query();
query.addCriteria(Criteria.where("age").gte(18).lte(60));
query.addCriteria(Criteria.where("hobbies").in("Java"));
query.with(Sort.by(Sort.Direction.DESC, "age"));
query.limit(10);
return mongoTemplate.find(query, User.class);
}
5. MongoDB更新操作?
// 原子更新
mongoTemplate.updateFirst(
Query.query(Criteria.where("_id").is("1")),
new Update().set("name", "李四").inc("age", 1),
User.class
);
// Upsert(存在则更新,不存在则插入)
mongoTemplate.upsert(
Query.query(Criteria.where("userId").is("u1")),
new Update().set("lastLogin", new Date()).setOnInsert("createdAt", new Date()),
User.class
);
// 批量更新
mongoTemplate.updateMulti(
Query.query(Criteria.where("status").is("inactive")),
new Update().set("status", "active"),
User.class
);
6. MongoDB的Schema设计原则?
1. 优先嵌套,避免不必要的引用
2. 文档大小不超过16MB
3. 热数据放一起(访问模式驱动设计)
4. 避免无限增长的数组
5. 使用TTL索引自动过期
6. 根据查询模式设计索引
反范式化场景:
- 读多写少 → 嵌套冗余数据
- 一对少量(<100) → 嵌套
- 需要原子操作 → 放同一文档
范式化场景:
- 数据频繁更新 → 引用
- 一对大量(>1000) → 引用
- 多对多 → 引用
二、MongoDB索引与查询优化
7. MongoDB索引类型?
| 索引类型 | 说明 | 使用场景 |
| 单字段 | 默认_id索引 | 常规查询 |
| 复合索引 | 多字段组合 | 多条件查询 |
| 多键索引 | 数组字段 | 数组元素查询 |
| 文本索引 | 全文搜索 | 关键词搜索 |
| 地理空间 | 2d/2dsphere | LBS应用 |
| 哈希索引 | 哈希分片 | 分片键 |
| TTL索引 | 自动过期 | 日志、Session |
| 唯一索引 | 唯一约束 | 唯一性保证 |
8. 复合索引的最佳实践?
ESR原则:Equal → Sort → Range
创建索引:{status: 1, createdAt: -1, amount: 1}
查询条件:
1. status = 'active' ← Equal(精确匹配放最前)
2. ORDER BY createdAt DESC ← Sort(排序放中间)
3. amount > 100 ← Range(范围放最后)
覆盖查询:查询字段都在索引中,不需要回表
db.orders.find({status: "active"}, {status: 1, createdAt: 1, _id: 0})
9. explain()分析查询?
db.orders.find({status: "active", amount: {$gt: 100}}).explain("executionStats")
关键指标:
- winningPlan:选中的执行计划
- totalDocsExamined:扫描文档数(越少越好)
- executionTimeMillis:执行时间
- indexUsed:使用的索引
优化目标:
- totalDocsExamined ≈ nReturned(扫描数≈返回数)
- 避免COLLSCAN(全表扫描)
- 避免SORT阶段(用索引排序)
10. 慢查询排查?
开启慢查询日志:
db.setProfilingLevel(1, {slowms: 100}) // >100ms记录
查看慢查询:
db.system.profile.find().sort({ts: -1}).limit(10)
常见慢查询原因:
1. 缺少索引 → 添加合适的复合索引
2. 索引不生效 → 检查查询条件顺序
3. 返回字段太多 → 只返回需要的字段
4. 正则表达式以%开头 → 无法使用索引
5. $or查询 → 每个条件都需要索引
11. MongoDB连接池配置?
# Spring Data MongoDB
spring:
data:
mongodb:
uri: mongodb://user:pass@host1:27017,host2:27017/db?maxPoolSize=100&minPoolSize=10&maxIdleTimeMS=60000&connectTimeoutMS=5000&socketTimeoutMS=30000
三、MongoDB聚合管道
12. 聚合管道常用阶段?
db.orders.aggregate([
{$match: {status: "completed", createdAt: {$gte: ISODate("2025-01-01")}}},
{$group: {_id: "$userId", totalAmount: {$sum: "$amount"}, orderCount: {$sum: 1}}},
{$sort: {totalAmount: -1}},
{$limit: 10}
])
13. $lookup关联查询?
// 类似SQL的LEFT JOIN
db.orders.aggregate([
{$lookup: {
from: "users",
localField: "userId",
foreignField: "_id",
as: "userInfo"
}},
{$unwind: "$userInfo"}, // 展开数组
{$match: {"userInfo.vip": true}},
{$project: {orderId: "$_id", userName: "$userInfo.name", amount: 1}}
])
14. Java聚合API?
@Autowired MongoTemplate mongoTemplate;
public List<UserStats> getUserStats() {
Aggregation aggregation = Aggregation.newAggregation(
Aggregation.match(Criteria.where("status").is("completed")),
Aggregation.group("userId")
.sum("amount").as("totalAmount")
.count().as("orderCount"),
Aggregation.sort(Sort.Direction.DESC, "totalAmount"),
Aggregation.limit(10)
);
return mongoTemplate.aggregate(aggregation, "orders", UserStats.class)
.getMappedResults();
}
15. $facet多管道并行?
// 一个聚合中执行多个管道
db.orders.aggregate([
{$facet: {
"byStatus": [{$group: {_id: "$status", count: {$sum: 1}}}],
"topUsers": [{$group: {_id: "$userId", total: {$sum: "$amount"}}}, {$sort: {total: -1}}, {$limit: 5}],
"monthlyTrend": [{$group: {_id: {$month: "$createdAt"}, count: {$sum: 1}}}]
}}
])
四、MongoDB事务与一致性
16. MongoDB多文档事务?
// Spring Data MongoDB 4.0+事务
@Transactional
public void transferOrder(String fromUserId, String toUserId, BigDecimal amount) {
User from = userRepository.findById(fromUserId).orElseThrow();
User to = userRepository.findById(toUserId).orElseThrow();
from.setBalance(from.getBalance().subtract(amount));
to.setBalance(to.getBalance().add(amount));
userRepository.save(from);
userRepository.save(to);
}
// 事务配置
@Configuration
@EnableTransactionManagement
public class MongoTxConfig {
@Bean MongoTransactionManager mongoTransactionManager(MongoDatabaseFactory factory) {
return new MongoTransactionManager(factory);
}
}
17. 读写关注(Read/Write Concern)?
| 级别 | 说明 | 一致性 | 可用性 |
| w: 1 | 主节点确认 | 低 | 高 |
| w: majority | 多数节点确认 | 高 | 中 |
| w: all | 所有节点确认 | 最高 | 低 |
| readConcern: local | 读本地最新 | 低 | 高 |
| readConcern: majority | 读多数确认 | 高 | 中 |
| readConcern: linearizable | 线性一致性 | 最高 | 低 |
18. 因果一致性(Causal Consistency)?
场景:先写后读,保证读到自己的写
实现:MongoDB自动传递 causal consistency token
ClientSession session = client.startSession();
session.startTransaction();
collection.insertOne(session, doc); // 写
collection.find(session, filter).first(); // 保证读到上面的写
session.commitTransaction();
五、MongoDB副本集与分片
19. 副本集(Replica Set)原理?
架构:
Primary(读写)+ Secondary(读)× N + Arbiter(投票)
选举机制:
1. 心跳检测(2秒一次)
2. Primary故障 → 发起选举
3. 多数投票选出新Primary
4. 优先级、数据新鲜度、网络分区影响选举
Oplog:
- 固定大小集合(local.oplog.rs)
- Primary写操作记录到Oplog
- Secondary异步拉取Oplog重放
- 用于Change Stream
自动故障转移:
- 10秒未心跳 → 标记不可达
- 多数节点确认 → 发起选举
- 新Primary选出 → 客户端自动重连
20. 分片(Sharding)架构?
组件:
- mongos:路由进程,客户端入口
- Config Server:存储元数据(分片信息)
- Shard:数据分片(每个Shard是一个副本集)
分片键选择:
1. 基数大:值范围广,数据均匀分布
2. 查询隔离:大多数查询包含分片键
3. 非单调递增:避免热点(避免ObjectId作分片键)
范围分片 vs 哈希分片:
- 范围:支持范围查询,但可能热点
- 哈希:数据均匀,但不支持范围查询
Chunk:
- 默认64MB,超过自动分裂
- Balancer自动迁移Chunk保持均衡
21. Change Stream实时数据流?
// 监听集合变更
@Autowired MongoTemplate mongoTemplate;
public void watchOrders() {
ChangeStreamOptions options = ChangeStreamOptions.builder()
.filter(Aggregation.newAggregation(
Aggregation.match(Criteria.where("operationType").in("insert", "update"))
))
.build();
mongoTemplate.changeStream("orders", options, Order.class)
.listen()
.doOnNext(event -> {
Order order = event.getBody();
// 处理变更:更新缓存、通知下游
handleOrderChange(order);
})
.subscribe();
}
六、Redis深度实战
22. Redis核心数据结构?
| 类型 | 底层结构 | 使用场景 |
| String | SDS | 缓存、计数器、分布式锁 |
| List | QuickList(ziplist+linkedlist) | 消息队列、最新列表 |
| Hash | ziplist/hashtable | 对象存储、购物车 |
| Set | intset/hashtable | 标签、共同好友、去重 |
| ZSET | ziplist/skiplist+hashtable | 排行榜、延迟队列 |
| Stream | radix tree | 消息队列(5.0+) |
| HyperLogLog | 概率算法 | UV统计 |
| Bitmap | String | 签到、布隆过滤器 |
| GEO | ZSET | 附近的人 |
23. Redis持久化方案对比?
| 维度 | RDB | AOF |
| 原理 | 定时快照 | 记录每个写操作 |
| 恢复速度 | 快(直接加载) | 慢(重放命令) |
| 数据安全 | 可能丢失两次快照间数据 | 最多丢1秒(appendfsync everysec) |
| 文件大小 | 小(二进制压缩) | 大(文本格式) |
| 适用场景 | 备份、容灾 | 数据安全优先 |
推荐配置:
save 900 1 # 15分钟1次变更触发RDB
save 60 10000 # 60秒10000次变更触发RDB
appendonly yes # 开启AOF
appendfsync everysec # 每秒刷盘
auto-aof-rewrite-percentage 100 # AOF重写阈值
24. Redis主从+哨兵+Cluster?
主从复制:
- 全量同步:新从库连接时,主库生成RDB发送
- 增量同步:通过repl_backlog环形缓冲区
- 异步复制,可能数据不一致
哨兵(Sentinel):
- 监控:定时ping检测主从存活
- 故障转移:主观下线 → 客观下线 → 选举新主
- 通知:告知客户端新主地址
Cluster集群:
- 16384个哈希槽,分散到多个节点
- 每个key = CRC16(key) % 16384 → 对应槽 → 对应节点
- 节点间Gossip协议通信
- 支持在线扩缩容
25. Redis缓存策略?
缓存模式:
1. Cache Aside:读时填充,写时删除(最常用)
2. Write Through:写时同步更新缓存
3. Write Behind:写时只更新缓存,异步写DB
过期策略:
- 惰性删除:访问时检查过期
- 定期删除:每100ms随机抽查,过期则删除
淘汰策略(maxmemory-policy):
- allkeys-lru:所有key中LRU淘汰(推荐)
- volatile-lru:过期key中LRU淘汰
- allkeys-random:随机淘汰
- noeviction:不淘汰,写入报错(默认)
26. 缓存穿透/击穿/雪崩?
穿透:查询不存在的数据 → 缓存和DB都没有
解决:
1. 布隆过滤器:拦截不存在的key
2. 缓存空值:缓存null,设置短过期时间
击穿:热点key过期 → 大量请求打到DB
解决:
1. 互斥锁:只允许一个请求重建缓存
2. 逻辑过期:不设TTL,数据中含逻辑过期时间
3. 热点永不过期:异步刷新
雪崩:大量key同时过期
解决:
1. 过期时间加随机值
2. 多级缓存
3. 熔断降级
27. Redis分布式锁?
// Redisson分布式锁(推荐)
@Autowired RedissonClient redisson;
public void processOrder(String orderId) {
RLock lock = redisson.getLock("order:lock:" + orderId);
try {
if (lock.tryLock(5, 30, TimeUnit.SECONDS)) {
// 处理订单
doProcess(orderId);
} else {
throw new BizException("请勿重复操作");
}
} finally {
if (lock.isHeldByCurrentThread()) lock.unlock();
}
}
// Redisson原理:
// 1. 加锁:Lua脚本 SETNX + PEXPIRE
// 2. 看门狗:后台线程自动续期(默认30秒,每10秒续一次)
// 3. 可重入:hash结构,field=线程ID,value=重入次数
// 4. 释放锁:Lua脚本检查线程ID后删除
28. Redis限流实现?
// 滑动窗口限流
@Component
public class RateLimiter {
@Autowired StringRedisTemplate redisTemplate;
public boolean isAllowed(String key, int maxRequests, int windowSeconds) {
String script = """
local now = redis.call('TIME')
local ms = tonumber(now[1]) * 1000 + math.floor(tonumber(now[2]) / 1000)
local window = tonumber(ARGV[2]) * 1000
redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, ms - window)
local count = redis.call('ZCARD', KEYS[1])
if count < tonumber(ARGV[1]) then
redis.call('ZADD', KEYS[1], ms, ms .. ':' .. math.random())
redis.call('PEXPIRE', KEYS[1], window)
return 1
end
return 0
""";
Long result = redisTemplate.execute(new DefaultRedisScript<>(script, Long.class),
List.of(key), String.valueOf(maxRequests), String.valueOf(windowSeconds));
return result != null && result == 1;
}
}
七、Redis高级应用
29. Redis Lua脚本?
// 库存扣减Lua脚本(原子操作)
@Component
public class StockService {
@Autowired StringRedisTemplate redisTemplate;
private static final String DEDUCT_SCRIPT = """
local stock = tonumber(redis.call('GET', KEYS[1]))
if stock and stock >= tonumber(ARGV[1]) then
redis.call('DECRBY', KEYS[1], ARGV[1])
return 1
end
return 0
""";
public boolean deduct(String productId, int quantity) {
Long result = redisTemplate.execute(
new DefaultRedisScript<>(DEDUCT_SCRIPT, Long.class),
List.of("stock:" + productId), String.valueOf(quantity));
return result != null && result == 1L;
}
}
30. Redis Stream消息队列?
// 生产者
@Autowired StringRedisTemplate redisTemplate;
// 消费者组
public void createConsumerGroup() {
redisTemplate.opsForStream().createGroup("orders", "order-group");
}
// 生产消息
public void produce(OrderEvent event) {
MapRecord<String, String, String> record = StreamRecords.newRecord()
.ofMap(Map.of("orderId", event.getOrderId(), "amount", event.getAmount().toString()))
.withStreamKey("orders");
redisTemplate.opsForStream().add(record);
}
// 消费消息
public void consume() {
List<MapRecord<String, String, String>> records = redisTemplate.opsForStream()
.read(Consumer.from("order-group", "consumer-1"),
StreamOffset.create("orders", ReadOffset.lastConsumed()));
for (MapRecord<String, String, String> record : records) {
process(record);
redisTemplate.opsForStream().acknowledge("orders", "order-group", record.getId());
}
}
31. 布隆过滤器?
// Redisson布隆过滤器
@Autowired RedissonClient redisson;
public void initBloomFilter() {
RBloomFilter<String> bloomFilter = redisson.getBloomFilter("userFilter");
bloomFilter.tryInit(10000000L, 0.01); // 1000万元素,1%误判率
}
public boolean mightExist(String userId) {
RBloomFilter<String> bloomFilter = redisson.getBloomFilter("userFilter");
return bloomFilter.contains(userId);
}
// 注意:布隆过滤器说存在→可能存在,说不存在→一定不存在
32. Redis GEO地理位置?
@Autowired StringRedisTemplate redisTemplate;
// 添加位置
public void addLocation(String userId, double lng, double lat) {
redisTemplate.opsForGeo().add("user:locations", new Point(lng, lat), userId);
}
// 查找附近的人
public List<GeoResult<RedisGeoCommands.GeoLocation<String>>> findNearby(
double lng, double lat, double distanceKm) {
GeoResults<RedisGeoCommands.GeoLocation<String>> results =
redisTemplate.opsForGeo().radius("user:locations",
new Circle(new Point(lng, lat), new Distance(distanceKm, Metrics.KILOMETERS)),
RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs()
.includeDistance().sortAscending().limit(20));
return results == null ? List.of() : results.getContent();
}
八、NoSQL选型与对比
33. CAP理论?
CAP三要素:
- Consistency(一致性):所有节点看到相同数据
- Availability(可用性):每个请求都能得到响应
- Partition Tolerance(分区容忍):网络分区时系统仍工作
CP系统:MongoDB(强一致)、Redis Cluster、HBase
AP系统:Cassandra、DynamoDB、CouchDB
CA系统:单机MySQL(不存在分布式场景)
34. NoSQL四大分类?
| 类型 | 代表 | 特点 | 适用场景 |
| 键值 | Redis/Memcached | 极高性能 | 缓存、计数器 |
| 文档 | MongoDB | 灵活Schema | 内容管理、日志 |
| 列族 | HBase/Cassandra | 海量数据 | 时间序列、IoT |
| 图 | Neo4j | 关系查询 | 社交网络、推荐 |
35. MongoDB vs Redis vs MySQL?
| 维度 | MySQL | MongoDB | Redis |
| 数据模型 | 关系表 | 文档 | 键值 |
| 查询能力 | SQL,最丰富 | 丰富(MQL) | 简单命令 |
| 事务 | 强ACID | 4.0+多文档事务 | 有限事务 |
| 扩展性 | 垂直为主 | 原生水平扩展 | 原生分片 |
| 持久化 | 磁盘 | 磁盘 | 内存+可选持久化 |
| 适用 | 核心业务 | 灵活Schema | 缓存/实时 |
36. 什么时候用MongoDB?
适合MongoDB的场景:
1. Schema不固定:用户画像、日志、IoT数据
2. 大数据量分片:亿级数据水平扩展
3. 聚合分析:复杂聚合管道
4. 地理位置:LBS应用
5. 内容管理:CMS系统
不适合的场景:
1. 强事务要求:银行核心系统 → 用MySQL
2. 复杂关联:多表JOIN → 用MySQL
3. 极低延迟:缓存层 → 用Redis
4. 强一致性:分布式锁 → 用Redis/ZK
九、Spring Data MongoDB实战
37. Spring Data MongoDB配置?
spring:
data:
mongodb:
uri: mongodb://user:pass@host1:27017,host2:27017,host3:27017/mydb?replicaSet=rs0&readPreference=secondaryPreferred
auto-index-creation: true
@Configuration
public class MongoConfig {
@Bean
public MongoCustomConversions customConversions() {
return new MongoCustomConversions(List.of(
new BigDecimalToDecimal128Converter(),
new Decimal128ToBigDecimalConverter()
));
}
}
38. 审计功能(Auditing)?
@Document(collection = "orders")
public class Order {
@Id private String id;
private String orderNo;
@CreatedDate
private Instant createdAt;
@LastModifiedDate
private Instant updatedAt;
@CreatedBy
private String createdBy;
@LastModifiedBy
private String updatedBy;
}
@Configuration
@EnableMongoAuditing(auditorAwareRef = "auditorProvider")
class MongoAuditConfig {
@Bean AuditorAware<String> auditorProvider() {
return () -> Optional.of(SecurityContextHolder.getContext().getAuthentication().getName());
}
}
39. GridFS大文件存储?
@Autowired GridFsTemplate gridFsTemplate;
// 存储
public String storeFile(InputStream inputStream, String filename) {
return gridFsTemplate.store(inputStream, filename, "application/pdf").toString();
}
// 读取
public GridFsResource getFile(String fileId) {
return gridFsTemplate.getResource(gridFsTemplate.findOne(
Query.query(Criteria.where("_id").is(fileId))));
}
// 适合:>16MB的文件存储,如PDF、视频、图片
40. 自定义Converter?
// 枚举与字符串互转
@ReadingConverter
public class StringToStatusConverter implements Converter<String, OrderStatus> {
@Override
public OrderStatus convert(String source) {
return OrderStatus.valueOf(source);
}
}
@WritingConverter
public class StatusToStringConverter implements Converter<OrderStatus, String> {
@Override
public String convert(OrderStatus source) {
return source.name();
}
}
十、面试高频综合题
41. 双写一致性(Redis+MySQL)?
方案一:Cache Aside(推荐)
写:先更新DB → 再删除缓存
读:先读缓存 → miss则读DB → 写入缓存
方案二:延迟双删
写:删缓存 → 更新DB → 延迟N毫秒 → 再删缓存
解决:并发时旧数据被写入缓存的问题
方案三:Canal监听Binlog
MySQL Binlog → Canal → 删除Redis缓存
异步解耦,最终一致性
方案四:消息队列
写DB成功 → 发MQ → 消费者删除缓存
42. 热Key/大Key处理?
热Key问题:某Key访问量极高,单节点压力过大
解决:
1. 本地缓存:Caffeine二级缓存
2. 热Key分片:key加后缀分散到多个Key
3. 读写分离:从节点分担读压力
大Key问题:单个Value过大(>10KB字符串,>5000个集合元素)
危害:阻塞Redis、网络拥塞、内存不均
解决:
1. 拆分:大Hash拆分为小Hash
2. 压缩:压缩后存储
3. 定期清理:SCAN + unlink删除
4. 监控:redis-cli --bigkeys
43. Redis与数据库双写一致性?
// 最优实践:Canal + Redis
@Component
public class BinlogListener {
@Autowired StringRedisTemplate redisTemplate;
@CanalEventListener(schema = "mydb", table = "users")
public void onUserChange(CanalEntry.EventType eventType, CanalEntry.RowData rowData) {
String userId;
if (eventType == CanalEntry.EventType.DELETE) {
userId = rowData.getBeforeColumnsList().get(0).getValue();
} else {
userId = rowData.getAfterColumnsList().get(0).getValue();
}
redisTemplate.delete("user:" + userId);
}
}
44. MongoDB vs Elasticsearch?
| 维度 | MongoDB | Elasticsearch |
| 定位 | 文档数据库 | 搜索引擎 |
| 写入 | 高吞吐 | 相对较低 |
| 搜索 | 基础文本搜索 | 全文搜索、聚合分析 |
| 事务 | 4.0+支持 | 不支持 |
| 实时性 | 实时 | 近实时(1秒刷新) |
| 适用 | 主数据存储 | 搜索、日志分析 |
45. 分库分表 vs MongoDB?
分库分表(ShardingSphere):
+ 保持MySQL生态
+ DBA熟悉
- 中间件复杂度
- 跨库JOIN困难
- 运维成本高
MongoDB:
+ 原生分片,无需中间件
+ 灵活Schema
+ 内置聚合管道
- 生态不如MySQL成熟
- 学习曲线
选型建议:
- 已有MySQL生态 → ShardingSphere
- 新项目 + 灵活Schema → MongoDB
- 超大规模数据 → MongoDB/HBase
46. Redis集群方案对比?
| 方案 | 节点数 | 扩容 | 适用 |
| 主从 | 1主N从 | 只加从 | 读多写少 |
| 哨兵 | 1主2从+哨兵 | 有限 | 高可用 |
| Cluster | 3主3从起 | 在线扩容 | 大规模 |
47. Redis内存优化?
1. 选择合适的数据结构:小数据用ziplist编码
2. 设置过期时间:避免永久Key堆积
3. 使用Hash:多个字段合并为一个Hash
4. 开启压缩:listpack/zset压缩
5. 定期清理:SCAN + TTL检查
6. maxmemory-policy:设置淘汰策略
监控:
info memory → used_memory, used_memory_rss, mem_fragmentation_ratio
48. MongoDB的监控指标?
核心指标:
- connections:当前连接数
- opcounters:CRUD操作计数
- opLatencies:操作延迟
- metrics.document:文档读写统计
- metrics.cursor:游标使用情况
- wiredTiger.cache:缓存命中率(应>95%)
告警阈值:
- 连接数 > 最大连接数的80%
- 慢查询 > 100ms
- 复制延迟 > 10秒
- 缓存命中率 < 90%
49. NoSQL在AI应用中的角色?
向量存储:Milvus/Pinecone/pgvector → Embedding检索
文档存储:MongoDB → 灵活Schema存文档
缓存:Redis → 模型推理结果缓存、限流
图数据库:Neo4j → GraphRAG知识图谱
列存储:HBase → 海量训练数据存储
Java + AI + NoSQL典型架构:
用户问题 → Redis缓存检查 → Milvus向量检索 → MongoDB文档存储
→ Neo4j图谱查询 → LLM生成 → 结果缓存到Redis
50. Redis在分布式系统中的角色?
缓存:热点数据缓存,减轻DB压力
分布式锁:Redisson实现互斥
限流:滑动窗口/令牌桶
排行榜:ZSET实现
Session:分布式Session共享
消息队列:Stream/Pub-Sub
计数器:INCR原子计数
位图:用户签到、特征标记
地理位置:附近的人/店
延迟队列:ZSET + 定时扫描
面试速记口诀
MongoDB三核心:文档模型灵活Schema、副本集高可用、分片水平扩展
>
Redis三件套:数据结构选对、持久化双保、集群三方案
>
缓存三问题:穿透用布隆、击穿用互斥锁、雪崩加随机过期
>
NoSQL选型:缓存→Redis、灵活→MongoDB、海量→HBase、关系→Neo4j