MongoDB上手教程：环境安装、图形化应用、增删改查、mongoose_以下是一个使用mongodb进行添加、查询、修改和删除操作的练习: 启动图形化软件并

参考：

尚硅谷教程：这里
mongodb官方文档：这里
参考博客1：这里
参考博客2：这里

一、简介及准备工作

1.数据库的分类

按照是否是关系型，可分为：

关系型数据库(MySQL、Orcal等)
非关系型数据库(MongoDB等)
1
2

二者区别：

关系型的是创建表格，非关系型是可以创建任意多个文档。

• ①数据存储方式不同

关系型和非关系型数据库的主要差异是数据存储的方式。关系型数据天然就是表格式的，因此存储在数据表的行和列中。数据表可以彼此关联协作存储，也很容易提取数据。

与其相反，非关系型数据不适合存储在数据表的行和列中，而是大块组合在一起。非关系型数据通常存储在数据集中，就像文档、键值对或者图结构。你的数据及其特性是选择数据存储和提取方式的首要影响因素。

• ②扩展方式不同

SQL和NoSQL数据库最大的差别可能是在扩展方式上，要支持日益增长的需求当然要扩展。
要支持更多并发量，SQL数据库是纵向扩展，也就是说提高处理能力，使用速度更快速的计算机，这样处理相同的数据集就更快了。

因为数据存储在关系表中，操作的性能瓶颈可能涉及很多个表，这都需要通过提高计算机性能来客服。虽然SQL数据库有很大扩展空间，但最终肯定会达到纵向扩展的上限。而NoSQL数据库是横向扩展的。

而非关系型数据存储天然就是分布式的，NoSQL数据库的扩展可以通过给资源池添加更多普通的数据库服务器(节点)来分担负载。

• ③对事务性的支持不同

如果数据操作需要高事务性或者复杂数据查询需要控制执行计划，那么传统的SQL数据库从性能和稳定性方面考虑是你的最佳选择。SQL数据库支持对事务原子性细粒度控制，并且易于回滚事务。

2.MongoDB简介

MongoDB是为快速开发互联网Web应用而设计的数据库系统。

设计目标： 极简、灵活、作为web应用栈的一部分。

数据模型： 是面向文档的，所谓的文档是一种类似于JSON的结构(增强版的JSON——BSON)。

—三个重要概念—

数据库(mongodb)： 是一个仓库，可以存放集合。

集合(collection)： 类似于数组，集合中可以存放文档。相当于关系型数据库中的表。

文档（document）： 是数据库中的最小单位，我们存储和操作的内容都是文档。

数据库里放集合，集合里放文档，我们操作的就是文档：

—注意—

在mongodb中，数据库和集合都不需要手动创建。我们在创建文档时，如果文档所在的文档或数据库不存在，则会自动创建数据库和集合（在第一次插入文档时创建）。

3.下载安装(centos)

教程跳转：点击这里

4.shell基本操作

• 进入mongodb shell：

在任意位置打开终端，输入mongo并回车。
1

以下所有命令，均在mongodb shell中执行。

• 显示所有的数据库：

show dbs
或 show databases
1
2

• 进入某个数据库：

use 数据库名
1

• 查看当前所在数据库：

db
1

• 在数据库中查看有哪些集合：

show collections
或show tables
1
2

• 删除数据库中的集合：

db.集合名.drop()
1

二、图形化应用

mongodb manager下载地址：https://www.mongodbmanager.com/download-mongodb-manager-free

下载后双击安装包，傻瓜式操作就能安装好。

1.远程访问

远程访问服务器中的mongodb：

1 点击 server>new mongodb connection
2 输入ip和port（port可以通过查看配置文件获取）
3 点击test connection测试能否成功连接
4 点击OK连接
1
2
3
4

2.基本操作

在左侧窗口可以进行数据库/集合的增删改查的操作，在右侧窗口可以进行文档的增删改查的操作，非常方便。

3.查询

点击小黑图标，可以在右侧窗口进行查询操作，可以在script窗口中输入任何指令并执行，查询结果将显示在下方窗口中。

执行整个脚本、一行脚本、选中的脚本：

对于执行结果可以显示为shell形式(点击Output)、表格形式(点击Documents View)：

三、增删改查

在进行操作之前，请务必学习上面的mongodb简介部分的内容。

1.数据库crud基本操作

(1)创建并使用数据库

• 语法：

# 如果数据库不存在，则创建并切换到该数据库，存在则直接切换到指定数据库
use 数据库名
1
2

