← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共11章,点击直达)
一、MongoDB基础与文档模型二、MongoDB索引与查询优化三、MongoDB聚合管道四、MongoDB事务与一致性五、MongoDB副本集与分片六、Redis深度实战七、Redis高级应用八、NoSQL选型与对比九、Spring Data MongoDB实战十、面试高频综合题面试速记口诀

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/2dsphereLBS应用
哈希索引哈希分片分片键
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核心数据结构?

类型底层结构使用场景
StringSDS缓存、计数器、分布式锁
ListQuickList(ziplist+linkedlist)消息队列、最新列表
Hashziplist/hashtable对象存储、购物车
Setintset/hashtable标签、共同好友、去重
ZSETziplist/skiplist+hashtable排行榜、延迟队列
Streamradix tree消息队列(5.0+)
HyperLogLog概率算法UV统计
BitmapString签到、布隆过滤器
GEOZSET附近的人

23. Redis持久化方案对比?

维度RDBAOF
原理定时快照记录每个写操作
恢复速度快(直接加载)慢(重放命令)
数据安全可能丢失两次快照间数据最多丢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?

维度MySQLMongoDBRedis
数据模型关系表文档键值
查询能力SQL,最丰富丰富(MQL)简单命令
事务强ACID4.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?

维度MongoDBElasticsearch
定位文档数据库搜索引擎
写入高吞吐相对较低
搜索基础文本搜索全文搜索、聚合分析
事务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从+哨兵有限高可用
Cluster3主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