1 MongoDB中的基本概念及原理

1.1 MongoDB介绍

官网地址：https://www.mongodb.com/
MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。 在高负载的情况下，添加更多的节点，可以保证服务器性能。 MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。 MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。

1.2 MongoDB概念解析

不管我们学习什么数据库都应该学习其中的基础概念，在mongodb中基本的概念是文档、集合、数据库，下面我们挨个介绍。
下表将帮助您更容易理解Mongo中的一些概念：

通过下图实例，我们也可以更直观的了解Mongo中的一些概念：

001.png

1.2.1 数据库

一个mongodb中可以建立多个数据库。MongoDB的默认数据库为"test"，该数据库存储在data目录中（安装时，可以默认可以指定，但是该目录必须是存在的）。MongoDB的单个实例可以容纳多个独立的数据库，每一个都有自己的集合和权限，不同的数据库放置在不同的文件中。
执行 "show dbs" 命令可以显示所有数据库的列表。

> show dbs 
local 0.078GB 
test 0.078GB 
>

执行 "db" 命令可以显示当前数据库对象或集合。

> db 
test 
>

执行 "use"命令，可以连接到一个指定的数据库。

> use local 
switched to db local 
> db 
local 
>

数据库命名规范
数据库也通过名字来标识。数据库名可以是满足以下条件的任意UTF-8字符串。
不能是空字符串
不得含有' '（空格)、.、$、/、\和\0 (空字符)
应全部小写
最多64字节

有一些数据库名是保留的，可以直接访问这些有特殊作用的数据库。
admin： 从权限的角度来看，这是"root"数据库。要是将一个用户添加到这个数据库，这个用户自动继承所有数据库的权限。一些特定的服务器端命令也只能从这个数据库运行，比如列出所有的数据库或者关闭服务器。
local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合
config: 当Mongo用于分片设置时，config数据库在内部使用，用于保存分片的相关信息。

1.2.2 集合

集合就是 MongoDB 文档组，类似于 RDBMS中的表。
集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据，但通常情况下我们插入集合的数据都会有一定的关联性。比如，我们可以将以下不同数据结构的文档插入到集合中：

{"site":"www.baidu.com"} 
{"site":"www.google.com","name":"Google"} 

当第一个文档插入时，集合就会被创建。

一个collection（集合）中的所有field（域）是collection（集合）中所有document（文档）中包含 的field（域）的并集。

集合命名规范
集合名不能是空字符串""。
集合名不能含有\0字符（空字符)，这个字符表示集合名的结尾。
集合名不能以"system."开头，这是为系统集合保留的前缀。
用户创建的集合名字不能含有保留字符。有些驱动程序的确支持在集合名里面包含，这是因为某些系统生成的集合中包含该字符。除非你要访问这种系统创建的集合，否则千万不要在名字里出现。
如下实例：

db.col.findOne()

capped collections
Capped collections 就是固定大小的collection。它有很高的性能以及队列过期的特性(过期按照插入的顺序)。有点和 "RRD" 概念类似。Capped collections 是高性能自动的维护对象的插入顺序。它非常适合类似记录日志的功能。和标准的collection 不同，你必须要显式的创建一个capped collection，指定一个 collection 的大小，单位是字节。collection 的数据存储空间值提前分配的。
Capped collections 可以按照文档的插入顺序保存到集合中，而且这些文档在磁盘上存放位置也是按照插入顺序来保存的，所以当我们更新Capped collections 中文档的时候，更新后的文档不可以超过之前文档的大小，这样话就可以确保所有文档在磁盘上的位置一直保持不变。
由于 Capped collection 是按照文档的插入顺序而不是使用索引确定插入位置，这样的话可以提高增添数据的效率。MongoDB 的操作日志文件 oplog.rs 就是利用 Capped Collection 来实现的。
要注意的是指定的存储大小包含了数据库的头信息

db.createCollection("mycoll", {capped:true, size:100000})

在 capped collection 中，你能添加新的对象。
能进行更新，然而，对象不会增加存储空间。如果增加，更新就会失败 。
使用 Capped Collection 不能删除一个文档，可以使用 drop() 方法删除 collection 所有的行。
删除之后，你必须显式的重新创建这个 collection。
在32bit机器中，capped collection 最大存储为 1e9( 1X10的9次方)个字节。

1.2.3 文档

