MongoDB基本使用

一、MongoDB介绍

MongoDB是一个NoSQL数据库，它是跨平台的，基于分布式文件存储的数据库，由C++语言编写的（这点很重要，则表示在Linux下需要安装gcc环境）。MongoDB是以文档的形式存储数据，数据结构由键值(key:value)对组成，类似JSON。

​ MongoDB结构，最小的单位为文档（类似MySQL的行），每一个文档用的是BSON形式来存储（类似JSON），文档的上一层为集合（类似MySQL的表），再上一级为库（类似MySQL的数据库）。

二、MongoDB启动

1.参数说明

参数	描述
–bind_ip	绑定服务IP，若绑定127.0.0.1，则只能本机访问，不指定，默认本地所有IP
–logpath	指定MongoDB日志文件
–logappend	使用追加方式书写日志
–dbpath	指定数据库路径
–port	指定服务端口号，默认为27017
–serviceName	指定服务名
–serviceDisplayName	指定服务名（在多个MongoDB服务时执行）
–install	指定作为一个Windows服务安装

2.启动MongoDB服务器的方式

2.1进入MongoDB目录的bin目录中执行mongod.exe文件(命令行)

在执行命令前，先在F盘目录下创建/data/db

进入cmd控制台，进入mongodb的安装bin目录，执行命令

cd C:\Program Files\MongoDB\Server\4.0\bin mongod.exe --dbpath f:\data\db

启动成功后，会在指定的目录下生成数据库文件信息

2.2将MongoDB服务器作为Windows服务来运行

cd C:\Program Files\MongoDB\Server\4.0\bin  mongod.exe --bind_ip 127.0.0.1 --logpath "f:\data\log\mongodb.log" --logappend --dbpath "f:\data\db" --port 27017 --serviceName "demo" --serviceDisplayName "demo" --install

在执行命令前需要创建对应的目录结构

进入cmd，执行命令（一定要以管理员的身份运行cmd控制台）

查看指定的mongodb的日志文件（即–logpath 指定的路径）

看日志文件，需要在命令行用[net start demo]，启动mongodb

自动生成数据库的文件信息在F:/data/db

进程里mongod正在运行，如下图

2.3 bin文件下的exe文件功能

mongod.exe：启动MongoDB服务器

mongo.exe：启动MongoDB Shell

3.SQL术语和MongoDB术语比较

SQL术语	MongoDB术语	说明
database	database	数据库
table	collection	数据库表/集合
row	document	数据记录行/文档
column	field	数据字段/域
index	index	索引
table joins		表连接（MongoDB不支持）
primary key	primary key	主键（MongoDB自动将_id字段设置为主键）

三、基本命令学习

1.db命令：查看当前操作的文档(数据库)

2.show dbs命令：显示所有数据的列表

3.use命令：连接到一个指定的数据库（如果数据库不存在创建数据库，否则打开该数据库。）

4.删除数据库：db.dropDatabase()

查看当前数据库为test1; 删除当前数据库；查看已有数据库内该数据库已经被删除成功。

5、从指定主机上克隆数据库

db.cloneDatabase(“127.0.0.1”); 将指定机器上的数据库的数据克隆到当前数据库

6、从指定的机器上复制指定数据库数据到某个数据库

db.copyDatabase(“mydb”, “temp”, “127.0.0.1”);将本机的mydb的数据复制到temp数据库中

7、修复当前数据库

db.repairDatabase();

8、查看当前使用的数据库

db.getName();

db; db和getName方法是一样的效果，都可以查询当前使用的数据库

9、显示当前db状态

db.stats();

10、当前db版本

db.version();

11、查看当前db的链接机器地址

db.getMongo();

按照上面的安装完成后，就可以使用MongDB了，操作的指令都是一样的，我自己使用的是Linux，所以下面都以Linux为例。

​ 找到你安装MongDB目录，如果不知道，可以通过ps -ef | grep mongo 来查看mongodb所在的位置，在Linux下，MonggoDB是随着Linux一起启动的。如果你不小心关闭了，可以通过命令service mongodb start来启动服务（注意，此处的启动服务不是使用MongDB），通过命令 service mongodb stop关闭服务。

