MongoDB(一)：MongoDB安装部署及简单使用

作者：运维人在路上

个人博客：https://www.cnblogs.com/hujinzhong

微信公众号：运维人在路上

Bilibili账号：https://space.bilibili.com/409609392

个人简介：本人是一枚大型电商平台的运维工程师，对开发及运维有一定了解，现分享技术干货，欢迎大家交流！

• 一、MongoDB介绍

• 1.1、MongoDB简介

• 1.2、体系结构

• 1.3、数据类型

• 1.4、MongoDB特点

• 1.5、业务场景应用

• 二、MongoDB单机部署

• 2.1、Windows系统安装及启动

• 2.2、Linux系统安装启动

• 2.3、图形化界面客户端

• 三、MongoDB常用基本命令

• 3.1、数据库操作

• 3.2、集合操作

• 3.3、文档操作

• 3.4、常用命令小结

• 四、MongoDB索引

• 4.1、MongoDB索引概述

• 4.2、索引的类型

• 4.3、索引的管理

• 五、Java编码

一、MongoDB介绍

1.1、MongoDB简介

1）MongoDB是一个开源、高性能、无模式的文档型数据库，当初的设计就是用于简化开发和方便扩展，是NoSQL数据库产品中的一种。是最像关系型数据库（MySQL）的非关系型数据库
。

2）它支持的数据结构非常松散，是一种类似于 JSON 的 格式叫BSON，所以它既可以存储比较复杂的数据类型，又相当的灵活。

3）MongoDB中的记录是一个文档，它是一个由字段和值对（field:value）组成的数据结构。MongoDB文档类似于JSON对象，即一个文档认为就是一个对象。字段的数据类型是字符型，它的值除了使用基本的一些类型外，还可以包括其他文档、普通数组和文档数组。

1.2、体系结构

MySQL和MongoDB对比：

1.3、数据类型

MongoDB的最小存储单位就是文档(document)
对象。文档(document)对象对应于关系型数据库的行。数据在MongoDB中以BSON（Binary-JSON）
文档的格式存储在磁盘上。

BSON（Binary Serialized Document Format
）是一种类json的一种二进制形式的存储格式，简称Binary JSON
。BSON和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型。

BSON采用了类似于 C 语言结构体的名称、对表示方法，支持内嵌的文档对象和数组对象，具有轻量性、可遍历性、高效性的三个特点，可以有效描述非结构化数据和结构化数据。这种格式的优点是灵活性高，但它的缺点是空间利用率不是很理想。

Bson中，除了基本的JSON类型：string,integer,boolean,double,null,array和object，mongo还使用了特殊的数据类型。这些类型包括date,object id,binary data,regular expression 和code。每一个驱动都以特定语言的方式实现了这些类型，查看你的驱动的文档来获取详细信息。

BSON数据类型参考列表：

注意：shell默认使用64位浮点型数值。{“x”：3.14}或{“x”：3}。对于整型值，可以使用NumberInt（4字节符号整数）或NumberLong（8字节符号整数），{“x”:NumberInt(“3”)}{“x”:NumberLong(“3”)}

1.4、MongoDB特点

MongoDB主要有如下特点：

1）高性能

MongoDB提供高性能的数据持久性。特别是对嵌入式数据模型的支持减少了数据库系统上的I/O活动。索引支持更快的查询，并且可以包含来自嵌入式文档和数组的键。

2）高可用性

MongoDB的复制工具称为副本集（replica set），它可提供自动故障转移和数据冗余。

3）高扩展性

MongoDB提供了水平可扩展性作为其核心功能的一部分。分片将数据分布在一组集群的机器上。（海量数据存储，服务能力水平扩展）

从3.4开始，MongoDB支持基于片键创建数据区域。在一个平衡的集群中，MongoDB将一个区域所覆盖的读写只定向到该区域内的那些片。

4）丰富的查询支持

MongoDB支持丰富的查询语言，支持读和写操作(CRUD)，比如数据聚合、文本搜索和地理空间查询等。

5）其他特点

如无模式（动态模式）、灵活的文档模型

1.5、业务场景应用

MongoDB可应对三高要求：

• High performance
  - 对数据库高并发读写的需求。
• Huge Storage
  - 对海量数据的高效率存储和访问的需求。
• High Scalability && High Availability
  - 对数据库的高可扩展性和高可用性的需求

具体的应用场景如：

1）社交场景，使用 MongoDB 存储存储用户信息，以及用户发表的朋友圈信息，通过地理位置索引实现附近的人、地点等功能。

2）游戏场景，使用 MongoDB 存储游戏用户信息，用户的装备、积分等直接以内嵌文档的形式存储，方便查询、高效率存储和访问。

3）物流场景，使用 MongoDB 存储订单信息，订单状态在运送过程中会不断更新，以 MongoDB 内嵌数组的形式来存储，一次查询就能将

订单所有的变更读取出来。

4）物联网场景，使用 MongoDB 存储所有接入的智能设备信息，以及设备汇报的日志信息，并对这些信息进行多维度的分析。

5）视频直播，使用 MongoDB 存储用户信息、点赞互动信息等。

数据操作的特点：

• 数据量大
• 写入操作频繁（读写都很频繁）
• 价值较低的数据，对事务性要求不高

二、MongoDB单机部署

2.1、Windows系统安装及启动