文档是一组键值(key-value)对(即 BSON)。MongoDB 的文档不需要设置相同的字段，并且相同的字段不需要相同的数据类型，这与关系型数据库有很大的区别，也是 MongoDB 非常突出的特点。
一个简单的文档例子如下：

{"site":"www.baidu.com", "name":"百度"}

下表列出了 RDBMS 与 MongoDB 对应的术语：

需要注意的是：
文档中的键/值对是有序的。
文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。
MongoDB区分类型和大小写。
MongoDB的文档不能有重复的键。
文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。
文档键命名规范：
键不能含有\0 (空字符)。这个字符用来表示键的结尾。
.和$有特别的意义，只有在特定环境下才能使用。
以下划线"_"开头的键是保留的(不是严格要求的)。

1.2.4 元数据

数据库的信息是存储在集合中。它们使用了系统的命名空间：

dbname.system.*

在MongoDB数据库中名字空间 .system.* 是包含多种系统信息的特殊集合(Collection)，如下:

对于修改系统集合中的对象有如下限制：
在{{system.indexes}}插入数据，可以创建索引。但除此之外该表信息是不可变的(特殊的drop index命令将自动更新相关信息)。
{{system.users}}是可修改的。
{{system.profile}}是可删除的。

1.3 MongoDB 数据类型

下表为MongoDB中常用的几种数据类型:

下面说明下几种重要的数据类型。

1.3.1 ObjectId

ObjectId 类似唯一主键，可以很快的去生成和排序，包含 12 bytes，含义是：
前 4 个字节表示创建 unix 时间戳，格林尼治时间 UTC 时间，比北京时间晚了 8 个小时
接下来的 3 个字节是机器标识码
紧接的两个字节由进程 id 组成 PID
最后三个字节是随机数

002.png

MongoDB 中存储的文档必须有一个 _id 键。这个键的值可以是任何类型的，默认是个 ObjectId 对象。由于 ObjectId 中保存了创建的时间戳，所以你不需要为你的文档保存时间戳字段，你可以通过getTimestamp 函数来获取文档的创建时间:

> var newObject = ObjectId() 
> newObject.getTimestamp() 
ISODate("2017-11-25T07:21:10Z")

ObjectId 转为字符串

> newObject.str 
5a1919e63df83ce79df8b38f

1.3.2 字符串

BSON 字符串都是 UTF-8 编码。

1.3.3 时间戳

BSON有一个特殊的时间戳类型用于MongoDB内部使用，与普通的日期类型不相关。时间戳值是一个 64 位的值。其中：前32位是一个 time_t 值（与Unix新纪元相差的秒数），后32位是在某秒中操作的一个递增的序数。
在单个 mongod 实例中，时间戳值通常是唯一的
在复制集中， oplog 有一个 ts 字段。这个字段中的值使用BSON时间戳表示了操作时间。
BSON 时间戳类型主要用于 MongoDB 内部使用。在大多数情况下的应用开发中，你可以使用BSON 日期类型。

1.3.4 日期

表示当前距离 Unix新纪元（1970年1月1日）的毫秒数。日期类型是有符号的, 负数表示 1970 年之前的日期。

> var mydate1 = new Date() //格林尼治时间 
> mydate1 ISODate("2018-03-04T14:58:51.233Z") 
> typeof mydate1 
object 
> var mydate2 = ISODate() //格林尼治时间 
> mydate2 ISODate("2018-03-04T15:00:45.479Z") 
> typeof mydate2 
object

这样创建的时间是日期类型，可以使用 JS 中的 Date 类型的方法。
返回一个时间类型的字符串：

> var mydate1str = mydate1.toString() 
> mydate1str 
Sun Mar 04 2018 14:58:51 GMT+0000 (UTC) 
> typeof mydate1str 
string

或者

> Date() 
Sun Mar 04 2018 1

2 MongoDB安装和常用命令

2.1 安装

下载地址：https://www.mongodb.com/download-center#community

下载安装包并解压 ：

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.6.11.tgz 
tar -zxvf mongodb-linux-x86_64-rhel70-3.6.11.tgz
mv mongodb-linux-x86_64-rhel70-3.6.11 mongodb 
#一定注意要创建数据存储目录，默认路径/data/db 
mkdir -p /data/db

配置环境变量：

vim /etc/profile
export PATH=$JAVA_HOME/bin:/root/mongodb/bin:$PATH
source /etc/profile

2.2 启动