​ 下面才是真正的使用MongoDB，上面已经教了怎么查找mongpdb的位置，找到位置之后呢，通过命令 ./mongo 进入到MongoDB的真正服务中，也就是到了此处才是真正的使用MongoDB。

​ 总结一波：

pe -ef | grep mongodb  查看mongodb的目录和看是否启动
service mongodb start  
启动mongodb服务
service mongodb stop   
关闭mongodb服务
./mongo  真正使用mongodb服务

​ 在mongodb中，我们就要学习mongodb 的指令了，类似于学习sql一样，注意：在MongoDB中，是区分大小写的，要特别注意这一点。

12、 先从库级别的指令开始：

> show dbs;             
查看数据库，会显示当前的数据库，以及占用的内存大小。local   0.078125GB  
注意：该命令不会显示空的数据库，也就是说你新建的数据库没数据是不会显示的。 
> db       
查看当前用户连接的是哪个库，没错就是这2个字符。test
> use xuye            
创建一个库，名为xuyeswitched to db xuye 
> use xuye            
注意上面我们db查看当前库是test，现在我们切换到xuye这个库了。
switched to db xuye    
use的命令有两个作用，一个是切换库，如果这个库不存在就是创建库。
> db     查看当前连接的库，此时使用的是xuye这个库。xuye 
> db.dropDatabase()    删除当前连接的数据库，类似对对象调用方法的操作，db表示当前的用户{ "dropped" : "xuye", "ok" : 1 }        
>dropDatabase()函数表示执行删除操作，下面的是返回值。 
> show users      显示当前用户，没有数据则不显示

13、 集合（类似MySQL的表级别）级别的指令：

​ 需要注意的是，在集合中，可以随意存储任何想干或者不想干的数据，并不像关系型数据库中已经定死了这个列必须是什么值，必须按照这个格式，如果现在不理解，待会看下面。

> db.createCollection("user",{size:20,capped:true,autolndexld:true,max:50}) { "ok" : 1 }在当前库下创建了一个集合，该集合自动添加索引，并且该集合为固定长度，20字节，集合中最多包包含50个文档。

​ db.createCollection(name,option)，其中option是一个json格式，可选参数以及信息如下。

14、 一些集合级别的其它操作

> db.getCollectionNames()[ "system.indexes", "user" ]
> show collectionssystem.indexesuser 
两个指令都是获得到当前库下的所有集合名。 
> db.getCollection("user")   
获得到单个的集合信息xuye.user                    
> db.printCollectionStats(); 
会显示当前库下集合的创建信息，例如MySQL的查看表设置的信息。user{        "ns" : "xuye.user",        "count" : 0,        "size" : 0,        "storageSize" : 4096,        "numExtents" : 1,        "nindexes" : 1,        "lastExtentSize" : 4096,        "paddingFactor" : 1,        "systemFlags" : 1,        "userFlags" : 0,        "totalIndexSize" : 8176,        "indexSizes" : {                "_id_" : 8176        },        "capped" : true,        "max" : 50,        "ok" : 1} 
> db.user.drop()          
删除当前库下的user集合。true 

15、 文档级别的操作指令：

> db.student.insert({"name":"xuye","school":"hafo","numbe":141420014})  
插入一条文档，我并没有创建集合student，直接写插入语句，如果表不存在会自动创建（一般都是使用此方式来建表，而不是去用createColletion()创建表，此方式的容量会自动增长。） 
> db.student.insert({"class":101,"number":1401420,"teach":"xuye"})
在插入一条文档，可以发现，两条文档之间的格式要求是没有任何关系的，甚至你可以随便插入不是关于学生此类的信息都可以，但是一般一个表只插入一类信息的文档（约定成俗的）。  
> db.student.find()      
查看该集合中所有的文档。{ "_id" : ObjectId("5b7d1aa979c725e3580ed2db") }{ "_id" : ObjectId("5b7d1b1d79c725e3580ed2dc"), "name" : "xuye", "school" : "hafo", "numbe" : 141420014 }{ "_id" : ObjectId("5b7d1c57c8ff91d6ecaf79d8"), "class" : 101, "number" : 1401420, "teach" : "xuye" }
此处还需要注意，我们并没有插入_id这个东西，这是mongodb自动帮我们生成的一个id，是唯一的，所以也就不需要我们去生成id了。 
> db.student.find().pretty(){ "_id" : ObjectId("5b7d1aa979c725e3580ed2db") }{        "_id" : ObjectId("5b7d1b1d79c725e3580ed2dc"),        "name" : "xuye",        "school" : "hafo",        "numbe" : 141420014} 
格式化显示查询的语句，应该还有几条，我只取了其中一条粘贴在这里，就类似代码的格式化，好看一些。 
> db.student.insert({"name":"xuye","number":140246,"deskmate":{"name":"xiaobai","number":140265}})
插入一条复杂一些的文档，可以嵌套，和json一样，只要符合键值对的形式都可以使用。如果多个嵌套的话，要使用中括号，如下。 
db.student.insert({"name":"xuye","number":140246,"deskmate":[{"name":"xiaobai","number":140265},{"name":"xiaohei","number":"142064"}]})   

