这可能是最全的MongoDB实战指南：Docker部署到CRUD操作一网打尽！

从零搭建到精通操作，一篇文章搞定MongoDB全流程

📦 目录

  1. 快速部署篇：3种Docker部署方案
  2. 核心操作篇：数据库、集合、文档全掌握
  3. 实战进阶篇：聚合查询、索引优化、操作符详解
  4. 电商实战篇：完整项目练习任务
  5. 性能优化篇：最佳实践与避坑指南

🔧 第一章：3分钟极速部署MongoDB

方案1：基础Dockerfile部署

1
2
3
4
5
6
7
8
9
10
# 使用官方MongoDB镜像
FROM mongo:latest

# 设置管理员账户
ENV MONGO_INITDB_ROOT_USERNAME=admin
ENV MONGO_INITDB_ROOT_PASSWORD=secret
ENV MONGO_INITDB_DATABASE=admin

EXPOSE 27017
CMD ["mongod"]

方案2：一键Docker命令启动

1
2
3
4
5
6
7
8
# 单行命令启动MongoDB
docker run -d \
  --name mongodb \
  -p 27017:27017 \
  -e MONGO_INITDB_ROOT_USERNAME=admin \
  -e MONGO_INITDB_ROOT_PASSWORD=secret \
  -v mongodb_data:/data/db \
  mongo:latest

方案3：生产级Docker Compose部署（⭐推荐⭐）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
version: '3.8'
services:
  mongodb:
    image: mongo:latest
    container_name: mongodb
    restart: unless-stopped  # 自动重启
    environment:
      MONGO_INITDB_ROOT_USERNAME: admin
      MONGO_INITDB_ROOT_PASSWORD: secret
      MONGO_INITDB_DATABASE: admin
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db          # 数据持久化
      - ./init-scripts:/docker-entrypoint-initdb.d:ro  # 初始化脚本
    command: ["mongod", "--auth", "--bind_ip_all"]  # 启用认证，允许远程连接

🚀 第二章：从入门到精通的核心操作

连接MongoDB的两种方式

1
2
3
4
5
# 方式1：容器内连接（开发调试）
docker exec -it mongodb mongosh -u admin -p secret

# 方式2：外部连接（生产环境）
mongosh "mongodb://admin:secret@localhost:27017/?authSource=admin"

2.1 数据库操作（5个核心命令）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 查看所有数据库（隐藏空数据库）
show dbs

// 切换到mydb（不存在则创建）
use mydb

// 查看当前数据库
db

// 创建用户（安全必备）
db.createUser({
  user: "appuser",
  pwd: "apppassword",
  roles: [{ role: "readWrite", db: "mydb" }]
})

// 删除数据库（谨慎操作！）
db.dropDatabase()

2.2 集合操作（MongoDB的”表”）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 显式创建集合（可设置选项）
db.createCollection("users", {
  capped: true,      // 固定大小集合
  size: 5242880,     // 5MB
  max: 5000          // 最多5000条文档
})

// 查看集合详情
show collections
db.getCollectionInfos()

// 动态集合（插入时自动创建）
db.products.insertOne({ name: "测试商品" })  // 自动创建products集合

// 删除集合
db.users.drop()

2.3 文档CRUD实战（增删改查全掌握）

📝 插入数据的3种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 1. 插入单条（推荐）
db.users.insertOne({
  name: "张三",
  age: 25,
  tags: ["vip", "active"],
  meta: { score: 95, level: "A" },
  created_at: new Date()
})

// 2. 批量插入（性能更优）
db.users.insertMany([
  { name: "李四", age: 30 },
  { name: "王五", age: 28 }
], { ordered: false })  // 无序插入，失败继续

// 3. 老版本语法（了解即可）
db.users.insert({ name: "赵六" })

🔍 查询数据的12个实战技巧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// 1. 基础查询
db.users.find().pretty()  // 美化输出

// 2. 条件查询
db.users.find({ age: 25 })                          // 等于
db.users.find({ age: { $gt: 20, $lt: 30 } })        // 范围
db.users.find({ name: /^张/ })                      // 正则（姓张）