通过配置文件方式启动

mongod --config 配置文件路径
mongod -f 配置文件路径

说明：-f是--config的缩写。配置文件，需要手动创建，参考以下配置即可。
创建mongodb.cfg配置文件

#数据库文件位置
dbpath=/root/mongodb/singleton/data 
#日志文件位置
logpath=/root/mongodb/singleton/logs/mongodb.log 
#以追加方式写入日志
logappend=true
#是否以守护进程方式运行
fork=true
#绑定客户端访问的ip 0.0.0.0 不绑定ip 
bind_ip=192.168.10.135
#默认端口号27017
port=27017

创建数据存储目录和日志文件目录：

mkdir /root/mongodb/singleton/data -p 
mkdir /root/mongodb/singleton/logs -p

通过配置文件方式启动：

mongod -f /root/mongodb/sinleton/mongodb.cfg

2.3 连接客户端

mongo 192.168.10.135:27017

常用客户端
自带命令行客户端
Navicat for mongodb
MongoVUE
Studio 3T
Robo 3T
RockMongo

2.4 常用命令

2.4.1 创建数据库

MongoDB 创建数据库的语法格式如下：

use DATABASE_NAME

如果数据库不存在，则创建数据库，否则切换到指定数据库。以下实例我们创建了数据库 zhoutian:

> use zhoutian 
switched to db zhoutian
> db 
zhoutian 
>

如果你想查看所有数据库，可以使用 show dbs 命令：

> show dbs 
admin 0.000GB 
local 0.000GB 
>

可以看到，我们刚创建的数据库zhoutian并不在数据库的列表中，要显示它，我们需要向zhoutian数据库插入一些数据。

> db.mycollection.insert({"name":"周天"}) 
WriteResult({ "nInserted" : 1 }) 
> show dbs 
local 0.078GB 
zhoutian 0.078GB 
test 0.078GB 
>

2.4.2 删除数据库

MongoDB 删除数据库的语法格式如下：

db.dropDatabase()

删除当前数据库，默认为 test，你可以使用 db 命令查看当前数据库名。以下实例我们删除了数据库 zhoutian。
首先，查看所有数据库：

> show dbs 
local 0.078GB 
zhoutian 0.078GB 
test 0.078GB

接下来我们切换到数据库 zhoutian：

> use zhoutian
switched to db zhoutian
>

执行删除命令：

> db.dropDatabase() 
{ "dropped" : "zhoutian", "ok" : 1 } 

最后，我们再通过show dbs命令数据库是否删除成功：

show dbs 
local 0.078GB 
test 0.078GB 
>

2.4.3 创建集合

MongoDB中使用 createCollection()方法来创建集合。
语法格式：

db.createCollection(name, options)

参数说明：
name: 要创建的集合名称
options: 可选参数， 指定有关内存大小及索引的选项。options 可以是如下参数：

在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。
在 test 数据库中创建 mycollection集合：

> use test 
switched to db test 
> db.createCollection("mycollection") 
{ "ok" : 1 } 
>

如果要查看已有集合，可以使用 show collections或show tables 命令：

> show collections 
mycollection 
system.indexes

下面是带有几个关键参数的 createCollection() 的用法：
创建固定集合 mycol，整个集合空间大小 6142800 KB, 文档最大个数为 10000 个。

> db.createCollection("mycol", { capped : true, autoIndexId : true, size : 6142800, max : 10000 } )
{ "ok" : 1 }
>

在 MongoDB 中，你不需要创建集合。当你插入一些文档时，MongoDB 会自动创建集合。

> db.mycol2.insert({"name" : "嗨"})
> show collections
mycol2
...

2.4.4 删除集合

集合删除语法格式如下：

db.collection_name.drop()

以下实例删除了zhoutian数据库中的集合 site：

> use zhoutian 
switched to db zhoutian 
> show tables 
site 
> db.site.drop() 
true 
> show tables 
>

2.4.5 插入文档

MongoDB 使用 insert() 或 save() 方法向集合中插入文档，语法如下：

db.COLLECTION_NAME.insert(document)
或
db.COLLECTION_NAME.save(document)