1）下载安装包

下载地址：https://www.mongodb.com/try/download/community

版本选择：

MongoDB的版本命名规范如：x.y.z

y为奇数时表示当前版本为开发版，如：1.5.2、4.1.13

y为偶数时表示当前版本为稳定版，如：1.6.3、4.0.10

z是修正版本号，数字越大越好。

2）解压启动

将压缩包解压到一个目录中，在解压目录中，手动建立一个目录用于存放数据文件，如 data/db

方式一：命令行参数启动服务

在 bin
目录中打开命令行提示符，输入如下命令：

# mongoDB的默认端口是27017，如果我们想改变默认的启动端口，可以通过--port来指定端口
mongod --dbpath=..\data\db

复制

方式二：配置文件方式启动服务

在解压目录中新建conf
文件夹，该文件夹中新建配置文件 mongod.conf

配置项文档：https://docs.mongodb.com/manual/reference/configuration-options/

# mongod.conf内容 
storage: 
  #The directory where the mongod instance stores its data.Default Value is "\data\db" on Windows. 
  dbPath: D:\mongodb-win32-x86_64-2008plus-ssl-4.0.12\data\db

复制

启动方式：

mongod -f ../conf/mongod.conf
# 或者
mongod --config ../conf/mongod.conf

复制

更多参数配置示例：

systemLog:
  destination: file
  #The path of the log file to which mongod or mongos should send all diagnostic logging information 
  path: "D:\mongodb-win32-x86_64-2008plus-ssl-4.0.12/log/mongod.log"
  logAppend: true
storage:
  journal:
    enabled: true 
 #The directory where the mongod instance stores its data.Default Value is "/data/db". 
 dbPath: "D:\mongodb-win32-x86_64-2008plus-ssl-4.0.12/data" 
net:
  #bindIp: 127.0.0.1 
  port: 27017 
setParameter: 
  enableLocalhostAuthBypass: false

复制

2.2、Linux系统安装启动

# 1、下载软件包 mongod-linux-x86_64-4.0.10.tgz

# 2、上传压缩包到Linux中，解压到指定目录
[root@mongo ~]# ll mongodb-linux-x86_64-4.0.10.tgz 
-rw-r--r-- 1 root root 84996443 Aug 10  2019 mongodb-linux-x86_64-4.0.10.tgz

# 3、移动解压后的文件夹到指定的目录中
[root@mongo ~]# tar xf mongodb-linux-x86_64-4.0.10.tgz -C /usr/local/
[root@mongo ~]# mv /usr/local/mongodb-linux-x86_64-4.0.10/ /usr/local/mongodb

# 4、新建几个目录，分别用来存储数据和日志，配置文件
[root@mongo ~]# mkdir -p /mongodb/data/db
[root@mongo ~]# mkdir -p /mongodb/log
[root@mongo ~]# mkdir -p /mongodb/conf

# 5、新建并修改配置文件
[root@mongo ~]# vim /mongodb/conf/mongod.conf
systemLog: 
   #MongoDB发送所有日志输出的目标指定为文件 
   destination: file
   #mongod或mongos应向其发送所有诊断日志记录信息的日志文件的路径 
   path: "/mongodb/log/mongod.log" 
   #当mongos或mongod实例重新启动时，mongos或mongod会将新条目附加到现有日志文件的末尾
   logAppend: true
storage: 
   #mongod实例存储其数据的目录
   dbPath: "/mongodb/data/db" 
   journal: 
      #启用或禁用持久性日志以确保数据文件保持有效和可恢复。 
      enabled: true 
processManagement: 
   #启用在后台运行mongos或mongod进程的守护进程模式。 
   fork: true 
net:
   #服务实例绑定的IP，默认是localhost 
   bindIp: localhost,10.0.0.104
   #绑定的端口，默认是27017 
   port: 27017
   
# 6、启动MongoDB服务
[root@mongo ~]# /usr/local/mongodb/bin/mongod -f /mongodb/conf/mongod.conf
about to fork child process, waiting until server is ready for connections.
forked process: 9252
child process started successfully, parent exiting

# 7、查看服务是否启动
[root@mongo ~]# ps -ef |grep mongod
root       9252      1  1 12:01 ?        00:00:00 /usr/local/mongodb/bin/mongod -f /mongodb/conf/mongod.conf
root       9474   3166  0 12:02 pts/0    00:00:00 grep --color=auto mongod

# 8、配置环境变量
[root@mongo ~]# vim /etc/profile
MONGO_HOME=/usr/local/mongodb/
export PATH=$PATH:$MONGO_HOME/bin
[root@mongo ~]# source /etc/profile

# 9、shell命令行连接
[root@mongo ~]# mongo
> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB

复制

mongod常用命令：

# 重启mongodb
mongod -f /mongodb/conf/mongod.conf --shutdown
mongod -f /mongodb/conf/mongod.conf

# mongodb关闭
#Kill模式
kill -2 PID
kill -4 PID
 
#内置模式
admin> db.shutdownServer()
或
admin> db.adminCommand({shutdown:1})
或
mongod -f /mongodb/conf/mongod.conf  --shutdown

复制

2.3、图形化界面客户端

2.3.1、MongoDB Compass

下载地址：https://www.mongodb.com/try/download/compass?initial=true

2.3.2、robo3t