// 3. 逻辑查询
db.users.find({ $or: [
  { age: { $lt: 20 } },
  { age: { $gt: 60 } }
]})

// 4. 数组查询
db.users.find({ tags: "vip" })                      // 包含vip标签
db.users.find({ tags: { $all: ["vip", "active"] } }) // 同时包含
db.users.find({ "tags.0": "vip" })                  // 第一个元素是vip

// 5. 投影（选择字段）
db.users.find({}, { name: 1, email: 1, _id: 0 })    // 只返回name和email

// 6. 分页查询
const page = 2
const limit = 10
db.users.find()
  .skip((page - 1) * limit)
  .limit(limit)
  .sort({ created_at: -1 })  // 按创建时间倒序

// 7. 去重查询
db.users.distinct("age")

// 8. 存在性检查
db.users.find({ email: { $exists: true } })         // 有email字段
db.users.find({ email: { $exists: true, $ne: null } }) // 有且不为null

// 9. 类型检查
db.users.find({ age: { $type: "number" } })         // age是数字类型

// 10. 文本搜索（需创建文本索引）
db.articles.find({ $text: { $search: "MongoDB 教程" } })

// 11. 地理位置查询
db.places.find({
  location: {
    $near: {
      $geometry: { type: "Point", coordinates: [116.4, 39.9] },
      $maxDistance: 1000  // 1公里内
    }
  }
})

// 12. 游标操作
const cursor = db.users.find({ age: { $gt: 25 } })
while (cursor.hasNext()) {
  printjson(cursor.next())
}

✏️ 更新操作的8个核心模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// 1. 更新单个文档
db.users.updateOne(
  { name: "张三" },
  { 
    $set: { age: 26, status: "updated" },
    $inc: { version: 1 },           // 版本号+1
    $currentDate: { updated_at: true }
  }
)

// 2. 更新多个文档
db.users.updateMany(
  { status: "inactive" },
  { $set: { last_notified: new Date() } }
)

// 3. 替换整个文档
db.users.replaceOne(
  { _id: ObjectId("...") },
  { name: "新名字", age: 30 }  // 完全替换，只保留_id
)

// 4. 数组操作
db.users.updateOne(
  { name: "张三" },
  {
    $push: { tags: "new_tag" },     // 添加元素
    $pull: { tags: "old_tag" },     // 移除元素
    $addToSet: { tags: "unique" }   // 添加唯一元素
  }
)

// 5. 更新嵌套字段
db.users.updateOne(
  { name: "张三" },
  { $set: { "meta.score": 100 } }
)

// 6. 根据条件更新数组元素
db.users.updateOne(
  { "items.name": "商品A" },
  { $set: { "items.$.price": 99.99 } }
)

// 7. 批量更新插入（upsert）
db.users.updateOne(
  { email: "new@example.com" },
  { 
    $setOnInsert: { created_at: new Date() },  // 只在插入时设置
    $set: { last_login: new Date() }
  },
  { upsert: true }  // 不存在则插入
)

// 8. 更新数组中的子文档
db.users.updateOne(
  { "items.id": 1 },
  { $set: { "items.$.quantity": 10 } }
)

🗑️ 删除操作的安全实践

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 1. 安全删除单条
db.users.deleteOne({ 
  _id: ObjectId("507f1f77bcf86cd799439011"),
  is_deleted: false  // 软删除检查
})

// 2. 批量删除（加限制防止误删）
db.users.deleteMany({
  status: "banned",
  created_at: { $lt: new Date("2023-01-01") }
}).limit(1000)  // 限制每次删除数量

// 3. 软删除模式（推荐生产环境）
db.users.updateOne(
  { _id: ObjectId("...") },
  { 
    $set: { 
      is_deleted: true,
      deleted_at: new Date(),
      deleted_by: "admin"
    }
  }
)

// 4. 真正的物理删除
db.users.deleteMany({ 
  is_deleted: true,
  deleted_at: { $lt: new Date(Date.now() - 30*24*60*60*1000) }  // 30天前删除的
})

🧠 第三章：高级查询与聚合管道