save()：如果 _id 主键存在则更新数据，如果不存在就插入数据。该方法新版本中已废弃，可以使用 db.collection.insertOne() 或 db.collection.replaceOne() 来代替。
insert(): 若插入的数据主键已经存在，则会抛 org.springframework.dao.DuplicateKeyException 异常，提示主键重复，不保存当前数据。
3.2 版本之后新增了 db.collection.insertOne() 和 db.collection.insertMany()。
以下文档可以存储在 MongoDB 的zhoutian数据库 的 mycollection 集合中：

>db.mycollection.insert({title: 'MongoDB 教程', 
description: 'MongoDB 是一个 Nosql 数据库', 
by: '周天', 
url: 'http://www.zhoutian.com', 
tags: ['mongodb', 'database', 'NoSQL'], 
likes: 100 
})

>var document = {title: 'MongoDB 教程', 
description: 'MongoDB 是一个 Nosql 数据库', 
by: '周天', 
url: 'http://www.zhoutian.com', 
tags: ['mongodb', 'database', 'NoSQL'], 
likes: 100 
}
>db.mycollection.insert(document)

2.4.6 更新文档

MongoDB 使用 update() 和 save() 方法来更新集合中的文档。
update() 方法用于更新已存在的文档。语法格式如下：

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

参数说明：
query : update的查询条件，类似sql update查询内where后面的。
update : update的对象和一些更新的操作符（如inc...）等，也可以理解为sql update查询内set后面的
upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
writeConcern :可选，抛出异常的级别。

我们在集合 mycollection中插入如下数据：

>db.mycollection.insert({
    title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '周天',
    url: 'http://www.zhoutian.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})

接着我们通过 update() 方法来更新标题(title):

>db.mycollection.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })   # 输出信息
> db.col.find().pretty()
{
        "_id" : ObjectId("56064f89ade2f21f36b03136"),
        "title" : "MongoDB",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "周天",
        "url" : "http://www.zhoutian.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}
>

可以看到标题(title)由原来的 "MongoDB 教程" 更新为了 "MongoDB"。
以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true。

>db.mycollection.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}},{multi:true})

save() 方法通过传入的文档来替换已有文档，_id 主键存在就更新，不存在就插入。语法格式如下：

db.COLLECTION_NAME.save(
   <document>,
   {
     writeConcern: <document>
   }
)

参数说明：
document : 文档数据。
writeConcern :可选，抛出异常的级别。

以下实例中我们替换了 _id 为 56064f89ade2f21f36b03136 的文档数据：

>db.mycollection.save({
    "_id" : ObjectId("56064f89ade2f21f36b03136"),
    "title" : "MongoDB",
    "description" : "MongoDB 是一个 Nosql 数据库",
    "by" : "zhoutian",
    "url" : "http://www.zhoutian.com",
    "tags" : [
            "mongodb",
            "NoSQL"
    ],
    "likes" : 110
})

替换成功后，我们可以通过 find() 命令来查看替换后的数据

>db.mycollection.find().pretty()
{
        "_id" : ObjectId("56064f89ade2f21f36b03136"),
        "title" : "MongoDB",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "zhoutian",
        "url" : "http://www.zhoutian.com",
        "tags" : [
                "mongodb",
                "NoSQL"
        ],
        "likes" : 110
}
> 

2.4.7 删除文档

MongoDB 使用remove()方法是用来移除集合中的数据。在执行remove()方法前先执行find()方法来判断执行的条件是否正确，这是一个比较好的习惯。
remove() 方法的基本语法格式如下所示：

db.COLLECTION_NAME.remove( <query>, <justOne> )

如果你的 MongoDB 是 2.6 版本以后的，语法格式如下：

db.COLLECTION_NAME.remove( <query>, { justOne: <boolean>, writeConcern: <document> } )

参数说明：
query :（可选）删除的文档的条件。
justOne : （可选）如果设为 true 或 1，则只删除一个文档，如果不设置该参数，或使用默认值false，则删除所有匹配条件的文档。
writeConcern :（可选）抛出异常的级别。

以下文档我们执行两次插入操作：

>db.mycollection.insert({
    title: 'MongoDB 教程',
    description: 'MongoDB 是一个 Nosql 数据库', 
    by: '周天', 
    url: 'http://www.zhoutian.com', 
    tags: ['mongodb', 'database', 'NoSQL'], 
    likes: 100 
})

使用 find() 函数查询数据：