下载地址：https://robomongo.org/

三、MongoDB常用基本命令

3.1、数据库操作

# 选择和创建数据库的语法格式
use 数据库名称

# 如果数据库不存在则自动创建，例如，以下语句创建 articledb数据库
# 注意: 在 MongoDB 中，集合只有在内容插入后才会创建! 就是说，创建集合(数据表)后要再插入一个文档(记录)，集合才会真正创建
use articledb

# 查看有权限查看的所有的数据库命令
show dbs/databases

# 查看当前正在使用的数据库
db

# 数据库的删除(删除持久化的数据库)
db.dropDatabase()

复制

系统默认数据库：

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

3.2、集合操作

3.2.1、集合创建

1）显式创建集合

# 创建一个名为 mycollection 的普通集合
db.createCollection("mycollection")

# 查看当前库中的集合
show collections/tables

复制

2）隐式创建集合

当向一个集合中插入一个文档的时候，如果集合不存在，则会自动创建集合。提示：通常我们使用隐式创建文档

3.2.2、集合删除

# 如果成功删除选定集合，则 drop() 方法返回 true，否则返回 false
# 删除mycollection集合
db.mycollection.drop()

复制

3.3、文档操作

文档（document）的数据结构和 JSON 基本一样。所有存储在集合中的数据都是 BSON 格式

3.3.1、文档插入

1）单个文档插入

# 向comment的集合(表)中插入一条测试数据
> db.comment.insert({"articleid":"100000","content":"今天天气真好，阳光明 媚","userid":"1001","nickname":"Rose","createdatetime":new Date(),"likenum":NumberInt(10),"state":null})
WriteResult({ "nInserted" : 1 })

# 查询
> db.comment.find()
{ "_id" : ObjectId("6062cececaa955dc12e4df30"), "articleid" : "100000", "content" : "今天天气真好，阳光明媚", "userid" : "1001", "nickname" : "Rose", "createdatetime" : ISODate("2021-03-30T07:10:06.248Z"), "likenum" : 10, "state" : null }

复制

提示：

• comment集合如果不存在，则会隐式创建
• mongo中的数字，默认情况下是double类型，如果要存整型，必须使用函数NumberInt(整型数字)
  ，否则取出来就有问题了。
• 插入当前日期使用 new Date()
  
• 插入的数据没有指定 _id
  ，会自动生成主键值
• 如果某字段没值，可以赋值为null，或不写该字段

2）文档批量插入

db.comment.insertMany([ 
{"_id":"1","articleid":"100001","content":"我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我 他。","userid":"1002","nickname":"相忘于江湖","createdatetime":new Date("2019-08- 05T22:08:15.522Z"),"likenum":NumberInt(1000),"state":"1"}, 
{"_id":"2","articleid":"100001","content":"我夏天空腹喝凉开水，冬天喝温开水","userid":"1005","nickname":"伊人憔 悴","createdatetime":new Date("2019-08-05T23:58:51.485Z"),"likenum":NumberInt(888),"state":"1"}, {"_id":"3","articleid":"100001","content":"我一直喝凉开水，冬天夏天都喝。","userid":"1004","nickname":"杰克船 长","createdatetime":new Date("2019-08-06T01:05:06.321Z"),"likenum":NumberInt(666),"state":"1"}, {"_id":"4","articleid":"100001","content":"专家说不能空腹吃饭，影响健康。","userid":"1003","nickname":"凯 撒","createdatetime":new Date("2019-08-06T08:18:35.288Z"),"likenum":NumberInt(2000),"state":"1"}, 
{"_id":"5","articleid":"100001","content":"研究表明，刚烧开的水千万不能喝，因为烫 嘴。","userid":"1003","nickname":"凯撒","createdatetime":new Date("2019-08- 06T11:01:02.521Z"),"likenum":NumberInt(3000),"state":"1"} 
]);

复制

插入时指定了 _id
，则主键就是该值。

如果某条数据插入失败，将会终止插入，但已经插入成功的数据不会回滚掉。

因为批量插入由于数据较多容易出现失败，因此，可以使用try catch进行异常捕捉处理，测试的时候可以不处理

try {
 db.comment.insertMany([ 
{"_id":"1","articleid":"100001","content":"我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我 他。","userid":"1002","nickname":"相忘于江湖","createdatetime":new Date("2019-08- 05T22:08:15.522Z"),"likenum":NumberInt(1000),"state":"1"}, 
{"_id":"2","articleid":"100001","content":"我夏天空腹喝凉开水，冬天喝温开水","userid":"1005","nickname":"伊人憔 悴","createdatetime":new Date("2019-08-05T23:58:51.485Z"),"likenum":NumberInt(888),"state":"1"}, {"_id":"3","articleid":"100001","content":"我一直喝凉开水，冬天夏天都喝。","userid":"1004","nickname":"杰克船 长","createdatetime":new Date("2019-08-06T01:05:06.321Z"),"likenum":NumberInt(666),"state":"1"}, {"_id":"4","articleid":"100001","content":"专家说不能空腹吃饭，影响健康。","userid":"1003","nickname":"凯 撒","createdatetime":new Date("2019-08-06T08:18:35.288Z"),"likenum":NumberInt(2000),"state":"1"}, 
{"_id":"5","articleid":"100001","content":"研究表明，刚烧开的水千万不能喝，因为烫嘴。","userid":"1003","nickname":"凯撒","createdatetime":new Date("2019-08- 06T11:01:02.521Z"),"likenum":NumberInt(3000),"state":"1"} 
]);
}catch(e){
 print(e);
}