3.1 聚合管道：数据分析利器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
// 电商销售分析案例
db.orders.aggregate([
  // 阶段1：筛选已完成订单
  { 
    $match: { 
      status: "completed",
      created_at: { 
        $gte: new Date("2024-01-01"),
        $lt: new Date("2024-02-01")
      }
    }
  },
  
  // 阶段2：展开订单中的商品
  { $unwind: "$items" },
  
  // 阶段3：关联商品信息
  {
    $lookup: {
      from: "products",
      localField: "items.product_id",
      foreignField: "_id",
      as: "product_info"
    }
  },
  
  // 阶段4：计算销售额
  {
    $addFields: {
      item_total: { 
        $multiply: ["$items.quantity", "$items.price"] 
      }
    }
  },
  
  // 阶段5：按商品类别分组
  {
    $group: {
      _id: { category: "$product_info.category" },
      total_sales: { $sum: "$item_total" },
      total_quantity: { $sum: "$items.quantity" },
      avg_price: { $avg: "$items.price" },
      orders_count: { $sum: 1 }
    }
  },
  
  // 阶段6：排序
  { $sort: { total_sales: -1 } },
  
  // 阶段7：格式化输出
  {
    $project: {
      category: "$_id.category",
      total_sales: { $round: ["$total_sales", 2] },
      total_quantity: 1,
      avg_price: { $round: ["$avg_price", 2] },
      _id: 0
    }
  }
])

3.2 索引优化：查询性能提升10倍+

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// 创建高性能索引
db.users.createIndex(
  { email: 1 }, 
  { 
    unique: true,            // 唯一约束
    partialFilterExpression: { email: { $exists: true } },  // 条件索引
    background: true         // 后台创建
  }
)

// 复合索引（注意字段顺序！）
db.orders.createIndex(
  { user_id: 1, created_at: -1 },  // 常用查询模式
  { name: "idx_user_orders" }      // 指定索引名
)

// 文本索引（全文搜索）
db.articles.createIndex(
  { title: "text", content: "text" },
  { 
    weights: { title: 10, content: 5 },  // 标题权重更高
    default_language: "chinese"          // 中文分词
  }
)

// 地理位置索引
db.places.createIndex({ location: "2dsphere" })

// TTL索引（自动过期）
db.sessions.createIndex(
  { created_at: 1 },
  { expireAfterSeconds: 7 * 24 * 60 * 60 }  // 7天后自动删除
)

// 查看索引使用情况
db.users.aggregate([{ $indexStats: {} }])

// 索引优化建议
db.users.find({ age: 25, city: "北京" }).explain("executionStats")

3.3 事务处理：保证数据一致性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// MongoDB 4.0+ 支持多文档事务
const session = db.getMongo().startSession()

try {
  session.startTransaction({
    readConcern: { level: "snapshot" },
    writeConcern: { w: "majority" }
  })
  
  const users = session.getDatabase("test").users
  const accounts = session.getDatabase("test").accounts
  
  // 转账操作
  const fromUser = users.findOne({ _id: 1 })
  const toUser = users.findOne({ _id: 2 })
  
  if (fromUser.balance < 100) {
    throw new Error("余额不足")
  }
  
  users.updateOne(
    { _id: 1 },
    { $inc: { balance: -100 } },
    { session }
  )
  
  users.updateOne(
    { _id: 2 },
    { $inc: { balance: 100 } },
    { session }
  )
  
  // 记录流水
  accounts.insertOne({
    from: 1,
    to: 2,
    amount: 100,
    created_at: new Date()
  }, { session })
  
  session.commitTransaction()
} catch (error) {
  console.error("事务失败:", error)
  session.abortTransaction()
} finally {
  session.endSession()
}

🛒 第四章：电商系统实战项目

4.1 数据库设计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
// 切换到电商数据库
use ecommerce