> db.mycollection.find() 
{ "_id" : ObjectId("56066169ade2f21f36b03137"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 } 

{ "_id" : ObjectId("5606616dade2f21f36b03138"), "title" : "MongoDB 教程","description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }

接下来我们移除 title 为 'MongoDB 教程' 的文档：

>db.mycollection.remove({'title':'MongoDB 教程'}) 
WriteResult({ "nRemoved" : 2 }) # 删除了两条数据 
>db.mycollection.find() 
…… # 没有数据

如果你只想删除第一条找到的记录可以设置 justOne 为 1，如下所示：

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

如果你想删除所有数据，可以使用以下方式：

>db.COLLECTION_NAME.remove({}) 
>db.COLLECTION_NAME.find() 
>

2.4.8 查询文档

MongoDB 查询文档使用 find() 方法。find() 方法以非结构化的方式来显示所有文档。MongoDB 查询数据的语法格式如下：

db.COLLECTION_NAME.find(query, projection)

query ：可选，使用查询操作符指定查询条件
projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值，只需省略该参数即可（默认省略）。
如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：

>db.COLLECTION_NAME.find().pretty()

以下实例我们查询了集合 mycollection 中的数据：

> db.mycollection.find().pretty() 
{ 
    "_id" : ObjectId("56063f17ade2f21f36b03133"), 
    "title" : "MongoDB 教程", 
    "description" : "MongoDB 是一个 Nosql 数据库", 
    "by" : "周天", 
    "url" : "http://www.zhoutian.com", 
    "tags" : ["mongodb", "database", "NoSQL" ],
    "likes" : 100 
}

通过下表可以更好的理解 MongoDB 的条件语句查询：

MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。
语法格式如下：

>db.COLLECTION_NAME.find({key1:value1, key2:value2}).pretty()

> db.mycollection.find({"by":"周天", "title":"MongoDB 教程"}).pretty()

MongoDB OR 条件语句使用了关键字 $or，语法格式如下：

>db.COLLECTION_NAME.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()

>db.mycollection.find({$or:[{"by":"周天"},{"title": "MongoDB 教程"}]}).pretty()

以下实例演示了 AND 和 OR 联合使用，类似常规 SQL 语句为： 'where likes>50 AND (by = '周天' OR title = 'MongoDB 教程')'

>db.mycollection.find({"likes": {$gt:50}, $or: [{"by": "周天"},{"title": "MongoDB 教程"}]}).pretty()

如果你需要在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。limit()方法基本语法如下所示：

>db.COLLECTION_NAME.find().limit(NUMBER)

集合 mycollection 中的数据如下：

{ "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "php" ], "likes" : 200 } 
{ "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb" ], "likes" : 100 }

以下实例为显示查询文档中的两条记录：

> db.mycollection .find({},{"title":1,_id:0}).limit(2) 
{ "title" : "PHP 教程" } 
{ "title" : "Java 教程" } 
>

注：如果你们没有指定limit()方法中的参数则显示集合中的所有数据。
我们除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。skip() 方法脚本语法格式如下：

>db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)

以下实例只会显示第二条文档数据

>db.mycollection.find({},{"title":1,_id:0}).limit(1).skip(1) 
{ "title" : "Java 教程" } 
>

注:skip()方法默认参数为 0 。

在 MongoDB 中使用 sort() 方法对数据（文档）进行排序，sort() 方法可以通过参数指定排序的字段，并使用1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。sort()方法基本语法如下所示：

>db.COLLECTION_NAME.find().sort({KEY:1})

mycollection集合中的数据如下：

{ "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "php" ], "likes" : 200 } 
{ "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "java" ], "likes" : 150 } 
{ "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "周天", "url" : "http://www.zhoutian.com", "tags" : [ "mongodb" ], "likes" : 100 }

以下实例演示了 mycollection 集合中的数据按字段 likes 的降序排列：

>db.mycollection.find({},{"title":1,_id:0}).sort({"likes":-1}) 
{ "title" : "PHP 教程" } 
{ "title" : "Java 教程" } 
{ "title" : "MongoDB 教程" } 
>

$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。
如果想获取 "col" 集合中 title 为 String 的数据，你可以使用以下命令：

db.col.find({"title" : {$type : 2}})
或
db.col.find({"title" : {$type : 'string'}})

2.4.9 聚合查询

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。 MongoDB中聚合的方法使用aggregate()。
基本语法为：

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

为了便于理解，先将常见的mongo的聚合表达式和mysql的查询做下类比：

下面以一个案例来演示，集合中的数据如下

> db.mycollection.find() 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ"}

$group
按照城市分组对年龄进行求和

> db.mycollection.aggregate([{$group : {_id : "$city", snum : {$sum : "$age"}}}]) 
{ "_id" : "TJ", "snum" : 34 } 
{ "_id" : "BJ", "snum" : 21 }

$sum
按照城市分组对年龄进行求和

> db.mycollection.aggregate([{$group : {_id : "$city", snum : {$sum : "$age"}}}]) 
{ "_id" : "TJ", "snum" : 34 } 
{ "_id" : "BJ", "snum" : 21 }

按照城市分组求总个数

> db.mycollection.aggregate([{$group : {_id : "$city", sc : {$sum : 1}}}]) 
{ "_id" : "TJ", "sc" : 4 } 
{ "_id" : "BJ", "sc" : 6 }

$avg
按照城市分组对年龄进行求平均

> db.mycollection.aggregate([{$group : {_id : "$city", avg : {$avg : "$age"}}}]) 
{ "_id" : "TJ", "avg" : 8.5 } 
{ "_id" : "BJ", "avg" : 3.5 }

$min
按照城市分组获得每组最小年龄

> db.mycollection.aggregate([{$group : {_id : "$city", min : {$min : "$age"}}}]) 
{ "_id" : "TJ", "min" : 7 } 
{ "_id" : "BJ", "min" : 1 }

$max
按照城市分组获得每组最大年龄

> db.mycollection.aggregate([{$group : {_id : "$city", max : {$max : "$age"}}}]) 
{ "_id" : "TJ", "max" : 10 } 
{ "_id" : "BJ", "max" : 6 }

$match
取年龄大于3并且小于10的记录再按照城市分组求个数和

> db.mycollection.aggregate( [{ $match : { age : { $gt : 3, $lte : 10 } } },{ $group: { _id: "$city",count: { $sum: 1 } } }] ); 
{ "_id" : "TJ", "count" : 4 } 
{ "_id" : "BJ", "count" : 3 }

$sort
按照年龄的倒序显示

> db.mycollection.aggregate( [{ $sort:{ age :-1}}] ) 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ"}
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" }

$limit
取得前5条数据

> db.mycollection.aggregate( { $limit:5} ) 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ" }
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ" } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ" }

$project
不显示_id字段，显示 name和city字段

> db.mycollection.aggregate( [ {$project :{_id:0,name:1,city:1} } ] ) 
{ "name" : "zhaoyun1", "city" : "BJ" } 
{ "name" : "zhaoyun2", "city" : "BJ" } 
{ "name" : "zhaoyun3", "city" : "BJ" } 
{ "name" : "zhaoyun4", "city" : "BJ" } 
{ "name" : "zhaoyun5", "city" : "BJ" } 
{ "name" : "zhaoyun6", "city" : "BJ" } 
{ "name" : "zhaoyun7", "city" : "TJ" } 
{ "name" : "zhaoyun8", "city" : "TJ" } 
{ "name" : "zhaoyun9", "city" : "TJ" } 
{ "name" : "zhaoyun10", "city" : "TJ" }

$lookup
用于多文档关联，类似于SQL的多表关联
建立新的集合

> db.sex.find() 
{ "_id" : 1, "name" : "male" } 
{ "_id" : 2, "name" : "female" }

给mycollection新增字段sex

> db.mycollection.update({},{$set:{sex:1}},{multi:1}) 
WriteResult({ "nMatched" : 10, "nUpserted" : 0, "nModified" : 10 }) 
> db.mycollection.find() 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854cf"), "name" : "zhaoyun1", "age" : 1, "city" : "BJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d0"), "name" : "zhaoyun2", "age" : 2, "city" : "BJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d1"), "name" : "zhaoyun3", "age" : 3, "city" : "BJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d2"), "name" : "zhaoyun4", "age" : 4, "city" : "BJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d3"), "name" : "zhaoyun5", "age" : 5, "city" : "BJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d4"), "name" : "zhaoyun6", "age" : 6, "city" : "BJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d5"), "name" : "zhaoyun7", "age" : 7, "city" : "TJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d6"), "name" : "zhaoyun8", "age" : 8, "city" : "TJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d7"), "name" : "zhaoyun9", "age" : 9, "city" : "TJ", "sex" : 1 } 
{ "_id" : ObjectId("5cceaf55e7a4cf28dc5854d8"), "name" : "zhaoyun10", "age" : 10, "city" : "TJ", "sex" : 1 }

将两个文档关联

> db.mycollection.aggregate([{$lookup: {from:"sex",localField:"sex",foreignField:"_id",as:"docs"}},{$project: {"_id":0}}])
{ "name" : "zhaoyun1", "age" : 1, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun2", "age" : 2, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] }
{ "name" : "zhaoyun3", "age" : 3, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun4", "age" : 4, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun5", "age" : 5, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun6", "age" : 6, "city" : "BJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun7", "age" : 7, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun8", "age" : 8, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun9", "age" : 9, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] } 
{ "name" : "zhaoyun10", "age" : 10, "city" : "TJ", "sex" : 1, "docs" : [ { "_id" : 1, "name" : "male" } ] }

mycollection中的数据字段sex关联sex中的数据字段_id，在mycollection中显示sex对应的中文，显示在docs中，不显示mycollection中的__id
$lookup中的参数：
from：需要关联的表【sex】
localField: 【mycollection】表需要关联的键。
foreignField：【sex】的matching key 主键
as：对应的外键集合的数据，【因为是一对多的】

3 MongoDB Java客户端

3.1 mongodb-java-API

<dependency>
    <groupId>org.mongodb</groupId> 
    <artifactId>mongo-java-driver</artifactId> 
    <version>3.10.1</version> 
</dependency>

public class MongodbDemo { 
   
    private MongoClient client; 
    
    @Before public void init() { 
        client = new MongoClient("192.168.10.135",27017); 
    }
    
    @Test public void connectDB() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        System.out.println("connect successful----"+database.getName()); 
    }
    
    @Test public void createCollection() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        database.createCollection("mycollection"); 
        System.out.println("集合创建成功"); 
    }
    
    @Test public void getCollection() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        MongoCollection<Document> collection = database.getCollection("mycollection");
        System.out.println("获取集合成功："+collection.getNamespace());
        MongoIterable<String> collectionNames = database.listCollectionNames(); 
        for (String string : collectionNames) { 
            System.out.println("collection name : "+ string); 
        } 
    }
    
    @Test public void insertDocument() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        MongoCollection<Document> collection = database.getCollection("mycollection");
        Document document = new Document("name", "James"); 
        document.append("age", 34); 
        document.append("sex", "男"); 
        Document document2 = new Document("name", "wade"); 
        document2.append("age", 36); 
        document2.append("sex", "男"); 
        Document document3 = new Document("name", "cp3"); 
        document3.append("age", 32); 
        document3.append("sex", "男"); 
        List<Document> documents = new ArrayList<>(); 
        documents.add(document); 
        documents.add(document2); 
        documents.add(document3); 
        collection.insertMany(documents);
        System.out.println("文档插入成功"); 
    }
    
    @Test public void findDocuments() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        MongoCollection<Document> collection = database.getCollection("mycollection");
        FindIterable<Document> iterable = collection.find(); 
        for (Document document : iterable) { 
            System.out.println(document.toJson()); 
        } 
        // MongoCursor<Document> mongoCursor = iterable.iterator(); 
        // while (mongoCursor.hasNext()) { 
        // Document document = mongoCursor.next(); 
        // System.out.println(document.toJson()); 
        // } 
    }
    
    @Test public void updateDocuments() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        MongoCollection<Document> collection = database.getCollection("mycollection");
        collection.updateMany(
            Filters.eq("age",18), new Document("$set", new Document("age", 20))
        ); 
        FindIterable<Document> iterable = collection.find(); 
        for (Document document : iterable) { 
            System.out.println(document.toJson()); 
        } 
    }
    
    @Test public void deleteDocuments() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        // 删除符合条件的第一个文档 
        collection.deleteOne(Filters.eq("age",20));
        collection.deleteOne(Filters.eq("name","James")); 
        // 删除符合条件的所有文档 
        collection.deleteMany(Filters.eq("age",20)); 
        FindIterable<Document> iterable = collection.find(); 
        for (Document document : iterable) { 
            System.out.println(document.toJson()); 
        } 
    }
    
    @Test
    public void testQuery1() { 
        MongoDatabase database = client.getDatabase("zhoutian"); 
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //获取第一条记录 
        Document first = collection.find().first(); 
        //根据key值获得数据 
        System.out.println(first.get("name")); 
        //查询指定字段 
        Document qdoc=new Document(); 
        qdoc.append("_id", 0);//0是不包含字段 
        qdoc.append("name", 1);//1是包含字段
        FindIterable<Document> findIterable = collection.find().projection(qdoc); 
        for (Document document : findIterable) { 
            System.out.println(document.toJson()); 
        } 
    }
    
    @Test public void testQuery2() { 
        MongoDatabase database = client.getDatabase("zhoutian");
        MongoCollection<Document> collection = database.getCollection("mycollection"); 
        //按指定字段排序 
        Document sdoc=new Document(); 
        //按年龄的倒序 
        sdoc.append("age", -1); 
        FindIterable<Document> findIterable = collection.find().sort(sdoc); 
        for (Document document : findIterable) { 
            System.out.println(document.toJson()); 
        } 
    } 
}