复制

3.3.2、文档基本查询

查询语法：

db.collection.find(<query>, [projection])

复制

1）查询所有

# 查询所有
> db.comment.find()
> db.comment.find({})

# 条件查询
> db.comment.find({userid:'1003'})

# 返回符合条件的第一条数据
> db.comment.findOne({userid:'1003'})
{
 "_id" : "4",
 "articleid" : "100001",
 "content" : "专家说不能空腹吃饭，影响健康。",
 "userid" : "1003",
 "nickname" : "凯 撒",
 "createdatetime" : ISODate("2019-08-06T08:18:35.288Z"),
 "likenum" : 2000,
 "state" : "1"
}

复制

2）投影查询（Projection Query
）

如果要查询结果返回部分字段，则需要使用投影查询（不显示所有字段，只显示指定的字段）

# 查询结果只显示 _id、userid、nickname
> db.comment.find({userid:"1003"},{userid:1,nickname:1})
{ "_id" : "4", "userid" : "1003", "nickname" : "凯 撒" }
{ "_id" : "5", "userid" : "1003", "nickname" : "凯撒" }

# 查询结果只显示userid、nickname,不显示_id
> db.comment.find({userid:"1003"},{userid:1,nickname:1,_id:0})
{ "userid" : "1003", "nickname" : "凯 撒" }
{ "userid" : "1003", "nickname" : "凯撒" }

# 查询所有数据，但只显示 _id、userid、nickname
> db.comment.find({},{userid:1,nickname:1,_id:0})
{ "userid" : "1002", "nickname" : "相忘于江湖" }
{ "userid" : "1005", "nickname" : "伊人憔悴" }
{ "userid" : "1004", "nickname" : "杰克船长" }
{ "userid" : "1003", "nickname" : "凯撒" }
{ "userid" : "1003", "nickname" : "凯撒" }

复制

3.3.3、文档更新

1）覆盖修改

# 修改_id为1的记录，点赞量为1001
> db.comment.find({_id:"1"})
{ "_id" : "1", "articleid" : "100001", "content" : "我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我他。", "userid" : "1002", "nickname" : "相忘于江湖", "createdatetime" : ISODate("1970-01-01T00:00:00Z"), "likenum" : 1000, "state" : "1" }
> db.comment.update({_id:"1"},{likenum:NumberInt(1001)})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.comment.find({_id:"1"})
{ "_id" : "1", "likenum" : 1001 }

复制

2）局部修改

需要使用修改器$set
来实现