• 示例：

# 在script窗口中输入指令后执行，下方将返回执行结果
use test
1
2

(2)查询

• 查看所有数据库

show dbs
或show databases
1
2

• 查看当前所在数据库

db
1

(3)删除数据库

use 数据库名 #切换到数据库
db,dropDatabase() #删除当前库
1
2

2.集合crud基本操作

(1)创建集合

# step1：选择所在数据库
use test

# step2：当第一个文档插入时，集合就会被创建并包含该文档
db.student.insert({'a':1})
1
2
3
4
5

(2)查询集合

• 查询当前数据库中的所有集合

show collections
或show tables
1
2

(3)删除集合

db.集合名.drop()
1

3.文档crud基本操作

(1)插入文档

• 插入一条文档：

db.集合名.insert(文档内容)
db.集合名.insertOne(文档内容)

# 示例
db.student.insert({name:"团团",age:1,gender:"female"})
1
2
3
4
5

• 插入多条文档：

db.集合名.insertMany([
文档1,
文档2,
...
])

# 注意，每条文档必须换行写

db.student.insertMany([
{name:"坨坨",age:1,gender:"female"},
{name:"钩子",age:1,gender:"female"}
])
1
2
3
4
5
6
7
8
9
10
11
12

(2)查询文档

• 查询集合中的所有文档：

db.集合名.find()
1

• 比较运算：

#1.select * from test.student where id = 1
db.student.find({"_id":1})
1
2

#2.select * from test.student where id != 1
db.student.find({"_id":{"$ne":1}})
1
2

#3.select * from test.student where id > 1
db.student.find({"_id":{"$gt":1}})
1
2

#4.select * from test.student where age < 1
db.student.find({"age":{"$lt":1}})
1
2

#5.select * from test.student where id >= 1
db.student.find({"_id":{"$gte":1}})
1
2

#6.select * from test.student where id <= 1
db.student.find({"_id":{"$lte":1}})
1
2

• 逻辑运算：

# 1.and 直接用逗号分隔多个条件

#select * from test.student where id >=3 and id <=4;
db.student.find({"_id":{"$gte":3,"$lte":4}})
#select * from test.student where id >=3 and id <=4 and age >=40;
db.student.find({
    "_id":{"$gte":3,"$lte":4},
    "age":{"$gte":40}
})
1
2
3
4
5
6
7
8
9

# 2.and 使用"$and"

#select * from test.student where id >=3 and id <=4 and age >=40;
db.student.find({"$and":[
{"_id":{"$gte":3,"$lte":4}},
{"age":{"$gte":40}}
]})
1
2
3
4
5
6
7

# 3.or

#select * from test.student where id >=0 and id <=1 or id >=4 or name = "团团";
db.student.find({"$or":[
{"_id":{"$lte":1,"$gte":0}},
{"_id":{"$gte":4}},
{"name":"团团"}
]})
1
2
3
4
5
6
7
8

# 4.求余

#select * from test.student where id % 2 = 1;
db.student.find({"_id":{"$mod":[2,1]}})
1
2
3
4

#5.not

#select * from test.student where id % 2 != 1;
db.student.find({
    "_id":{"$not":{"$mod":[2,1]}}
})
1
2
3
4
5
6

• 成员运算：

# in
#select * from test.student where age in (20,30,31);
db.student.find({"age":{"$in":[20,30,31]}})

# not in
#select * from test.student where name not in ('alex','yuanhao');
db.student.find({"name":{"$nin":['Stefan','Damon']}})
1
2
3
4
5
6
7

• 正则：

# MongoDB: /正则表达/i

#select * from test.student where name regexp '^j.*?(g|n)$';
db.student.find({'name':/^j.*?(g|n)$/i})#匹配规则：j开头、g或n结尾，不区分大小写
1
2
3
4

• 查看指定字段：

# 0表示不显示，1表示显示
#select name,age from test.student where id=3;
db.student.find({'_id':3},{'_id':0,'name':1,'age':1})
1
2
3

• 数组查询：

#查hobbies中有dancing的人
db.user.find({
    "hobbies":"dancing"
})
#查看既有dancing爱好又有tea爱好的人
db.user.find({
    "hobbies":{"$all":["dancing","tea"]}
})
#查看第2个爱好为dancing的人
db.user.find({
    "hobbies.2":"dancing"
})
#查看所有人的第2个到第3个爱好
db.user.find(
{},
{
    "_id":0,
    "name":0,
    "age":0,
    "addr":0,
    "hobbies":{"$slice":[1,2]},
}
)