16、 分页查询：

> db.books.insert({"name":"spring","price":20.01})
> db.books.insert({"name":"springMvc","price":19.99})
> db.books.insert({"name":"java","price":67.84})
> db.books.insert({"name":"linux","price":289.78})
> db.books.insert({"name":"python","price":29.78})
> db.books.insert({"name":"c++","price":157.68})
先插入一些数据，书名和书的价格。
> db.books.find(){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }{ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d4a7f8e6123a7a302be28"), "name" : "java", "price" : 67.84 }{ "_id" : ObjectId("5b7d4a898e6123a7a302be29"), "name" : "linux", "price" : 289.78 }{ "_id" : ObjectId("5b7d4a9f8e6123a7a302be2a"), "name" : "python", "price" : 29.78 }{ "_id" : ObjectId("5b7d4aad8e6123a7a302be2b"), "name" : "c++", "price" : 157.68 }
查看数据，下面进行分页。
> db.books.find().skip(0).limit(3){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }{ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d4a7f8e6123a7a302be28"), "name" : "java", "price" : 67.84 }
分页查询，表示查到的数据，从第一条开始，显示3条。类似SQL的limit 0,3。也可以记为，跳过0条，显示3条。 
> db.books.find().limit(3).skip(0){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }{ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d4a7f8e6123a7a302be28"), "name" : "java", "price" : 67.84 }limit和skip两个函数可以更换位置，结果都一样。 
> db.books.find().limit(3)  等同于db.books.find().skip(0).limit(3) 
> db.books.find().skip(5)    跳过前5条，显示第六条以后的所有文档。

17、 带条件的查询：（and、or、gt、lt、正则、去重、排序等查询）

> db.books.find({"name":"spring"}){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }
查询name为spring的书籍，在find函数的里面加上json格式的条件即可。 
> db.books.find({"name":"spring","price":20.01}){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }
多条件查询，使用逗号分隔即可，类似select * form books where name="spring" and price=20.01
> db.books.find({$or:[{"name":"spring"},{"name":"java"}]}){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }{ "_id" : ObjectId("5b7d4a7f8e6123a7a302be28"), "name" : "java", "price" : 67.84 }
查询nam为spring或者java的书籍，格式为find({$or : [{},{}]}) 中括号里面填写每一个json格式的条件，类似select * form books where name="spring" or name="java" 
> db.books.find({"price":{$gte : 100}}){ "_id" : ObjectId("5b7d4a898e6123a7a302be29"), "name" : "linux", "price" : 289.78 }{ "_id" : ObjectId("5b7d4aad8e6123a7a302be2b"), "name" : "c++", "price" : 157.68 }
查询价格大于等于100的书籍。 
> db.books.find({"price":{$lte : 20}}){ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }
查询价格小于等于20的书籍。 
> db.books.find({"price":{$gte:100,$lte:200}}){ "_id" : ObjectId("5b7d4aad8e6123a7a302be2b"), "name" : "c++", "price" : 157.68 }
查询价格大于等于100并且小于等于200的书籍。 
> db.books.find({$or:[{"price":{$gt:200}},{"price":{$lt:20}}]}){ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d4a898e6123a7a302be29"), "name" : "linux", "price" : 289.78 }
查询价格大于200或者价格小于20的书籍，or的操作有点另类，一定要写在一开始的key上。 注意：gt为大于，gte为大于等于,lt为小于，lte为小于等于，e为equals。

​ 因为带提交查询的指令内容太多，上面这一部分主要是大于和小于，and和or的指令。下面是去重，正则的条件查询。

> db.books.insert({"name":"spring","price":22.05})
先插入一条name同为spring的文档 
> db.books.distinct("name")[ "spring", "springMvc", "java", "linux", "python", "c++" ]根据name去重，类似select distinct name from books 
> db.books.distinct("name",{"price":{$lt:30}})[ "spring", "springMvc", "python" ]
查询出价格小于30的书籍，然后根据name去重，类似select distinct name from books where price<30distinct命令和find类似，只不过多了一个去重功能。 
> db.books.find({"name":/spring/}){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 20.01 }{ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d58deabdfa1fbe797fa0b"), "name" : "spring", "price" : 22.05 }
使用正则表达式查询，/等同于%，类似select *from books where name like %spring%
> db.books.find({"name":/spring/}).skip(1).limit(2){ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d58deabdfa1fbe797fa0b"), "name" : "spring", "price" : 22.05 }
搜索后的分页查询，在搜索栏输入内容后的查询功能，类似select *from books where name like %spring% limit 1,2。正则表达式内容较多，具体可自己网上查询。
> db.books.find({},{"price":1}){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "price" : 20.01 }{ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "price" : 19.99 }{ "_id" : ObjectId("5b7d4a7f8e6123a7a302be28"), "price" : 67.84 }{ "_id" : ObjectId("5b7d4a898e6123a7a302be29"), "price" : 289.78 }{ "_id" : ObjectId("5b7d4a9f8e6123a7a302be2a"), "price" : 29.78 }{ "_id" : ObjectId("5b7d4aad8e6123a7a302be2b"), "price" : 157.68 }{ "_id" : ObjectId("5b7d58deabdfa1fbe797fa0b"), "price" : 22.05 }
只显示price列，格式find({},{key1:1,key2:1})，第一个{}表示查询的条件，第二个为显示的列信息，多个用逗号隔开，类似select price from books，但是_id它是必须显示的。
> db.books.find({},{"price":1}).sort({"price":1}){ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "price" : 19.99 }{ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "price" : 20.01 }{ "_id" : ObjectId("5b7d58deabdfa1fbe797fa0b"), "price" : 22.05 }{ "_id" : ObjectId("5b7d4a9f8e6123a7a302be2a"), "price" : 29.78 }{ "_id" : ObjectId("5b7d4a7f8e6123a7a302be28"), "price" : 67.84 }{ "_id" : ObjectId("5b7d4aad8e6123a7a302be2b"), "price" : 157.68 }{ "_id" : ObjectId("5b7d4a898e6123a7a302be29"), "price" : 289.78 }
查询后只显示price列，并且按照价格升序，类似select price from books order by price  
> db.books.find({},{"price":1}).sort({"price":-1})与上面相反，按价格降序。 
> db.books.find().count()7返回查询结果的总记录数。 
> db.books.findOne()查询第一条记录

18、 修改和删除指令：

> db.books.update({"name":"java"},{$set:{"name":"javase","price":50.01}})
把name为java的这条数据更新为name=javase和price=50.01。格式update({},{})，第一个{}为要更改的数据，第二个为要修改为什么数据。类似update books set name="javase" and price=50.01 where name="java"注意，如果存在多个name为java的则只修改一个，下面看如何更新多个。之前我们存在名为spring的书籍有两本。现在把这两本价格都修改为50.
> db.books.update({"name":"spring"},{$set : {"price":50}},{multi:true})
> db.books.find(){ "_id" : ObjectId("5b7d4a588e6123a7a302be25"), "name" : "spring", "price" : 50 }{ "_id" : ObjectId("5b7d58deabdfa1fbe797fa0b"), "name" : "spring", "price" : 50 }
结果为name为spring的都修改了，{multi:true}表示是否修改多行，默认是为false。
> db.books.remove({"name":"spring"})> db.books.find(){ "_id" : ObjectId("5b7d4a6b8e6123a7a302be27"), "name" : "springMvc", "price" : 19.99 }{ "_id" : ObjectId("5b7d4a898e6123a7a302be29"), "name" : "linux", "price" : 289.78 }{ "_id" : ObjectId("5b7d4a9f8e6123a7a302be2a"), "name" : "python", "price" : 29.78 }{ "_id" : ObjectId("5b7d4aad8e6123a7a302be2b"), "name" : "c++", "price" : 157.68 }
删除name为spring的书籍，默认是存在多少个就删除多少个，与update相反。 
> db.books.remove({}) 删除当前集合的所有数据，不要乱用。

19、 索引的操作指令：

> db.books.ensureIndex({"name":1,"price":-1}) 创建组合索引，mongodb会自动为索引创建名字，如果{}里面为一个，则为单个索引，多个就为组合索引，其中1和-1表示索引的方向。 
> db.books.ensureIndex({"price":1},{"name":"index_price"})创建一个索引，并指定索引的名字。 
> db.books.ensureIndex({"name":1},{"unique":true})为name创建一个唯一索引 
> db.books.getIndexes()查看当前集合中的索引信息。  
> db.system.indexes.find(){ "v" : 1, "key" : { "_id" : 1 }, "ns" : "test.student", "name" : "_id_" }{ "v" : 1, "key" : { "_id" : 1 }, "ns" : "test.books", "name" : "_id_" }{ "v" : 1, "key" : { "name" : 1, "price" : 1 }, "ns" : "test.books", "name" : "name_1_price_1" }{ "v" : 1, "key" : { "price" : 1 }, "ns" : "test.books", "name" : "index_price" }{ "v" : 1, "key" : { "name" : 1 }, "unique" : true, "ns" : "test.books", "name" : "name_1" }索引的信息存在每个数据库的system.indexes集合里面，这里是查看所有的索引信息，需要与上面区别开。 
> db.books.dropIndex("name_1"){ "nIndexesWas" : 4, "ok" : 1 }删除在books集合中索引名为name_1的索引 
> db.books.dropIndexes(){        "nIndexesWas" : 3,        "msg" : "non-_id indexes dropped for collection",        "ok" : 1}删除在books集合中的所有索引。 

​ 基础部分到此结束，下面部分的内容是关于mongodb的权限和用户的操作指令，以及语句块和在java中的使用。

20、MongoDB Java

springboot集成mongo

• 引入依赖

	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-mongodb</artifactId>
		</dependency>

• 配置文件，application.properties文件

server.port=8091

#数据库连接
spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=root

#mybatis配置
mybatis.type-aliases-package=com.congge.entity
mybatis.mapper-locations=classpath:mybatis/*.xml

#mongodb配置
spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.port=27017
spring.data.mongodb.database=enterprise_dc_db
spring.data.mongodb.username=enterprise_dc_dba
spring.data.mongodb.password=123456

• 创建实体类 【 @Document为mongodb集合名 】

package com.example.springbootmongodb.domian;

import org.springframework.data.mongodb.core.mapping.Document;

@Document(collection = "mydb")
@Data
public class Users {
    private String userId;
    private String name;
    private Integer age;
}
@Data
public class ResultObject {

    private int code;

    private String desc;

    private Object data;
}

• controller

  package com.example.springbootmongodb.controller;
  
  import com.example.springbootmongodb.domian.Users;
  import org.springframework.beans.factory.annotation.Autowired;
  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.web.bind.annotation.*;
  
  import java.util.List;
  
  @RequestMapping("/mongo")
  @RestController
  public class UserController {
  
      @Autowired
      private MongoTemplate mongoTemplate;
  
      @RequestMapping(value = "/hello",method = RequestMethod.GET)
      public String hello(){
          return "hello";
      }
  
      /**
       * 新增
       */
      @ResponseBody
      @RequestMapping(value = "/insert", method = RequestMethod.GET)
      public ResultObject insert(){
          Users user = new Users();
          user.setUserId("1002");
          user.setName("eric");
          user.setAge(18);
          mongoTemplate.insert(user);
      return new ResultObject(200);
      }
  
      /**删除
       *
       * @return
       */
      @ResponseBody
      @RequestMapping("/delete")
      public ResultObject delete(){
          Query query = Query.query(Criteria.where("userId").is("1001"));
          mongoTemplate.remove(query,"mydb");
          return new ResultObject(200);
      }
  
      /**
       * 修改
       * @return
       */
      @ResponseBody
      @RequestMapping("/update")
      public ResultObject update(){
          Query query = Query.query(Criteria.where("userId").is("1002"));
          Update update = new Update();
          update.set("name","name1");
          update.set("age",18);
          mongoTemplate.updateFirst(query,update,"mydb");
          return new ResultObject(200);
      }
  
      /**
       * 查询
       * @return
       */
      @ResponseBody
      @RequestMapping("/query")
      public ResultObject query(){
          Query query = Query.query(Criteria.where("userId").is("1001"));
          List<Users> list = mongoTemplate.find(query,Users.class);
          return new ResultObject(200,list);
      }
  }
  

21、mongodb权限相关指令

1.切换数据库

use admin

2.创建admin超级管理员用户

  db.createUser(  
    { user: "admin",  
      customData：{description:"superuser"},
      pwd: "admin",  
      roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]  
    }  
  )  

• 注意：

user字段，为新用户的名字；
pwd字段，用户的密码；
cusomData字段，为任意内容，例如可以为用户全名介绍；
roles字段，指定用户的角色，可以用一个空数组给新用户设定空角色。在roles字段,可以指定内置角色和用户定义的角色。
超级用户的role有两种，userAdmin或者userAdminAnyDatabase(比前一种多加了对所有数据库的访问,仅仅是访问而已)。
db是指定数据库的名字，admin是管理数据库。
不能用admin数据库中的用户登录其他数据库。注：只能查看当前数据库中的用户，哪怕当前数据库admin数据库，也只能查看admin数据库中创建的用户。

3.创建一个不受访问限制的超级用户【 (跳出三界之外，不在五行之中) 】

db.createUser(
    {
        user:"root",
        pwd:"pwd",
        roles:["root"]
    }
)

4.创建一个业务数据库管理员用户【 只负责某一个或几个数据库的増查改删 】

> db.createUser({
    user:"user001",
    pwd:"123456",
    customData:{
        name:'jim',
        email:'jim@qq.com',
        age:18,
    },
    roles:[
        {role:"readWrite",db:"db001"},
        {role:"readWrite",db:"db002"},
        'read'// 对其他数据库有只读权限，对db001、db002是读写权限
    ]
})

• 数据库用户角色：read、readWrite；

• 数据库管理角色：dbAdmin、dbOwner、userAdmin;

• 集群管理角色：clusterAdmin、clusterManager、4. clusterMonitor、hostManage；

• 备份恢复角色：backup、restore；

• 所有数据库角色：readAnyDatabase、readWriteAnyDatabase、userAdminAnyDatabase、dbAdminAnyDatabase

• 超级用户角色：root

• 内部角色：__system

• dbAdmin：允许用户在指定数据库中执行管理函数，如索引创建、删除，查看统计或访问system.profile

• userAdmin：允许用户向system.users集合写入，可以在指定数据库里创建、删除和管理用户

• clusterAdmin：只在admin数据库中可用，赋予用户所有分片和复制集相关函数的管理权限。

• readAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读权限

• readWriteAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的读写权限

• userAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限

• dbAdminAnyDatabase：只在admin数据库中可用，赋予用户所有数据库的dbAdmin权限。

• root：只在admin数据库中可用。超级账号，超级权限

5.查看创建的用户

show users 或 db.system.users.find() 或 db.runCommand({usersInfo:"userName"})

6.修改密码

use admin
db.changeUserPassword("username", "xxx")

7.修改密码和用户信息

db.runCommand(
    {
        updateUser:"username",
        pwd:"xxx",
        customData:{title:"xxx"}
    }
)

8.删除数据库用户

use admin
db.dropUser('user001')

9.创建其他数据管理员

// 登录管理员用户
use admin
db.auth('admin','admin')
// 切换至db001数据库
use db001
// ... 増查改删该数据库专有用户

10.重要的一步

启用权限验证
mongo --auth
或者修改mongo.conf，最后一行添加
auth=true

11.重新启动mongodb

net stop mongodb;
net start mongodb;

ps:

• 和用户管理相关的操作基本都要在admin数据库下运行，要先use admin;
• 如果在某个单一的数据库下，那只能对当前数据库的权限进行操作;
• db.addUser是老版本的操作，现在版本也还能继续使用，创建出来的user是带有root role的超级管理员。

12.更多操作可访问：

https://www.runoob.com/mongodb/mongodb-capped-collections.html