Filters
利用Filters可以进行条件过滤，比如：eq、ne、gt、lt、gte、lte、in、nin、and、or、not、nor、exists、type、mod、regex、text、where、all、elemMatch、size、bitsAllClear、bitsAllSet、bitsAnyClear、bitsAnySet、geoWithin、geoWithin、geoWithinBox、geoWithinPolygon、geoWithinCenter、geoWithinCenterSphere、geoIntersects、near、nearSphere 等。
需要引入com.mongodb.client.model.Filters类

介绍几个常用的过滤操作。

@Test public void testFilters1() { 
    MongoDatabase database = client.getDatabase("zhoutian");
    MongoCollection<Document> collection = database.getCollection("mycollection"); 
    //获得name等于zhaoyun1的记录 
    FindIterable<Document> findIterable =collection.find(Filters.eq("name", "zhaoyun1"));
    for (Document document : findIterable) { 
        System.out.println(document.toJson()); 
    }  
}

@Test public void testFilters2() { 
    MongoDatabase database = client.getDatabase("zhoutian");
    MongoCollection<Document> collection = database.getCollection("mycollection"); 
    //获得age大于3的记录 
    FindIterable<Document> findIterable =collection.find(Filters.gt("age", 3)); 
    for (Document document : findIterable) { 
        System.out.println(document.toJson()); 
    } 
}