// 1. 商品集合
db.products.insertMany([
  {
    _id: ObjectId(),
    name: "iPhone 13 Pro",
    sku: "IP13P-256-BLK",
    price: 8999.00,
    category: "智能手机",
    brand: "Apple",
    attributes: {
      color: "石墨黑",
      storage: "256GB",
      screen_size: "6.1英寸"
    },
    stock: {
      total: 150,
      reserved: 20,
      available: 130
    },
    tags: ["新品", "旗舰", "热卖"],
    ratings: {
      average: 4.8,
      count: 1250
    },
    is_active: true,
    created_at: new Date(),
    updated_at: new Date()
  },
  // ... 更多商品
])

// 2. 用户集合（带索引）
db.users.createIndex({ email: 1 }, { unique: true })
db.users.createIndex({ phone: 1 }, { sparse: true })
db.users.createIndex({ "addresses.city": 1 })

db.users.insertOne({
  username: "tech_guru",
  email: "user@example.com",
  phone: "13800138000",
  profile: {
    real_name: "张三",
    avatar: "https://example.com/avatar.jpg",
    gender: "male",
    birthday: new Date("1990-01-01")
  },
  addresses: [
    {
      id: 1,
      recipient: "张三",
      phone: "13800138000",
      province: "北京市",
      city: "北京市",
      district: "朝阳区",
      detail: "某某街道123号",
      is_default: true
    }
  ],
  membership: {
    level: "gold",
    points: 12500,
    expires_at: new Date("2024-12-31")
  },
  created_at: new Date(),
  last_login: new Date()
})

// 3. 订单集合（分片键设计）
db.orders.createIndex({ user_id: 1, created_at: -1 })
db.orders.createIndex({ order_no: 1 }, { unique: true })
db.orders.createIndex({ status: 1 })

db.orders.insertOne({
  order_no: "ORD202401150001",
  user_id: ObjectId("..."),
  status: "pending",  // pending, paid, shipped, completed, cancelled
  items: [
    {
      product_id: ObjectId("..."),
      sku: "IP13P-256-BLK",
      name: "iPhone 13 Pro",
      quantity: 1,
      unit_price: 8999.00,
      subtotal: 8999.00,
      snapshot: { /* 下单时的商品快照 */ }
    }
  ],
  amount: {
    subtotal: 8999.00,
    shipping: 0.00,
    discount: 200.00,
    total: 8799.00
  },
  payment: {
    method: "alipay",
    transaction_id: "202401152100100...",
    paid_at: new Date(),
    amount: 8799.00
  },
  shipping: {
    address_id: 1,
    courier: "SF Express",
    tracking_no: "SF1234567890",
    shipped_at: null,
    estimated_delivery: new Date("2024-01-18")
  },
  created_at: new Date(),
  updated_at: new Date()
})

4.2 实战查询练习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// 练习1：找出库存紧张的商品
db.products.find({
  "stock.available": { $lt: 50 },
  "is_active": true
}).sort({ "stock.available": 1 })

// 练习2：统计各类别商品平均价格
db.products.aggregate([
  { $match: { is_active: true } },
  {
    $group: {
      _id: "$category",
      count: { $sum: 1 },
      avg_price: { $avg: "$price" },
      max_price: { $max: "$price" },
      min_price: { $min: "$price" }
    }
  },
  { $sort: { avg_price: -1 } }
])

// 练习3：查询用户订单历史（分页）
const getOrdersByUser = (userId, page = 1, limit = 10) => {
  return db.orders.aggregate([
    { $match: { user_id: ObjectId(userId) } },
    { $sort: { created_at: -1 } },
    { $skip: (page - 1) * limit },
    { $limit: limit },
    {
      $lookup: {
        from: "products",
        localField: "items.product_id",
        foreignField: "_id",
        as: "product_details"
      }
    },
    {
      $project: {
        order_no: 1,
        status: 1,
        "amount.total": 1,
        created_at: 1,
        items_count: { $size: "$items" },
        items: {
          $map: {
            input: "$items",
            as: "item",
            in: {
              name: "$$item.name",
              quantity: "$$item.quantity",
              price: "$$item.unit_price"
            }
          }
        }
      }
    }
  ])
}