#查看所有人最后两个爱好，第一个{}表示查询条件为所有，第二个是显示条件
db.user.find(
{},
{
    "_id":0,
    "name":0,
    "age":0,
    "addr":0,
    "hobbies":{"$slice":-2},
}
)

#查询子文档有"country":"China"的人
db.user.find(
{
    "addr.country":"China"
}
)
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

• 排序：

# 1代表升序，-1代表降序
db.user.find().sort({"name":1,})
db.user.find().sort({"age":-1,'_id':1})
1
2
3

• 分页：

# limit表示取多少个document，skip代表跳过几个document
db.user.find().limit(2).skip(0)#前两个
db.user.find().limit(2).skip(2)#第三个和第四个
db.user.find().limit(2).skip(4)#第五个和第六个
1
2
3
4

• count()：

#查询年龄大于30的人数
#方式一：
db.user.count({'age':{"$gt":30}}) 

#方式二：
db.user.find({'age':{"$gt":30}}).count()
1
2
3
4
5
6

• 去重：

db.user.find().distinct()
1

• null：

# 得到的是b这个key的值为null和没有b这个key的文档
db.user.find({"b":null})
1
2

(3)更新操作

• 常规更新：

db.集合名.update(
   <query>,
   <update>,
   {
     upsert: <boolean>,
     multi: <boolean>,
     writeConcern: <document>
   }
)

# 参数说明
query : 相当于where条件。
update : update的对象和一些更新的操作符。
upsert : 可选，默认为false，代表如果不存在update的记录则不更新也不插入，设置为true代表不存在则添加。
multi : 可选，默认为false，代表只更新找到的第一条记录，设为true时,代表更新找到的全部记录。
writeConcern :可选，抛出异常的级别。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 原始文档数据
{"name" : "钩子", "age" : 1, "gender" : "female"}

# 1.覆盖式修改
db.student.update(
    {"name":"钩子"},
    {"age":16,"name":"芒果"}
)
得到的结果为{"age":16,"name":"芒果"}

# 2.局部修改:$set
db.student.update(
    {"name":"钩子"},
    {"$set":{"age":15,"name":"苹果"}}
)
得到的结果为{"name" : "苹果", "age" : 15, "gender" : "female"}

# 3.改多条：将multi参数设为true
db.student.update(
    {"name":"钩子"},
    {"age":16,"name":"芒果"},
    {"multi":true}
)

# 4.有则修改，无则添加：upsert参数设为true
db.student.update(
    {"name":"钩子"},
    {"age":16,"name":"芒果"},
    {"upsert":true}
)

# 5.删除字段：不要gender了
db.student.update(
    {"name":"钩子"},
    {"$unset":{"gender":""}}
)
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

(4)删除操作

# 1.删除符合条件的第一个文档
db.student.deleteOne({ 'gender': "female" })

# 2.删除符合条件的全部
db.student.deleteMany({"_id":{"$gte":3}})#删除id大于等于3的所有

# 3.删除所有
db.student.deleteMany({}) #清空该集合
1
2
3
4
5
6
7
8

• 加减操作：

#增加和减少$inc

#年龄都+1
db.user.update(
    {},
    {"$inc":{"age":1}},
    {"multi":true}
)