> db.comment.find({_id:"2"})
{ "_id" : "2", "articleid" : "100001", "content" : "我夏天空腹喝凉开水，冬天喝温开水", "userid" : "1005", "nickname" : "伊人憔 悴", "createdatetime" : ISODate("2019-08-05T23:58:51.485Z"), "likenum" : 888, "state" : "1" }
> db.comment.update({_id:"2"},{$set:{likenum:NumberInt(1001)}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.comment.find({_id:"2"})
{ "_id" : "2", "articleid" : "100001", "content" : "我夏天空腹喝凉开水，冬天喝温开水", "userid" : "1005", "nickname" : "伊人憔 悴", "createdatetime" : ISODate("2019-08-05T23:58:51.485Z"), "likenum" : 1001, "state" : "1" }

复制

3）批量修改

# 默认只修改第一条数据
> db.comment.update({userid:"1003"},{$set:{nickname:"凯撒2"}}) 
# 修改所有符合条件的数据 
> db.comment.update({userid:"1003"},{$set:{nickname:"凯撒大帝"}},{multi:true})

复制

4）列值增长修改

想实现对某列值在原有值的基础上进行增加或减少，可以使用 $inc
运算符来实现

# 对3号数据的点赞数，每次递增1
> db.comment.update({_id:"3"},{$inc:{likenum:NumberInt(1)}})

复制

3.3.4、文档删除

刪除语法：db.集合名称.remove(条件)

# 全部删除
> db.comment.remove({})

# 部分删除
> db.comment.remove({_id:"1"})

复制

3.3.5、文档复杂查询

1）统计查询

# 统计comment集合的所有的记录数
> db.comment.count()
5

# 统计userid为1003的记录条数
> db.comment.count({userid:"1003"})
2

复制

2）分页列表查询

可以使用limit()
方法来读取指定数量的数据，使用skip()
方法来跳过指定数量的数据

# 返回指定条数的记录，可以在find方法后调用limit来返回结果(TopN)，默认值20
> db.comment.find().limit(3)
{ "_id" : "1", "articleid" : "100001", "content" : "我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我 他。", "userid" : "1002", "nickname" : "相忘于江湖", "createdatetime" : ISODate("1970-01-01T00:00:00Z"), "likenum" : 1000, "state" : "1" }
{ "_id" : "2", "articleid" : "100001", "content" : "我夏天空腹喝凉开水，冬天喝温开水", "userid" : "1005", "nickname" : "伊人憔 悴", "createdatetime" : ISODate("2019-08-05T23:58:51.485Z"), "likenum" : 888, "state" : "1" }
{ "_id" : "3", "articleid" : "100001", "content" : "我一直喝凉开水，冬天夏天都喝。", "userid" : "1004", "nickname" : "杰克船 长", "createdatetime" : ISODate("2019-08-06T01:05:06.321Z"), "likenum" : 666, "state" : "1" }

# skip方法同样接受一个数字参数作为跳过的记录条数。（前N个不要）,默认值是0
> db.comment.find().skip(3)
{ "_id" : "4", "articleid" : "100001", "content" : "专家说不能空腹吃饭，影响健康。", "userid" : "1003", "nickname" : "凯 撒", "createdatetime" : ISODate("2019-08-06T08:18:35.288Z"), "likenum" : 2000, "state" : "1" }
{ "_id" : "5", "articleid" : "100001", "content" : "研究表明，刚烧开的水千万不能喝，因为烫嘴。", "userid" : "1003", "nickname" : "凯撒", "createdatetime" : ISODate("1970-01-01T00:00:00Z"), "likenum" : 3000, "state" : "1" }

复制

分页查询需求：每页2个，第二页开始：跳过前两条数据，接着值显示3和4条数据

# 第一页
> db.comment.find().skip(0).limit(2)
{ "_id" : "1", "articleid" : "100001", "content" : "我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我 他。", "userid" : "1002", "nickname" : "相忘于江湖", "createdatetime" : ISODate("1970-01-01T00:00:00Z"), "likenum" : 1000, "state" : "1" }
{ "_id" : "2", "articleid" : "100001", "content" : "我夏天空腹喝凉开水，冬天喝温开水", "userid" : "1005", "nickname" : "伊人憔 悴", "createdatetime" : ISODate("2019-08-05T23:58:51.485Z"), "likenum" : 888, "state" : "1" }
# 第二页
> db.comment.find().skip(2).limit(2)
{ "_id" : "3", "articleid" : "100001", "content" : "我一直喝凉开水，冬天夏天都喝。", "userid" : "1004", "nickname" : "杰克船 长", "createdatetime" : ISODate("2019-08-06T01:05:06.321Z"), "likenum" : 666, "state" : "1" }
{ "_id" : "4", "articleid" : "100001", "content" : "专家说不能空腹吃饭，影响健康。", "userid" : "1003", "nickname" : "凯 撒", "createdatetime" : ISODate("2019-08-06T08:18:35.288Z"), "likenum" : 2000, "state" : "1" }
# 第三页
> db.comment.find().skip(4).limit(2)
{ "_id" : "5", "articleid" : "100001", "content" : "研究表明，刚烧开的水千万不能喝，因为烫嘴。", "userid" : "1003", "nickname" : "凯撒", "createdatetime" : ISODate("1970-01-01T00:00:00Z"), "likenum" : 3000, "state" : "1" }

复制

3）排序查询

sort()
方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列

# 对userid降序排列，并对访问量进行升序排列
> db.comment.find({},{userid:1,likenum:1}).sort({userid:-1,likenum:1})
{ "_id" : "2", "userid" : "1005", "likenum" : 888 }
{ "_id" : "3", "userid" : "1004", "likenum" : 666 }
{ "_id" : "4", "userid" : "1003", "likenum" : 2000 }
{ "_id" : "5", "userid" : "1003", "likenum" : 3000 }
{ "_id" : "1", "userid" : "1002", "likenum" : 1000 }

复制

注意：skip(), limilt(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()，和命令编写顺序无关

4）正则查询

MongoDB的模糊查询是通过正则表达式的方式实现的，格式为：

db.collection.find({field:/正则表达式/})
db.集合.find({字段:/正则表达式/})

复制

示例如下：

# 查询评论内容包含“开水”的所有文档
> db.comment.find({content:/开水/})

# 查询评论的内容中以“专家”开头的
> db.comment.find({content:/^专家/})

复制

5）比较查询

格式如下：

# 大于: field > value 
db.集合名称.find({ "field" : { $gt: value }})
# 小于: field < value 
db.集合名称.find({ "field" : { $lt: value }}) 
# 大于等于: field >= value 
db.集合名称.find({ "field" : { $gte: value }}) 
# 小于等于: field <= value 
db.集合名称.find({ "field" : { $lte: value }}) 
# 不等于: field != value
db.集合名称.find({ "field" : { $ne: value }}) 

复制

示例如下：

# 查询评论点赞数量大于700的记录
> db.comment.find({likenum:{$gt:NumberInt(700)}})

复制

6）包含查询

使用$in
操作符和用$nin
操作符

# 查询评论的集合中userid字段包含1003或1004的文档
> db.comment.find({userid:{$in:["1003","1004"]}})

# 查询评论集合中userid字段不包含1003和1004的文档
> db.comment.find({userid:{$nin:["1003","1004"]}})

复制

7）条件连接查询

语法格式如下：

# 需要查询同时满足两个以上条件，需要使用$and操作符将条件进行关联
$and:[ { },{ },{ } ]
# 如果两个以上条件之间是或者的关系，我们使用$or操作符进行关联
$or:[ { },{ },{ } ]

复制

示例如下：

# 查询评论集合中likenum大于等于700 并且小于2000的文档
> db.comment.find({$and:[{likenum:{$gte:NumberInt(700)}},{likenum:{$lt:NumberInt(2000)}}]})

# 查询评论集合中userid为1003，或者点赞数小于1000的文档记录
> db.comment.find({$or:[ {userid:"1003"} ,{likenum:{$lt:1000} }]})

复制

3.4、常用命令小结

# 选择切换数据库
use articledb
# 插入数据
db.comment.insert({bson数据}) 
# 查询所有数据
db.comment.find();
# 条件查询数据
db.comment.find({条件})
# 查询符合条件的第一条记录
db.comment.findOne({条件})
# 查询符合条件的前几条记录
db.comment.find({条件}).limit(条数)
# 查询符合条件的跳过的记录
db.comment.find({条件}).skip(条数)
# 修改数据
db.comment.update({条件},{修改后的数据}) 或db.comment.update({条件},{$set:{要修改部分的字段:数据})
# 修改数据并自增某字段值
db.comment.update({条件},{$inc:{自增的字段:步进值}})
# 删除数据
db.comment.remove({条件}) 
# 统计查询
db.comment.count({条件})
# 模糊查询
db.comment.find({字段名:/正则表达式/})
# 条件比较运算
db.comment.find({字段名:{$gt:值}})
# 包含查询
db.comment.find({字段名:{$in:[值1，值2]}})或db.comment.find({字段名:{$nin:[值1，值2]}}) 
# 条件连接查询
db.comment.find({$and:[{条件1},{条件2}]})或db.comment.find({$or:[{条件1},{条件2}]})

复制

四、MongoDB索引

4.1、MongoDB索引概述

索引支持在MongoDB中高效地执行查询。如果没有索引，MongoDB必须执行全集合扫描，即扫描集合中的每个文档，以选择与查询语句匹配的文档。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。如果查询存在适当的索引，MongoDB可以使用该索引限制必须检查的文档数。

索引是特殊的数据结构，它以易于遍历的形式存储集合数据集的一小部分。索引存储特定字段或一组字段的值，按字段值排序。索引项的排序支持有效的相等匹配和基于范围的查询操作。此外，MongoDB还可以使用索引中的排序返回排序结果。

官网文档：https://docs.mongodb.com/manual/indexes/

了解：MongoDB索引使用B树数据结构（确切的说是B-Tree，MySQL是B+Tree）

4.2、索引的类型

4.2.1、单字段索引

MongoDB支持在文档的单个字段上创建用户定义的升序/降序索引，称为单字段索引（Single Field Index）

对于单个字段索引和排序操作，索引键的排序顺序（即升序或降序）并不重要，因为MongoDB可以在任何方向上遍历索引

4.2.2、复合索引

MongoDB还支持多个字段的用户定义索引，即复合索引（Compound Index）
。

复合索引中列出的字段顺序具有重要意义。例如，如果复合索引由 { userid: 1, score: -1 } 组成，则索引首先按userid正序排序，然后在每个userid的值内，再在按score倒序排序

4.2.3、其他索引

1）地理空间索引（Geospatial Index）

为了支持对地理空间坐标数据的有效查询，MongoDB提供了两种特殊的索引：返回结果时使用平面几何的二维索引和返回结果时使用球面几何的二维球面索引。

2）文本索引（Text Indexes）

MongoDB提供了一种文本索引类型，支持在集合中搜索字符串内容。这些文本索引不存储特定于语言的停止词（例如“the”、“a”、“or”），而将集合中的词作为词干，只存储根词。

3）哈希索引（Hashed Indexes）

为了支持基于散列的分片，MongoDB提供了散列索引类型，它对字段值的散列进行索引。这些索引在其范围内的值分布更加随机，但只支持相等匹配，不支持基于范围的查询

4.3、索引的管理

4.3.1、索引的查看

返回一个集合中的所有索引的数组

>  db.comment.getIndexes()
[
 {
  "v" : 2,
  "key" : {
   "_id" : 1
  },
  "name" : "_id_",
  "ns" : "articledb.comment"
 }
]

复制

默认_id索引：MongoDB在创建集合的过程中，在 _id 字段上创建一个唯一的索引，默认名字为 _id_
，该索引可防止客户端插入两个具有相同值的文

档，您不能在_id字段上删除此索引。

注意：该索引是唯一索引，因此值不能重复，即 _id 值不能重复的。在分片集群中，通常使用 _id 作为片键

4.3.2、索引的创建

1）创建单字段索引

# 单字段索引示例：对userid字段建立索引
>  db.comment.createIndex({userid:1})
{
 "createdCollectionAutomatically" : false,
 "numIndexesBefore" : 1,
 "numIndexesAfter" : 2,
 "ok" : 1
}
> db.comment.getIndexes()
[
 {
  "v" : 2,
  "key" : {
   "_id" : 1
  },
  "name" : "_id_",
  "ns" : "articledb.comment"
 },
 {
  "v" : 2,
  "key" : {
   "userid" : 1
  },
  "name" : "userid_1",
  "ns" : "articledb.comment"
 }
]

复制

2）创建复合索引

# 复合索引：对 userid 和 nickname 同时建立复合（Compound）索引
> db.comment.createIndex({userid:1,nickname:-1})
{
 "createdCollectionAutomatically" : false,
 "numIndexesBefore" : 2,
 "numIndexesAfter" : 3,
 "ok" : 1
}
> db.comment.getIndexes()
[
 {
  "v" : 2,
  "key" : {
   "_id" : 1
  },
  "name" : "_id_",
  "ns" : "articledb.comment"
 },
 {
  "v" : 2,
  "key" : {
   "userid" : 1
  },
  "name" : "userid_1",
  "ns" : "articledb.comment"
 },
 {
  "v" : 2,
  "key" : {
   "userid" : 1,
   "nickname" : -1
  },
  "name" : "userid_1_nickname_-1",
  "ns" : "articledb.comment"
 }
]

复制

4.3.3、索引的移除

# 删除 comment 集合中 userid 字段上的升序索引
> db.comment.dropIndex({userid:1})
{ "nIndexesWas" : 3, "ok" : 1 }
> db.comment.getIndexes()
[
 {
  "v" : 2,
  "key" : {
   "_id" : 1
  },
  "name" : "_id_",
  "ns" : "articledb.comment"
 },
 {
  "v" : 2,
  "key" : {
   "userid" : 1,
   "nickname" : -1
  },
  "name" : "userid_1_nickname_-1",
  "ns" : "articledb.comment"
 }
]

# 根据索引名称删除
> db.comment.dropIndex("userid_1_nickname_-1")
{ "nIndexesWas" : 2, "ok" : 1 }
> db.comment.getIndexes()
[
 {
  "v" : 2,
  "key" : {
   "_id" : 1
  },
  "name" : "_id_",
  "ns" : "articledb.comment"
 }
]

# 删除所有的索引
> db.collection.dropIndexes()
{
 "ok" : 0,
 "errmsg" : "ns not found",
 "code" : 26,
 "codeName" : "NamespaceNotFound"
}
> db.comment.getIndexes()
[
 {
  "v" : 2,
  "key" : {
   "_id" : 1
  },
  "name" : "_id_",
  "ns" : "articledb.comment"
 }
]

复制

提示：_id
的字段的索引是无法删除的，只能删除非 _id 字段的索引

4.3.4、索引执行计划

分析查询性能（Analyze Query Performance
）通常使用执行计划来查看查询的情况，如查询耗费的时间、是否基于索引查询等

1）单字段索引执行计划

# 查看根据userid查询数据的情况
>  db.comment.find({userid:"1003"}).explain()
{
 "queryPlanner" : {
  "plannerVersion" : 1,
  "namespace" : "articledb.comment",
  "indexFilterSet" : false,
  "parsedQuery" : {
   "userid" : {
    "$eq" : "1003"
   }
  },
  "winningPlan" : {
   "stage" : "COLLSCAN", # 表示全集合扫描
   "filter" : {
    "userid" : {
     "$eq" : "1003"
    }
   },
   "direction" : "forward"
  },
  "rejectedPlans" : [ ]
 },
 "serverInfo" : {
  "host" : "mongo",
  "port" : 27017,
  "version" : "4.0.10",
  "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
 },
 "ok" : 1
}

复制

在compass
中执行查看：

下面对userid
建立索引，再次查看执行计划

> db.comment.createIndex({userid:1})
{
 "createdCollectionAutomatically" : false,
 "numIndexesBefore" : 1,
 "numIndexesAfter" : 2,
 "ok" : 1
}
> db.comment.find({userid:"1003"}).explain()
{
 "queryPlanner" : {
  "plannerVersion" : 1,
  "namespace" : "articledb.comment",
  "indexFilterSet" : false,
  "parsedQuery" : {
   "userid" : {
    "$eq" : "1003"
   }
  },
  "winningPlan" : {
   "stage" : "FETCH",
   "inputStage" : {
    "stage" : "IXSCAN", # 基于索引的扫描
    "keyPattern" : {
     "userid" : 1
    },
    "indexName" : "userid_1",
    "isMultiKey" : false,
    "multiKeyPaths" : {
     "userid" : [ ]
    },
    "isUnique" : false,
    "isSparse" : false,
    "isPartial" : false,
    "indexVersion" : 2,
    "direction" : "forward",
    "indexBounds" : {
     "userid" : [
      "[\"1003\", \"1003\"]"
     ]
    }
   }
  },
  "rejectedPlans" : [ ]
 },
 "serverInfo" : {
  "host" : "mongo",
  "port" : 27017,
  "version" : "4.0.10",
  "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
 },
 "ok" : 1
}

复制

4.3.5、覆盖的查询

文档：https://docs.mongodb.com/manual/core/query-optimization/#read-operations-covered-query

当查询条件和查询的投影仅包含索引字段时，MongoDB直接从索引返回结果，而不扫描任何文档或将文档带入内存。这些覆盖的查询可以非常有效

> db.comment.find({userid:"1003"},{userid:1,_id:0})
{ "userid" : "1003" }
{ "userid" : "1003" }
> db.comment.find({userid:"1003"},{userid:1,_id:0}).explain()
{
 "queryPlanner" : {
  "plannerVersion" : 1,
  "namespace" : "articledb.comment",
  "indexFilterSet" : false,
  "parsedQuery" : {
   "userid" : {
    "$eq" : "1003"
   }
  },
  "winningPlan" : {
   "stage" : "PROJECTION",
   "transformBy" : {
    "userid" : 1,
    "_id" : 0
   },
   "inputStage" : {
    "stage" : "IXSCAN",
    "keyPattern" : {
     "userid" : 1
    },
    "indexName" : "userid_1",
    "isMultiKey" : false,
    "multiKeyPaths" : {
     "userid" : [ ]
    },
    "isUnique" : false,
    "isSparse" : false,
    "isPartial" : false,
    "indexVersion" : 2,
    "direction" : "forward",
    "indexBounds" : {
     "userid" : [
      "[\"1003\", \"1003\"]"
     ]
    }
   }
  },
  "rejectedPlans" : [ ]
 },
 "serverInfo" : {
  "host" : "mongo",
  "port" : 27017,
  "version" : "4.0.10",
  "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
 },
 "ok" : 1
}

复制

五、Java编码

1）搭建项目工程article，pom.xml
引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>co,.dianchou</groupId>
    <artifactId>demo_mongo_article</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

</project>

复制

2）编写application.yml

spring:
  data:
    mongodb:
      host: 10.0.0.104
      database: articledb
      port: 27017
      #也可以使用uri连接
      #uri: mongodb://10.0.0.104:27017/articledb

复制

3）启动类

package com.dianchou.article;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class ArticleApplication {
    public static void main(String[] args) {
        SpringApplication.run(ArticleApplication.class, args);
    }
}

复制

4）实体类**

package com.dianchou.article.pojo;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.CompoundIndex;
import org.springframework.data.mongodb.core.index.Indexed;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import java.io.Serializable;
import java.time.LocalDateTime;
import java.util.Date;

/**
 * 文章评论实体类
 */
@Data
@Document(collection="comment")
@CompoundIndex( def = "{'userid': 1, 'nickname': -1}")
public class Comment implements Serializable {
    @Id
    private String id;//主键
    @Field("content")
    private String content;     //吐槽内容
    private Date publishtime;   //发布日期
    @Indexed    //单字段索引注解
    private String userid;      //发布人ID
    private String nickname;    //昵称
    private LocalDateTime createdatetime;   //评论的日期时间
    private Integer likenum;    //点赞数
    private Integer replynum;   //回复数
    private String state;   //状态
    private String parentid;    //上级ID
    private String articleid;

}

复制

5）Dao层

package com.dianchou.article.dao;

import com.dianchou.article.pojo.Comment;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.repository.MongoRepository;


//评论的持久层接口
public interface CommentRepository extends MongoRepository<Comment,String> {

    //根据父id，查询子评论的分页列表
    Page<Comment> findByParentid(String parentid, Pageable pageable);
}

复制

6）service层

package com.dianchou.article.service;

import com.dianchou.article.dao.CommentRepository;
import com.dianchou.article.pojo.Comment;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class CommentService {

    @Autowired
    private CommentRepository commentRepository;
    @Autowired
    private MongoTemplate mongoTemplate;


    /**
     * 保存一个评论
     */
    public void saveComment(Comment comment){
        commentRepository.save(comment);
    }

    /**
     * 更新评论
     */
    public void updateComment(Comment comment){
        commentRepository.save(comment);
    }

    /**
     * 根据id删除评论
     */
    public void deleteCommentById(String id){
        commentRepository.deleteById(id);
    }

    /**
     * 查询所有评论
     */
    public List<Comment> findCommentList(){
        return commentRepository.findAll();
    }

    /**
     * 根据id查询评论
     */
    public Comment findCommentById(String id){
        return commentRepository.findById(id).get();
    }

    /**
     * 根据父id查询
     */
    public Page<Comment> findCommentListByParentid(String parentid,int page,int size) {
        return commentRepository.findByParentid(parentid,PageRequest.of(page-1,size));
    }

    /**
     * 更新点赞数
     */
    public void updateCommentLikenum(String id){

        //  查询条件
        Query query = Query.query(Criteria.where("_id").is(id));
        //  更新条件
        Update update = new Update();
        update.inc("likenum");
        mongoTemplate.updateFirst(query,update,Comment.class);
    }

}

复制

7）测试类

package com.diancou.article.service;

import com.dianchou.article.ArticleApplication;
import com.dianchou.article.pojo.Comment;
import com.dianchou.article.service.CommentService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Page;
import org.springframework.test.context.junit4.SpringRunner;

import java.time.LocalDateTime;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ArticleApplication.class)
public class CommentServiceTest {

    @Autowired
    private CommentService commentService;


    @Test
    public void testFindCommentList() {
        List<Comment> commentList = commentService.findCommentList();
        System.out.println(commentList);
    }

    @Test
    public void testFindCommentById() {
        Comment commentById = commentService.findCommentById("1");
        System.out.println(commentById);
    }

    @Test
    public void testSaveComment(){
        Comment comment=new Comment();
        comment.setArticleid("100000");
        comment.setContent("测试添加的数据");
        comment.setCreatedatetime(LocalDateTime.now());
        comment.setUserid("1003");
        comment.setNickname("凯撒大帝");
        comment.setState("1");
        comment.setLikenum(0);
        comment.setReplynum(0);

        commentService.saveComment(comment);

    }

    @Test
    public void testFindCommentListByParentid() {
        Page<Comment> page = commentService.findCommentListByParentid("3", 1, 2);
        System.out.println(page.getTotalElements());
        System.out.println(page.getContent());
    }

    @Test
    public void testUpdateCommentLikenum() {
        commentService.updateCommentLikenum("1");
    }

}

复制