// 练习4：销售排行榜
db.orders.aggregate([
  { $match: { 
    status: "completed",
    created_at: { $gte: new Date("2024-01-01") }
  }},
  { $unwind: "$items" },
  {
    $group: {
      _id: "$items.product_id",
      total_sold: { $sum: "$items.quantity" },
      total_revenue: { $sum: "$items.subtotal" }
    }
  },
  { $sort: { total_revenue: -1 } },
  { $limit: 10 },
  {
    $lookup: {
      from: "products",
      localField: "_id",
      foreignField: "_id",
      as: "product"
    }
  },
  { $unwind: "$product" },
  {
    $project: {
      product_name: "$product.name",
      category: "$product.category",
      total_sold: 1,
      total_revenue: 1,
      avg_price: { $divide: ["$total_revenue", "$total_sold"] }
    }
  }
])

🚨 第五章：生产环境最佳实践

5.1 安全配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# docker-compose.prod.yml
version: '3.8'
services:
  mongodb:
    image: mongo:6.0
    container_name: mongodb_prod
    restart: always
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_ROOT_USER}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_ROOT_PASSWORD}
      MONGO_INITDB_DATABASE: admin
    ports:
      - "27017:27017"
    volumes:
      - mongodb_data:/data/db
      - ./mongod.conf:/etc/mongod.conf:ro  # 自定义配置
      - ./ssl:/ssl:ro  # SSL证书
      - ./backups:/backups  # 备份目录
    command: 
      - "--config"
      - "/etc/mongod.conf"
      - "--auth"
      - "--bind_ip_all"
      - "--keyFile"
      - "/data/keyfile"  # 副本集认证
    networks:
      - internal_network  # 内部网络
    deploy:
      resources:
        limits:
          memory: 4G
        reservations:
          memory: 2G

volumes:
  mongodb_data:
    driver: local
    driver_opts:
      type: none
      device: /data/mongodb
      o: bind

5.2 MongoDB配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
# mongod.conf
storage:
  dbPath: /data/db
  journal:
    enabled: true
  wiredTiger:
    engineConfig:
      cacheSizeGB: 2  # 根据内存调整

systemLog:
  destination: file
  path: /var/log/mongodb/mongod.log
  logAppend: true
  logRotate: reopen

processManagement:
  fork: false  # Docker中设置为false

net:
  port: 27017
  bindIp: 0.0.0.0  # Docker中需要
  maxIncomingConnections: 1000

security:
  authorization: enabled
  keyFile: /data/keyfile

operationProfiling:
  slowOpThresholdMs: 100
  mode: slowOp

5.3 备份与恢复策略

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# 1. 定时备份脚本
#!/bin/bash
BACKUP_DIR="/backups/mongodb"
DATE=$(date +%Y%m%d_%H%M%S)
CONTAINER_NAME="mongodb_prod"

# 执行备份
docker exec $CONTAINER_NAME mongodump \
  --username admin \
  --password "${MONGO_ROOT_PASSWORD}" \
  --authenticationDatabase admin \
  --out /backups/dump_$DATE

# 压缩备份
docker exec $CONTAINER_NAME tar -czf /backups/mongodb_backup_$DATE.tar.gz -C /backups dump_$DATE

# 清理旧备份（保留7天）
find $BACKUP_DIR -name "*.tar.gz" -mtime +7 -delete

# 2. 恢复数据
docker exec -i $CONTAINER_NAME mongorestore \
  --username admin \
  --password "${MONGO_ROOT_PASSWORD}" \
  --authenticationDatabase admin \
  --drop \
  /backups/dump_20240115

# 3. 导出单集合
docker exec $CONTAINER_NAME mongoexport \
  --username appuser \
  --password "apppassword" \
  --db ecommerce \
  --collection orders \
  --query '{ "status": "completed" }' \
  --out /backups/orders.json

# 4. 监控脚本
docker exec $CONTAINER_NAME mongosh \
  --username admin \
  --password "${MONGO_ROOT_PASSWORD}" \
  --eval "
    const status = db.serverStatus();
    print('连接数:', status.connections.current);
    print('内存使用:', status.mem.virtual + 'MB');
    print('操作计数:', status.opcounters);
  "