#年龄都-10
db.user.update(
    {},
    {"$inc":{"age":-10}},
    {"multi":true}
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 添加删除数组内元祖：

# $push的功能是往现有数组内添加元素

#为名字为武大郎的人添加一个爱好read
db.user.update({"name":"武大郎"},{"$push":{"hobbies":"read"}})

#为名字为武大郎的人一次添加多个爱好tea，dancing
db.user.update({"name":"武大郎"},{"$push":{
    "hobbies":{"$each":["tea","dancing"]}
}})
1
2
3
4
5
6
7
8
9

# $pop的功能是按照位置只能从头或从尾即两端删元素，类似于队列。1代表尾，-1代表头

#{"$pop":{"key":1}} 从数组末尾删除一个元素

db.user.update({"name":"武大郎"},{"$pop":{
    "hobbies":1}
})

#{"$pop":{"key":-1}} 从头部删除
db.user.update({"name":"武大郎"},{"$pop":{
    "hobbies":-1}
})
1
2
3
4
5
6
7
8
9
10
11
12

# $pull可以自定义条件删除

db.user.update({'addr.country':"China"},{"$pull":{
    "hobbies":"read"}
},
{
    "multi":true
}
)
1
2
3
4
5
6
7
8
9

(3)聚合操作

关于$match $group $avg $project $concat参考博客：这里

四、mongoose

mongose就是一个Node.js的库，用来操作mongodb。

• 三个对象：

Schema(模式对象)：定义了约束mongodb的文档结构的条件。
Model：相当于mongodb中的 collection(集合)。
Document：表示集合中的具体文档。
1
2
3

• nodejs安装mongoose模块：

npm i mongoose --save
1

1.基本用法

// 1、引入 mongoose 模块
const mongoose = require('mongoose');

// 2、连接数据库    27017是默认端口号，可以省略不写， ppxia是需要连接的数据库
mongoose.connect('mongodb://127.0.0.1:27017/ppxia');

// 2.1、这是对数据库的监听，而且是使用once, 只监听一次就行了
mongoose.connection.once('open', (err)=>{
    if(!err){
        console.log("数据库已连接...");
    }
});

mongoose.connection.once('close', (err)=>{
    if(!err){
        console.log("数据库已断开!!!");
    }
});

// 3、重命名，简化操作
const Schema = mongoose.Schema;

// 3.1、创建了约束条件:type是类型，default是默认是女，如果是女的话则不用写性别这个属性值了。
const stuSch = new Schema({
    name:String,
    age: Number,
    gender: {
        type: String,
        default:"女"
    },
    address:String
});

// 4、创建了 模型， 数据库中的集合名是 stuSch(会自动加s), 第二个参数是标准，即是约束条件: stuSch
const stuModel = mongoose.model('stuSch', stuSch);

// 5、使用模型创建对象, 当想创建多个的时候，可以使用数组里面存储对象的方式
stuModel.create({
    name: "西施",
    age: 18,
    address: "王者峡谷"
}, (err)=>{
    console.log('文档创建成功~');
});
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

2.文档的增删改查

• 增：

Model.create(doc,[callback]);			创建一个或多个对象
Model.createOne(doc, [callback]);		创建一个对象
Model.createMany(doc, [callback]);		创建多个对象
	-doc是需要插入的文档
	-callback(err) 是回调函数，可以用来提示是否创建成功了
1
2
3
4
5

• 删：

Model.remove(condition, [callback]);
Model.deleteOne(condition, [callback]);
Model.deleteMany(condition, [callback]);
	-- condition 条件
1
2
3
4

• 改：

Model.updateMany(condition, doc, [options], [callback]);
Model.updateOne(condition, doc, [options], callback);
	** Model.update() 已经不适用了
-- condition 修改的条件
-- doc 修改后的内容/需要修改的内容

需要配合修改操作符来使用:
	$set		表示需要设置指定的属性
	$unset		表示需要删除指定的属性
	$push		表示给数组添加一个新元素，因为文档内也会有数组，数组便会有数组元素
	$addToset 	表示给数组添加一个新元素，和push的区别是，如果出现同名的数组元素，则不会再添加
	$gt			大于
	$gte		大于等于
	$lt			小于
	$lte		小于等于
	$or [{条件一,条件二}]		表示或的意思，符合条件一或者条件二	
	$inc		表示自增，用在在原来数据的基础上对数据加减，可用于加薪减薪的操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 查：

Model.find(condition, 投影, [options], [callback]);	 	查询一个或多个文档
	-- 返回的是数组
Model.findById(id, 投影, [callback]);  			根据id查询一个文档
Model.findMany(condition, 投影. [callback]); 	查询多个文档
Model.findOne(condition, [projection], [options], [callback]);	查询一个文档
	-- condition 			查询条件
	-- 投影/ projection: 	投影，也就是 查询条件，有两种方式
			{name: 1, _id:0}: 1是显示，0是不显示	"name  -_id"显示name, 不显示 _id
    -- options:  	查询的选项, skip是跳过，limit是限制 {skip: 3, limit:3}
    -- callback: 	回调函数,有两个参数(err, doc) err是错误类型, doc是文档。
1
2
3
4
5
6
7
8
9
10

• Document的方法：

Document事实上是Model的实例，对应mongodb中的文档。

document.get(name)
        获取指定属性值
        doc.get("name") === doc.name
document.set("name", "猪猪") === doc.name = "猪猪"
documentc.id  
        属性, 获取id
document.toJSON()
        - 转换成 JSON
document.toObject()
        将doc对象 转换成 普通JS对象, 转换后, 所有doc的属性和方法都不能使用了
1
2
3
4
5
6
7
8
9
10