MongoDB：从容器使用到 Mongosh、Python/Node.js 数据操作（结构清晰万字长文）

文章目录

• • [1. 容器与应用之间的关系介绍](#1. 容器与应用之间的关系介绍)
  • [2. 使用 Docker 容器安装 MongoDB](#2. 使用 Docker 容器安装 MongoDB)
  • [3. Mongosh 操作](#3. Mongosh 操作)
  • • [3.1 Mongosh 连接到 MongoDB](#3.1 Mongosh 连接到 MongoDB)
    • [3.2 基础操作与 CRUD](#3.2 基础操作与 CRUD)
  • [4. Python 操作 MongoDB](#4. Python 操作 MongoDB)
  • [5. Nodejs 操作 MongoDB](#5. Nodejs 操作 MongoDB)
  • • [5.1 Mongodb 和 Mongoose](#5.1 Mongodb 和 Mongoose)
    • [5.2 推荐在项目中使用 Mongoose](#5.2 推荐在项目中使用 Mongoose)
  • 参考文献

1. 容器与应用之间的关系介绍

MongoDB 的安装有时候并不是那么容易的，为了简化这个步骤，比较舒适好用的方法是使用容器（Container）安装。

在讲容器之前先说一下容器的镜像（Image），镜像是容器的前置基础，是一个关于某些应用的软件包。在镜像里规定了要运行这个应用需要准备的所有内容，包括代码、运行时、库、环境变量和配置文件等。通过一个镜像可以创建和运行容器实例。（镜像如下图1）

容器是一套完整的应用程序环境，包括应用程序本身及其所有依赖项，如库、运行时、系统工具和设置等。通过使用容器启动应用程序，用户无需手动解决各种依赖和系统环境问题，即可实现快速启动。以 MongoDB 为例，启动该数据库只需下载相应的 MongoDB 镜像，然后使用该镜像创建容器，即可立即启动 MongoDB 服务如下图 2 所示。

需要注意的是，尽管 MongoDB 运行在容器中，但实际上并非完全在本地执行。以在 Linux 主机内安装 MongoDB 为例：在 Linux 环境下进行安装需要一个操作系统，因此在容器中，除了 MongoDB，还需要集成一个完整的操作系统。

整理说明即在我们的 Linux 主机（最先希望安装数据库的机器）中，有一个容器，在这个容器内有一个 Linux 的系统，在这个系统中，安装了一个 MongoDB 的服务，所谓的使用容器运行 MongoDB 就是指使用了这样一个服务。

到这里是否有个疑问------这应该算是在当前主机访问另一个主机了，那么我们要怎么访问这个 MongoDB 呢？是否应该进入到这个系统中，然后像使用别的数据库那样，打开一个 CLI 客户端，输入指令进行增删改查呢？

当然，这确实是一种访问方式。实际上我们知道就算是安装在本地的数据库，也会选择工作在一个端口中。譬如 MySQL 的 3306，Redis 的 6379，MongoDB 的是 27017。所以容器就将系统内端口与主机的端口建立了相互的映射，将容器内的一个端口映射成主机的端口，就像是上面图 2 的 PORTS 所示，此时容器的 27017 端口就是主机的 27017 端口，访问主机的 27017 端口即是访问容器的 27017 端口。

2. 使用 Docker 容器安装 MongoDB

1. 使用以下命令安装一个 Docker，如果你还没有的话

   apt install docker.io

   安装完毕后可以使用以下命令验证，如正确安装会显示一个版本号

   docker --version

2. 使用以下命令下载 MongoDB 镜像

   docker pull mongo

   下载完成后可以使用以下命令查看镜像列表

   docker images

3. 使用下载好的镜像启动 MongoDB 容器

   docker run -d -p 27017:27017 --name my-mongodb mongo

   在上述命令中，run 是启动一个容器，-d 是指定在后台运行；-p 是在主机和容器之间创建端口映射，冒号左侧是主机端口，右侧是容器端口；--name 是为当前容器命名，mongo 是镜像名，如果有版本需求，还可以加上版本标签，如 mongo:latest，具体的镜像名称和版本号可以通过镜像列表查看。

   容器启动后的情况使用 docker ps 命令查看如下图划线部分所示：

   

4. 使用下面的命令在进入到容器内

   docker exec -it 8424792f4ec4 /bin/bash

   其中 exec 是指在容器内执行命令，-i 是使标准输入保持打开，-t 是分配一个伪终端，同时使用可以理解为交互式执行命令，并分配一个伪终端 ，8424792f4ec4 是容器的 ID，保证唯一的情况下可以简略输入。/bin/bash 是实际使用的 Shell（Shell 可以理解为一种命令行界面），当然你也可以只输入 bash，这是一样的效果。由此可以持续性地操作容器。情况大概如下图所示，与操作 Linux 没什么不同，顺便一提得是，从 MongoDB 的 Dockerfile 中可以看到大致的安装过程。

   

5. 在容器内使用如下命令，进入到 MongoDB 的 Shell 中。

   mongosh

   当出现下面的状态时就代表了成功进入，那之后的操作将会在下文中详细说明。

   

6. 如需了解更多的 Docker 命令，可以查阅此文档 https://dockerdocs.cn/reference/index.html

3. Mongosh 操作

3.1 Mongosh 连接到 MongoDB

在 2.5 中使用 mongosh 命令连接到 MongoDB 仅为使用默认参数，该命令加上一些可能使用到的参数后类似于下面这个命令：

mongosh --host localhost --port 27017

或者类似于下面这一行：

mongosh "mongodb://localhost:27017"

这在 MongoDB 中被称为连接串（Connection String），即使用一个字符串来代表所有的参数。连接串的使用常见于使用代码连接 MongoDB 的场景。

为了安全性，一般需要启用密码来登录 MongoDB。在容器中要通过 conf 来使用密码比较困难，推荐的做法是在容器启动的时候设置一些环境变量来启用密码，如下：

docker run -d -p 27017:27017 --name my-mongodb2 \
-e MONGO_INITDB_ROOT_USERNAME=admin \
-e MONGO_INITDB_ROOT_PASSWORD=admin123 \
-e MONGO_INITDB_DATABASE=admin \
mongo

这个命令在启动容器的时候为 Mongodb 设置了一个 ROOT 用户 admin，密码是 admin123，在指定的数据库 admin 中进行身份验证。（注意事项：在设置密码或者账号时候，尽量避免使用 ":"、"@" 等符号，以保证密码字符串会被数据库引擎正确解析。）

这个时候如果只像上文一样，Mongosh 只设置了端口号和主机名的话，是没有权限操作的，得到的结果就像下面一样：

test> show databases
MongoServerError: Command listDatabases requires authentication

使用以下的方法选择一个进行身份验证：

1. mongosh --username admin --password admin123
2. mongosh "mongodb://admin:admin123@localhost:27017"
3. mongosh --username admin --password admin123 --authenticationDatabase admin
4. mongosh "mongodb://admin:yejue123@localhost:27017/database?authSource=admin"

如果你的用户是创建在 admin 数据库以外的，需要指定在哪个数据库进行验证，并且登录后也只能看到那一个数据库。

另外，可以依次执行下列命令看到容器在启动时设置的用户：

use admin
show collections
db.system.users.find()

3.2 基础操作与 CRUD

以下列出一些简单的操作：

# 显示数据库
show databases

# 创建数据库/切换数据库
use databasename

# 查看内置的 role
show roles

# 在当前数据库创建一个用户
db.createUser(
	{
		user: username, 
		pwd: password, 
		roles: [{role: "readWrite", db: dbtabases name}]
	}
)

# 查看当前数据库的所有用户
db.getUsers()

# 查看所有的集合
show collections

Mongodb 是面向文档的 NoSQL 的数据库，数据通常以 BSON 格式存储，而在 Mongosh 中看到的则是以 JSON 格式显示的。MongoDB 有三种组织数据的层级：数据库、集合（Collection）、文档（Document）。他们之间的关系用一句话概括即 "在一个数据库中有若干个集合，集合内通常存放着有相似内容的文档"。如果以关系型数据库来类比，则集合相当于一个表，一个文档相当于一行记录。这个文档并非常见的"文件文档"，而是一个键值对形式的 JSON/BSON 对象。下面我们将以一些例子来引入完整的 CRUD，请读者在其中体会集合与文档的含义。

例1：假设有一个图书管理系统的数据库，里面有各种各样的图书。

1. 创建一个数据库 "BookManagement"。use BookManagement

2. 使用 db.createCollection() 函数来创建名为 books 的集合，执行以下命令：

   db.createCollection("books")

   以默认参数创建的集合没有大小限制，存储空间会自动增长。可以通过指定一些参数来限制集合大小是否自动增长，如下则设置了一个最大存储空间 100 MB、最大文档数量为 1000 的集合：

   db.createCollection("books", { capped: true, size: 100 * 1024*1024, max: 1000})

   可以通过 db.collection.stats() 函数看到集合的设置：

   db.books.stats()

3. Insert

   向集合内插入文档（数据）的方式有两种，下面我们分别以单条插入和多条插入的方法，向 resources 插入几个文档。

   单个插入 db.collection.insertOne()：

   db.books.insertOne({
   	title: "围城",
   	authors: ["钱钟书"],
   	publication_year: 1947,
   	publisher: "上海文艺出版社",
   	tags: ["小说", "讽刺文学"],
   	remainings: 10
   })

   批量插入 db.collection.insertMany()：

   db.books.insertMany([
     {
       title: "活着",
       authors: ["余华"],
       publication_year: 1993,
       publisher: "作家出版社",
       tags: ["小说", "现实主义"],
       remainings: 5
     },
     {
       title: "红楼梦",
       authors: ["曹雪芹"],
       publication_year: 1791,
       publisher: "人民文学出版社",
       tags: ["古典小说", "传统文学"],
       remainings: 8
     },
   ])

   现在可以通过以下函数来查询集合中所有的文档：

   db.books.find()

4. Query

   接下来将演示三种常见的查找："="、"in"、"AND / OR"。

   第一种，指定相等条件：查找书名为"活着"的书

   BookManagement> db.books.find({title: "活着"})
   [
     {
       _id: ObjectId('65b49ed320bf3de68d11029c'),
       title: '活着',
       ...
     }
   ]

   第二种，使用查询运算符 $in ：查找书名在下列所给出的列表中的书籍

   BookManagement> db.books.find({title: {$in: ["活着","围城"]}})
   [
     {
       _id: ObjectId('65b49da320bf3de68d11029b'),
       title: '围城',
       ...
     },
     {
       _id: ObjectId('65b49ed320bf3de68d11029c'),
       title: '活着',
       ...
     }
   ]

   第二种，使用查询运算符 gte：查询剩余数量大于等于 10 的

   BookManagement> db.books.find({remainings: {$gte: 10}})
   [
     {
       _id: ObjectId('65b49da320bf3de68d11029b'),
       title: '围城',
       remainings: 10
       ...
     }
   ]

   更多的查询运算符请查阅此文档：https://www.mongodb.com/docs/manual/reference/operator/query/#query-selectors

   第三种，逻辑运算符 AND：查找出版年份大于 1700 年并且是小说类型的

   BookManagement> db.books.find({publication_year: {$gt: 1700}, tags: {$in: ["小说"]}})
   [
     {
       title: '围城',
       publication_year: 1947,
       tags: [ '小说', '讽刺文学' ],
       ...
     },
     {
       title: '活着',
       publication_year: 1993,
       tags: [ '小说', '现实主义' ],
       ...
     }
   ]

   从结果中可以看到《红楼梦》并没有被匹配到，因为红楼梦的标签里是"古典小说"，如果我们希望凡是含有"小说"的都看做是小说，加上我们的 tags 是一个列表，那么查询条件就成了这样：查找年份大于 1700 的，内部任一标签中含有"小说"字样的书。这个查询可以使用元素匹配运算符 $elemMatch 和正则运算符 $regex，对 tags 中每一个标签进行匹配查询。

   BookManagement> db.books.find({publication_year: {$gt: 1400}, tags: {$elemMatch: {$regex: "小说"}}})
   [
     {
       title: '围城',
       publication_year: 1947,
       tags: [ '小说', '讽刺文学' ],
       ...
     },
     {
       title: '活着',
       publication_year: 1993,
       tags: [ '小说', '现实主义' ],
       ...
     },
     {
       title: '红楼梦',
       publication_year: 1791,
       tags: [ '古典小说', '传统文学' ],
       ...
     }
   ]

   第三种，逻辑运算符 OR：查找出版年份大于 1990 或者剩余数量大于等于 10 的

   BookManagement> db.books.find({$or: [{publication_year: {$gt: 1990}}, {remainings: {$gte: 10}}]})

5. Update

   MongoDB 的更新操作可以使用 updateOne、updateMany 方法。这两个方法的参数第一个是过滤器，第二个是更新操作，以及一些参数。

   db.collection.updateOne(<filter>, <update>, options)
   db.collection.updateMany(<filter>, <update>, options)

   其中 filter 即指定过滤（匹配）条件，与上文中的查询一致，当查询到若干条或单条数据后，对这些数据进行更新操作。如果是 updateOne 则对匹配到的第一条进行更新，如果是 updateMany 则对匹配到的所有条目进行更新。以下是一些基础示例：

   【例1】假设要将《活着》的书库存设置为 20：

   BookManagement> db.books.updateOne({title: "活着"}, {$set: {remainings: 20}})
   {
     acknowledged: true,
     insertedId: null,
     matchedCount: 1,
     modifiedCount: 1,
     upsertedCount: 0
   }

   在这个示例中，使用了 $set 操作符将剩余数量直接改成了 20，返回的结果中，"matchedCount" 是匹配到的数量，"modifiedCount " 是修改的文档数量，其中 "upsertedCount" 是更新插入的数量，如果在 options 中使用 {upsert: true}，那么当 filter 匹配不到文档的时候，将会新建一个文档。

   【例2】假设要将所有的书库存设置为 0：

   BookManagement> db.books.updateMany({}, {$set: {remainings: 0}})
   {
     acknowledged: true,
     insertedId: null,
     matchedCount: 3,
     modifiedCount: 3,
     upsertedCount: 0
   }

   有些时候我们只希望在原有的基础上增加，而不是完全覆盖式更新。下面给出一些例子：

   【例3】将 2000 年前的书增加一个标签 "2000年前的书"：

   db.books.updateMany( 
   	{"publication_year": { $lt: 2000 }},
   	{$addToSet: { "tags": "2000年前的书" }}
   )

   上述操作使用了 $lt（小于）操作符，找到所有出版年份早于 2000 年的书籍。然后，使用 $addToSet 操作符将新标签添加到每个匹配文档的 "tags" 数组中。如果标签已经存在于某本书的 "tags" 数组中，$addToSet 会确保不重复添加相同的标签。如果不需要查重，可以使用 $push 操作符，这样无论标签是否已存在，都会被添加到 "tags" 数组中。

6. Delete

   想要删除特定条件下的文档，可以使用 deleteOne 或 deleteMany 操作。以下是一些示例：

   【例4】删除出版年份早于 1800 年的书：

   BookManagement> db.books.deleteMany({publication_year: {$lt: 1800}})
   { acknowledged: true, deletedCount: 1 }

   【例5】删除 "tags" 中含有"小说"字样的书，但只删除默认排序的第一本：

   BookManagement> db.books.deleteOne({tags: "小说"})
   { acknowledged: true, deletedCount: 1 }

   此时查看 Collection 里的结果，是《围城》被删掉了，剩下一本书《活着》。MongoDB 的默认排序是按照 "_id" 升序排序。《围城》在本例中是第一个被插入到 Collection 中的，所以优先被匹配删除。

   自此 CRUD 告一段落，对于CRUD 更多的细节，可以参照 MongoDB 的官方文档，已在本文末尾列出。

4. Python 操作 MongoDB

当使用 Python 连接 MongoDB 并执行 CRUD 操作时，可以使用 pymongo 库。本节将会使用一些简单示例，演示如何连接到 MongoDB 并执行基本的 CRUD 操作。首先，确保你已经安装了 pymongo 库：

pip install pymongo

接下来，你可以使用以下示例代码连接到数据库：

import pymongo

# MongoDB 连接字符串，格式为：mongodb://<username>:<password>@<host>:<port>/<database>
# 如果不需要认证，可以省略 <username>:<password>@ 部分
connection_string = "mongodb://username:password@localhost:27017/mydatabase"

# 创建 MongoDB 客户端
client = pymongo.MongoClient(connection_string)

连接串已经在上文 3.1 中做了详细介绍，在此不做过多介绍。

通常创建完成客户端后并不一定就成功连接了，运行下面的代码进行检查，如果成功连接可以看到输出的数据库名字。

print(client.list_database_names())

接下来创建一个数据库和集合：

# 创建或选择数据库
db = client.BookManagement
print(db)
# 创建或选择集合
collection = db.books
print(collection)

在代码中创建数据库和集合与 Mongosh 中的逻辑相近，均为不存在则创建，如果存在则选择。

现在我们已经连接到 MongoDB 并选择了数据库和集合，我们可以开始执行 CRUD 操作。以下是一些基本的示例：

Insert

# 插入文档
document_to_insert = {"name": "John Doe", "age": 30, "city": "New York"}
result = collection.insert_one(document_to_insert)
print("成功插入文档，文档ID：%s" % result.inserted_id)

Query

# 查询文档
query_to_find = {"city": "New York"}
documents = collection.find(query_to_find)
print(list(documents))

Update

query_to_update = {"name": "John Doe"}
update_data = {"$set": {"age": 31}}
result = collection.update_one(query_to_update, update_data)
print("成功更新文档，匹配：%d，修改：%d" % (result.matched_count, result.modified_count))

所有的过滤器书写规则与 Mongosh 一致，在 Python 中需要注意的是 Python 字典并不能直接写诸如 "$set" 等的操作符，应遵循 Python 的规则，使用字符串的方式来写入操作符。如需查看详情请参照上文 3.2 部分。

Delete

# 删除文档
result = collection.delete_one(query_to_update)
print("成功删除文档，删除：%d" % result.deleted_count)

Disconnect

# 断开与 MongoDB 的连接
client.close()

5. Nodejs 操作 MongoDB

5.1 Mongodb 和 Mongoose

在 Node.js 中，有几种库可以用来操作 MongoDB。其中两个主要的是 MongoDB 官方的驱动程序（mongodb）和 Mongoose（推荐项目中使用 Mongoose）。以下是它们的简要介绍：

1. MongoDB 官方驱动程序（mongodb）：

   • 安装：npm install mongodb

   • 特点：

     • 提供了 MongoDB 的原生驱动程序，允许直接与 MongoDB 数据库进行低级别的交互。
     • 支持各种 MongoDB 特性和操作。
     • 对于直接操作 MongoDB，执行原生的查询和操作，是一个轻量级的选择。

   • 使用示例

     const { MongoClient } = require('mongodb');
     
     // 连接到数据库
     const client = new MongoClient('mongodb://localhost:27017', { useNewUrlParser: true, useUnifiedTopology: true });
     client.connect().then(async () => {
       // 在这里执行 MongoDB 操作
       const database = client.db('mydatabase');
       const collection = database.collection('mycollection');
     
       // 插入文档
       const documentToInsert = { name: 'John Doe', age: 30, city: 'New York' };
       await collection.insertOne(documentToInsert);
     
       // 查询文档
       const queryToFind = { city: 'New York' };
       const result = await collection.find(queryToFind).toArray();
       console.log(result);
     
       // 更新文档
       const queryToUpdate = { name: 'John Doe' };
       const updateData = { $set: { age: 31 } };
       await collection.updateOne(queryToUpdate, updateData);
     
       // 查询更新后的文档
       const documentsAfterUpdate = await collection.find(queryToUpdate).toArray();
       console.log(documentsAfterUpdate);
     
       // 删除文档
       await collection.deleteOne(queryToUpdate);
     
       // 关闭连接
       client.close();
     });

2. Mongoose

   • 安装：npm install mongoose

   • 特点：

     • 提供了对象模型工具，允许在应用中定义模型和模式，更易于维护和扩展。
     • 封装了 MongoDB 的原生驱动，提供了更高级别的抽象和功能，例如中间件、查询构建、数据验证等。
     • 适用于构建复杂的数据模型和应用。

   • 使用示例（此处仅为格式对称用代码，可以直接看 5.2）

     const mongoose = require('mongoose');
     
     // 连接到数据库
     mongoose.connect('mongodb://localhost:27017/mydatabase', { useNewUrlParser: true, useUnifiedTopology: true });
     
     const db = mongoose.connection;
     
     db.once('connected', async () => {
       // 在这里执行 Mongoose 操作
       const MyModel = mongoose.model('MyModel', new mongoose.Schema({
         name: String,
         age: Number,
         city: String
       }));
     
       // 插入文档
       const documentToInsert = new MyModel({ name: 'John Doe', age: 30, city: 'New York' });
       await documentToInsert.save();
     
       // 查询文档
       const documents = await MyModel.find({ city: 'New York' });
       console.log(documents);
     
       // 更新文档
       await MyModel.updateOne({ name: 'John Doe' }, { $set: { age: 31 } });
     
       // 查询更新后的文档
       const documentsAfterUpdate = await MyModel.find({ name: 'John Doe' });
       console.log(documentsAfterUpdate);
     
       // 删除文档
       await MyModel.deleteOne({ name: 'John Doe' });
     
       // 关闭连接
       mongoose.connection.close();
     });

5.2 推荐在项目中使用 Mongoose

推荐 Mongoose 的最大原因就是 Mongoose 允许你使用模式（Schema）来定义 MongoDB 文档的结构和规则。这使得数据模型的定义更加清晰，模式还支持数据验证，确保数据符合预期的格式和规则。下面是一个模型示例：

const mongoose = require('mongoose');

// 模式定义
const bookManagementSchema = new mongoose.Schema({
    title: {
        type: String,
        required: true
    },
    author: String,
    publishedDate: Date,
    genre: String
}, { collection: 'book_management' });

// 模型创建
const BookManagementModel = mongoose.model('BookManagement', bookManagementSchema);

在这个模型中，我们使用 Schema 预定义了一个 book_management 的集合，可以清楚地看到其中的参数及其参数类型。

在执行完模型创建的代码后，数据库中创建了一个空的 Collection，以下是一些基本的 CRUD 示例：

async function main() {
  // 创建文档并保存 (Create)
  const newBook = new BookManagementModel({
    title: 'The Great Gatsby',
    author: 'F. Scott Fitzgerald',
    publishedDate: new Date('1925-04-10'),
    genre: 'Fiction'
  });
  const savedBook = await newBook.save();
  console.log('保存文档成功:', savedBook);

  // 查询文档 (Read)
  const query = { title: 'The Great Gatsby' };
  const foundBooks = await BookManagementModel.find(query);
  console.log('查询到的文档:', foundBooks);

  // 更新文档 (Update)
  const updateQuery = { title: 'The Great Gatsby' };
  const updateData = { $set: { genre: 'Classic' } };
  const updateResult = await BookManagementModel.updateOne(updateQuery, updateData);
  console.log('更新文档成功:', updateResult);

  // 查询更新后的文档
  const updatedBooks = await BookManagementModel.find(updateQuery);
  console.log('更新后的文档:', updatedBooks);

  // 删除文档 (Delete)
  const deleteQuery = { title: 'The Great Gatsby' };
  const deleteResult = await BookManagementModel.deleteOne(deleteQuery);
  console.log('删除文档成功:', deleteResult);

  // 关闭连接
  mongoose.connection.close();
}

参考文献

MongoDB 官方详细文档：https://www.mongodb.com/docs/manual/

MongoDB CRUD 速览：https://www.mongodb.com/docs/mongodb-shell/crud/

Mongoose 官方文档 Model 部分：https://mongoosejs.com/docs/models.html