5.4 性能监控

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 1. 慢查询分析
db.setProfilingLevel(1, { slowms: 100 })  // 记录超过100ms的查询

// 查看慢查询日志
db.system.profile.find({ millis: { $gt: 100 } })
  .sort({ ts: -1 })
  .limit(10)

// 2. 查询计划分析
db.users.find({ email: "test@example.com" })
  .explain("executionStats")

// 3. 索引使用情况
db.users.aggregate([{ $indexStats: {} }])

// 4. 当前操作监控
db.currentOp({
  "active": true,
  "secs_running": { "$gt": 5 }
})

// 5. 杀死慢查询
db.killOp(opid)

5.5 常见问题与解决方案

❌ 问题1：连接数过多

1
2
3
4
5
6
7
8
9
10
11
# 解决方案：调整连接池
net:
  maxIncomingConnections: 1000
  maxIncomingConnections: 500  # 根据实际情况调整

# 应用端配置
mongoose.connect(uri, {
  poolSize: 10,  # 连接池大小
  maxPoolSize: 50,
  minPoolSize: 5
})

❌ 问题2：内存不足

1
2
3
4
5
6
7
8
9
10
11
// 监控内存使用
db.serverStatus().mem

// 限制缓存大小
storage:
  wiredTiger:
    engineConfig:
      cacheSizeGB: 2  # 不超过物理内存的60%

// 优化查询
db.collection.find().hint({ index_name: 1 })  # 强制使用索引

❌ 问题3：磁盘空间不足

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 启用压缩
storage:
  wiredTiger:
    collectionConfig:
      blockCompressor: snappy  # 或 zstd

# 清理旧数据
db.logs.deleteMany({ 
  created_at: { $lt: new Date("2023-01-01") } 
})

# 使用TTL索引自动清理
db.sessions.createIndex(
  { created_at: 1 },
  { expireAfterSeconds: 604800 }  # 7天
)

📊 第六章：性能对比与选择指南

MongoDB vs 其他数据库

特性 MongoDB MySQL Redis
数据模型 文档型 关系型 键值对
Schema 动态 固定 无
查询语言 JSON式 SQL 命令式
扩展性 水平扩展 垂直扩展 内存扩展
适用场景 内容管理、IoT、实时分析 事务系统、财务系统 缓存、会话、队列

使用场景建议

✅ 适合MongoDB的场景：

  • 快速迭代的产品原型
  • 内容管理系统（CMS）
  • 物联网设备数据存储
  • 实时分析平台
  • 移动应用后端

❌ 不适合MongoDB的场景：

  • 复杂的事务系统（银行、支付）
  • 需要严格ACID保证的系统
  • 已有成熟SQL方案的系统

🎯 总结与下一步

通过本文，你已经掌握了：

  1. ✅ 部署技能：3种Docker部署方案
  2. ✅ 核心操作：CRUD全流程实战
  3. ✅ 高级特性：聚合、索引、事务
  4. ✅ 项目实战：完整电商系统设计
  5. ✅ 生产实践：安全、备份、监控

下一步学习建议：

  1. 深入学习：

    • MongoDB Atlas（云服务）
    • Change Streams（实时数据流）
    • GraphQL集成

  2. 实战项目：

    • 构建博客系统
    • 实现实时聊天
    • 搭建电商平台

  3. 性能优化：

    • 查询性能调优
    • 分片集群部署
    • 读写分离配置

📚 资源推荐

  1. 官方文档：docs.mongodb.com
  2. 学习平台：
    • MongoDB University（免费课程）
    • 掘金、思否社区文章
  3. 工具推荐：
    • MongoDB Compass（GUI工具）
    • Robo 3T（轻量客户端）
    • Studio 3T（高级功能）

最后提醒：数据库技术日新月异，保持学习才能不被淘汰。建议每隔半年回顾一次最佳实践，及时更新知识体系。

希望这篇长文能成为你的MongoDB实战宝典！如果有问题或建议，欢迎在评论区交流讨论。💪

标签：#MongoDB #Docker #数据库 #后端开发 #NoSQL