@Testpublic void testFilters3() {
    MongoDatabase database = client.getDatabase("zhoutian");
    MongoCollection<Document> collection = database.getCollection("mycollection"); 
    //获得age大于3的记录 或者 name=zhaoyun1 
    FindIterable<Document> findIterable = 
        collection.find(Filters.or(Filters.eq("name", "zhaoyun1"),Filters.gt("age", 3))); 
    for (Document document : findIterable) { 
        System.out.println(document.toJson());
    } 
}

BasicDBObject
利用BasicDBObject可以实现模糊查询和分页查询

@Test public void testLike() { 
    MongoDatabase database = client.getDatabase("zhoutian");
    MongoCollection<Document> collection = database.getCollection("mycollection"); 
    //利用正则 模糊匹配 包含zhaoyun1 
    Pattern pattern = Pattern.compile("^.*zhaoyun1.*$", Pattern.CASE_INSENSITIVE);
    BasicDBObject query = new BasicDBObject(); 
    //name包含zhaoyun1 
    query.put("name",pattern); 
    FindIterable<Document> findIterable = collection.find(query); 
    for (Document document : findIterable) { 
        System.out.println(document.toJson()); 
    } 
}

@Test public void testPage() { 
    MongoDatabase database = client.getDatabase("zhoutian");
    MongoCollection<Document> collection = database.getCollection("mycollection"); 
    //利用正则 模糊匹配 name包含zhaoyun1 
    Pattern pattern = Pattern.compile("^.*zhaoyun.*$", Pattern.CASE_INSENSITIVE); 
    //查询条件 
    BasicDBObject query = new BasicDBObject(); 
    query.put("name",pattern);
    //排序 
    BasicDBObject sort = new BasicDBObject(); 
    //按年龄倒序 
    sort.put("age", -1); 
    //获得总条数 
    System.out.println("共计："+collection.count()+"条记录"); 
    /** 取出第1至3条记录 
    * query : 查询条件 
    * sort: 排序 
    * skip : 起始数 从0开始 
    * limit:取几条 
    */ 
    FindIterable<Document> findIterable =           collection.find(query).sort(sort).skip(0).limit(3); 
    for (Document document : findIterable) { 
        System.out.println(document.toJson()); 
    } 
}