Mongodb基础与入门

一：基本了解
                1. 特点
                        基于分布式文件存储的NoSql数据库。能为WEB应用提供可扩展的高性能数据存储解决方案。
                        将数据存储为一个文档，数据结构由键值对组成。文档类似于JSON对象。字段值可以包含其他文档，数组以及文档数组。

                2. 启动HTTP用户界面，需指定参数--rest    $ ./mongod --dbpath=/data/db --rest    【Web界面访问端口比服务端口多1000】

                3.  基本概念：文档，集合，数据库
                        数据库：database    数据表/集合：collection    数据记录行/文档：document
                        数据字段/域：field     索引:index    主键：primary key  自动将_id字段设为主键
                        不支持表链接
                4. 一个mongodb可建立多个数据库。默认数据库为db（存储在data目录中），MongoDB的单个实例可以容纳多个独立的数据库，每一个都有自己的集合和权限，不同的数据库也放置在不同的文件中。

        二：基础命令

                1. 命令
                        显示所有数据库列表：show dbs
                        显示当前数据库集合或对象：db
                        连接到指定数据库：use 数据库名
                                  数据库可通过名字标识。数据库名可以是满足以下条件的任意UTF-8字符串。
                                            （1）不能是空字符串( " " )
                                            （2）不能含有空格，点（.），$，/，\和\0 (空字符)
                                            （3）全部为小写
                                            （4）最多为64字节
                                  特殊数据库：
                                            （1）admin
                                                    权限上这是root数据库。若添加一个用户则此用户自动继承所有数据库的权限
                                            （2）local
                                                    永远不会被复制的数据库。可以用来存储限于本地单台服务器的任意集合
                                            （3）config
                                                    当Mongo用于分片设置时，在内部使用，用于保存分片的相关信息。
                2. 文档
                        一组键值对（即BSON）。
                        不需要设置相同的字段，且相同的字段不需要相同的数据类型。
                        注意：
                                （1）键值对是有序的
                                （2）值不仅可以是字符串，还可以是其他几种数据类型
                                （3）区分类型和大小写
                                （4）不能有重复的键
                                （5）键一般为任意UTF-8字符串
                        键命名规范：        
                                （1）不能含有空字符\0，？？？这个字符用来表示键的结尾。
                                （2）.和$有特殊意义，只能在特定环境下使用
                                （3）？？？以下划线 "_" 开头的键是保留的
                3. 集合
                        文档组，类似于表格。
                        存储在数据库中，没有固定的结构。可插入不同格式和类型的数据，但通常插入集合的数据会有一定的关联性
                        插入第一个文档时，集合就会被创建
                        集合命名规范：
                                （1）不能是空字符串
                                （2）不能含有空字符\0，？？？这个字符用来表示集合名的结尾。
                                （3）不能以 "system."开头，这是为系统保留的前缀
                                （4）不能含有保留字符。访问系统创建的集合需要在名字里出现 $
                4. capped collections
                        有很高的性能以及队列过期的特性(过期按照插入的顺序)
                        是高性能自动的维护对象的插入顺序。适合类似记录日志功能
                        需显示创建并指定一个collection的大小（包含了数据的头信息），单位为字节。collection的数据存储空间值提前分配
                        注意：
                                可添加新的对象，但对象不会增加存储空间
                                可进行更新，如果新添的对象增加存储空间，更新失败
                                不允许进行删除。drop()删除collection所有的行【删除后须显示的重新创建这个collection】
                                在32bit机器中，最大存储为1e9( 1X109)个字节。
                5. 元数据
                        数据库的信息是存储在集合中的。使用系统的命名空间：dbname.system.*
                        dbname.system.* 是包含多种系统信息的特殊集合。例： dbname.system.namespaces        列出所有名字的空间
                                                                                                                          dbname.system.indexes               列出所有索引
                                                                                                                          dbname.system.profile                包含数据库概要(profile)信息
                                                                                                                          dbname.system.uses                     列出所有可访问数据库的用户
                                                                                                                          dbname.local.sources                   包含复制对端（slave）的服务器信息和状态
                        注意：修改系统集合的对象限制
                                在{{system.indexes}}插入数据，可以创建索引。但除此之外该表信息是不可变的(特殊的drop index命令将自动更新相关信息)。
                                {{system.users}}是可修改的。 {{system.profile}}是可删除的。
                6.常用数据类型
                                String：UTF-8 编码的字符串，存储数据常用的数据类型
                                Integer：存储数值
                                Boolean：存储布尔值
                                Double：存储（双精度）浮点值
                                Min/Max keys：将一个值与 BSON（二进制的 JSON）元素的最低值和最高值相对比。
                                Arrays：将数组或列表或多个值存储为一个键
                                Timestamp：时间戳，记录文档修改或添加时间
                                Object：用于内嵌文档
                                Null：创建空值
                                Symbol：采用特殊符号类型
                                Date：使用UNIX时间格式存储当前日期或时间，可自己指定
                                Object ID：创建文档的ID
                                Binary Data：存储二进制数据
                                Code：用于在文档中存储JavaScript代码
                                Regular expression：存储正则表达式

                7. 连接[Mongodb Shell 连接]
                        连接语法：
                                mongodb://[username:password@] host1 [:port1] [, host2 [:port2]] [/[database] [?options] ]
                        PS：
                                mongodb://    固定格式，必须指定
                                [username:password@]      如果设置，在连接数据库服务器之后，驱动都会尝试登陆这个数据库
                                host1      至少指定一个host[要连接的服务器的地址]，如果连接复制集，请指定多个主机地址
                                portX      可选的指定端口，默认为27017
                                /database   如果指定username:password@，连接并验证登陆指定数据库。若不指定，默认打开admin数据库。  
                                ?options      如果不使用/database，则前面需要加上/。所有连接选项都是键值对name=value，键值对之间通过&或;（分号）隔开
                                   例：
                                        replicaSet = name        
                                        slaveOk = true | false
                                        safe = true | false
                                        w = n
                                        wtimeoutMS = ms
                                        fsync = true | false
                                        journal = true | false
                                        connectTimeoutMS = ms
                                        socketTimeoutMS = ms
                8. 操作
                        创建数据库语法格式：
                                use 数据库名        如果不存在则创建数据库，否则切换到指定数据库

                        删除数据库语法格式：
                                db.dropDatabase()        删除当前数据库，默认为test  可使用 db 命令查看当前数据库名

                        插入文档语法格式：[ 使用 insert() 或 save() 方法向集合中插入文档]
                                db.COLLECTION_NAME.insert(document)
                                db.col.save(document)       不指定_id字段，save() 类似于insert()  指定则会更新该_id的数据

                        更新文档语法格式：[使用 update() 和 save() 方法来更新集合中的文档。update() 用于更新已存在的文档，save() 通过传入的文档来替换已有的文档]
                                        db.collection.update{
                                                <query>,
                                                <update>,
                                                    {
                                                        update:<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：抛出异常的级别。

                                    db.collection.save{
                                            <document>,
                                            {
                                                    writeConcern:<document>
                                            }
                                    
                                    }
                                参数说明：
                                        document：文档数据
                                        writeConcern：抛出异常的级别

                        删除文档语法格式：【在执行remove()函数前先执行find()命令来判断执行的条件是否正确，这是一个比较好的习惯。】
                                        db.collection.remove{
                                                <query>,
                                                <justOne>
                                        }
                                        2.6版本之后：
                                        db.collection.remove{
                                                <query>,
                                                {
                                                    justOne:<boolean>,
                                                    writeConcern:<document>
                                                }
                                        }
                                        参数说明：
                                                query：删除的文档的条件。
                                                justOne：如果设为 true 或 1，则只删除一个文档。
                                                writeConcern：抛出异常的级别。
                                        删除全部：
                                                db.col.remove( { } )
                                                db.col.find(  )

                        查询文档语法格式：【find() 以非结构化的方式显示所有文档，findOne() 只返回一个文档】
                                        db.collection.find(query,projection)
                                        参数说明:
                                                 query：使用查询操作符指定查询条件
                                                 projection：使用投影操作符指定返回的键。查询时返回文档中所有键值， 只需省略该参数即可（默认省略）
                                        易读方式读取数据：db.col.find().pretty()
                                                 pretty()：以格式化的方式显示所有文档
                                                         例：db.col.find().pretty()     以易读的方式读取数据

                    条件操作符：
                            1. where
                                     等于
                                             格式： {<key> : <value>}
                                             例：db.col.find( {"by" : "兔兔"} ).pretty()         
                                     小于【 lt -- less than 】
                                             格式： {<key> : {$lt : <value>} }
                                             例：db.col.find( {"by" : {$lt : 50} } ).pretty()
                                     小于等于【 lte -- less than equal】
                                             格式： {<key> :  {$lte : <value>} }
                                             例：db.col.find( {"by" : {$lte : 50} } ).pretty()
                                     大于【 gt -- greater than 】
                                             格式： {<key> : {$gt : <value>} }
                                             例：db.col.find( {"by" : {$gt : 50} } ).pretty()
                                     大于等于【 gte -- greater than equal】
                                             格式： {<key> :  {$gte : <value>} }
                                             例：db.col.find( {"by" :  {$gte : 50} } ).pretty()
                                     不等于【 ne -- not equal 】
                                             格式： {<key> :  {$ne : <value>} }
                                             例：db.col.find( {"by" :  {$ne : 50}} ).pretty()
                            2. and
                                     find() 方法可以传入多个键(key)，每个键(key)以逗号隔开
                                     格式：
                                             db.col.find( { key1 : value1 , key2 : value2 } ).pretty()
                                     例：db.col.find( { likes : {$lt : 200, $gt : 100 } } )        相当于： Select * from col where likes > 100 AND  likes < 200 ;
                            3. or
                                     格式：
                                             db.col.find( { $or : [ { key1 : value1 }, { key2 : value2 } ] } ).pretty()
                            4. and 和 or
                                     例：
                                             db.col.find( { "by" : "兔兔" }, $or : [ { "by" : "开心的", {"title" : "睡觉"} } ] ).pretty()
                            5. $type操作符：基于BSON类型检索集合中匹配的数据类型并返回结果。
                                     MongoDB中可以使用的类型：
                                     例：
                                             db.col.find( { "by" : { $type : 2 } } )         获取 "col" 集合中 title 为 String 的数据
                            6. limit()：读取指定数量的数据记录。接受一个数字参数，该参数指定从MongoDB中读取的记录条数
                                     基本语法：
                                             db.COLLECTION_NAME.find().limit(NUMBER)
                                     例：
                                             db.col.find({},{"title":1,_id:0}).limit(2)     
                                                     补充：第一个 {} 放 where 条件，为空表示返回集合中所有文档。
                                                                 第二个 {} 指定那些列显示和不显示 （0表示不显示 1表示显示)。    
                            7. skip()：跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数
                                     基本语法：
                                             db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
                                     例：
                                             db.col.find({},{"title":1,_id:0}).limit(1).skip(1)
                                                    补充：skip 和 limit 结合就能实现分页
                                                                当查询时同时使用sort,skip,limit，无论位置先后 最后执行顺序 sort再skip再limit
                            8. sort()：对数据进行排序。可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。
                                     基本语法：
                                             db.COLLECTION_NAME.find().sort({KEY:1})
                                     例：
                                             db.COLLECTION_NAME.find().sort({KEY:1})
                            9. ensureIndex()：创建索引
                                     基本语法：
                                             db.COLLECTION_NAME.ensureIndex({KEY:1})                      --  Key 值为你要创建的索引字段，1为指定按升序创建索引
                                     例：
                                             db.col.ensureIndex({"title":1})                                                    --创建单个索引     
                                             db.col.ensureIndex({"title":1,"description":-1})                        -- 创建多个索引         
                                     可选参数：
                                             （1）background
                                                     boolean类型。
                                                     建索引过程会阻塞其它数据库操作，background可指定以后台方式创建索引，默认值为false
                                             （2）unique
                                                     boolean类型。
                                                     建立的索引是否唯一。指定为true创建唯一索引。默认值为false
                                             （3）name
                                                     string类型。
                                                     索引的名称。如果未指定，MongoDB的通过连接索引的字段名和排序顺序生成一个索引名称
                                             （4）dropDups
                                                     boolean类型。
                                                     在建立唯一索引时是否删除重复记录,指定 true 创建唯一索引。默认值为 false
                                             （5）sparse
                                                     boolean类型。
                                                     对文档中不存在的字段数据不启用索引。如果设置为true的话，在索引字段中不会查询出不包含对应字段的文档.。默认值为 false
                                             （6）expireAfterSeconds
                                                     integer类型。
                                                     指定一个以秒为单位的数值，完成 TTL设定，设定集合的生存时间
                                             （7）v
                                                     索引的版本号。默认的索引版本取决于mongod创建索引时运行的版本
                                             （8）weights
                                                     document类型。
                                                     索引权重值，数值在 1 到 99,999 之间，表示该索引相对于其他索引字段的得分权重
                                             （9）default_language
                                                     string类型。
                                                     对于文本索引，该参数决定了停用词及词干和词器的规则的列表。 默认为英语
                                             （10）language_override
                                                     string类型。
                                                     对于文本索引，该参数指定了包含在文档中的字段名，语言覆盖默认的language，默认值为 language
                                               例：
                                                       db.values.ensureIndex({open: 1, close: 1}, {background: true})
                    10. aggregate()：处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。类似于sql语句中的 count(*)
                             基本语法：
                                     db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
                             聚合表达式：
                                     （1）$sum 【计算总和】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , num : { $sum : "likes" }} } ] )        --根据 name 分组 并求 likes 的和
                                     （2）$avg【计算平均值】
                                              例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , num : { $avg : "likes" }} } ] )        --根据 name 分组 并求 likes 的平均值
                                     （3）$min【获取集合中所有文档对应值得最小值】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , num : { $min : "likes" }} } ] )        --根据 name 分组 并求 likes 的最小值
                                     （4）$max【获取集合中所有文档对应值得最大值】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , num : { $max : "likes" }} } ] )        --根据 name 分组 并求 likes 的最大值
                                     （5）$push【在结果文档中插入值到一个数组中】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , url : { $push : "$url" }} } ] )        --根据 name 分组 并插入值到数组中
                                     （6）$addToSet【在结果文档中插入值到一个数组中，但不创建副本】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , url : { $addToSet : "$url" }} } ] )        --根据 name 分组 并插入值到数组中但不创建副本
                                     （7）$first【根据资源文档的排序获取第一个文档数据】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , first_url : { $first : "$url" }} } ] )        --根据 name 分组 并获取第一个数据
                                     （8）$last【根据资源文档的排序获取最后一个文档数据】
                                             例：
                                                     db.col.aggregate( [ { $group : { _id : "name" , last_url : { $last : "$url" }} } ] )        --根据 name 分组 并获取最后一个数据

                    11. 管道
                             概念：在Unix和Linux中一般用于将当前命令的输出结果作为下一个命令的参数。
                                          MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
                                          表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。
                             聚合框架中常用操作：
                                     $project:修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档
                                     $match:用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作
                                     $limit:用来限制MongoDB聚合管道返回的文档数
                                     $skip:在聚合管道中跳过指定数量的文档，并返回余下的文档
                                     $unwind:将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值
                                     $group:将集合中的文档分组，可用于统计结果
                                     $sort:将输入文档排序后输出
                                     $gepNear:输出接近某一地理位置的有序文档
                                     例：
                                             db.article.aggregate(
                                                     { $project : {
                                                             title : 1 ,
                                                             author : 1 ,
                                                     }}
                                             );                                    --   默认情况下_id字段是被包含的

                                             db.article.aggregate(
                                                     { $project : {
                                                             title : 1 ,
                                                             author : 1 ,
                                                     }}
                                             );                                    --   不包含_id字段

                                             db.article.aggregate(
                                                     { $skip : 5 }
                                             );                                    --   跳过前五个文档

                    12. 复制（副本集）
                             概念：将数据同步在多个服务器的过程。
                             优点：提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性， 并可以保证数据的安全性。还允许从硬件故障和服务中断中恢复数据。
                             原理：
                                     mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。
                                     mongodb各个节点常见的搭配方式为：一主一从、一主多从。主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据
                                     副本执行这些操作，从而保证从节点的数据与主节点一致。
                             结构图：

                                     客户端总主节点读取数据，在客户端写入数据到主节点是， 主节点与从节点进行数据交互保障数据的一致性。
                             副本集特征：
                                     （1）N个节点的集群
                                     （2）任何节点可作为主节点
                                     （3）所有写入操作都在主节点上
                                     （4）自动故障转移
                                     （5）自动恢复
                                     例一：使用同一个MongoDB来做MongoDB主从的副本集设置及成员的添加
                                             1. 关闭正在运行的MongoDB服务器
                                             2. 通过指定 --replSet 选项来启动mongoDB。
                                                     【--replSet基本格式：
                                                             mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"
                                                        --rs.add基本格式：
                                                             rs.add(HOST_NAME : PORT)
                                                     】
                                                mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0        --启动一个名为rs0的MongoDB实例，其端口号为27017。启动后打开命令提示框并连接上mongoDB服务
                                                rs.initiate()                         --    在客户端启动一个新的副本集
                                                rs.conf()                              --    查看副本集配置
                                                rs.status                              --    查看副本集状态
                                             3. 添加成员
                                                     需要使用多条服务器来启动mongo服务。进入Mongo客户端，并使用rs.add()方法来添加副本集的成员。
                                                             rs.add(" mongod1.net : 27017 ")                        --  将启动了的mongod1.net，端口号为27017的Mongo服务。 在客户端命令窗口使用rs.add() 命令将其添加到副本集中。
                                                    PS：
                                                            （1）在MongoDB中只能通过主节点将Mongo服务添加到副本集中， 判断当前运行的Mongo服务是否为主节点可以使用命令db.isMaster()
                                                            （2）MongoDB的副本集与我们常见的主从有所不同，主从在主机宕机后所有服务将停止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的情况

                    13. 分片
                             概念：当MongoDB存储海量的数据时，我们可以通过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据
                             为什么使用分片：
                                     （1）复制所有的写入操作到主节点
                                     （2）延迟的敏感数据会在主节点查询
                                     （3）单个副本集限制在12个节点
                                     （4）当请求量巨大时会出现内存不足
                                     （5）本地磁盘不足
                                     （6）垂直扩展价格昂贵
                             分片集群结构分布：

                             主要组件：
                                     （1）Shard
                                             用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障
                                     （2）Config Server
                                             mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息
                                     （3）Query Routers
                                             前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用可以透明使用
                             例：
                                     分片结构端口分布如下：

                                             Shard Server 1：27020
                                             Shard Server 2：27021
                                             Shard Server 3：27022
                                             Shard Server 4：27023
                                             Config Server ：27100
                                             Route Process：40000

                                     步骤一：启动Shard Server

                                              [root@100 /]# mkdir -p /www/mongoDB/shard/s0
                                              [root@100 /]# mkdir -p /www/mongoDB/shard/s1
                                              [root@100 /]# mkdir -p /www/mongoDB/shard/s2
                                              [root@100 /]# mkdir -p /www/mongoDB/shard/s3
                                              [root@100 /]# mkdir -p /www/mongoDB/shard/log
                                              [root@100 /]# /usr/local/mongoDB/bin/mongod --port 27020 --dbpath=/www/mongoDB/shard/s0 --logpath=/www/mongoDB/shard/log/s0.log --logappend --fork
                                              ....
                                              [root@100 /]# /usr/local/mongoDB/bin/mongod --port 27023 --dbpath=/www/mongoDB/shard/s3 --logpath=/www/mongoDB/shard/log/s3.log --logappend --fork

                                     步骤二： 启动Config Server
                                            
                                                [root@100 /]# mkdir -p /www/mongoDB/shard/config
                                                [root@100 /]# /usr/local/mongoDB/bin/mongod --port 27100 --dbpath=/www/mongoDB/shard/config --logpath=/www/mongoDB/shard/log/config.log --logappend --fork

                                     步骤三： 启动Route Process
                                         
                                                /usr/local/mongoDB/bin/mongos --port 40000 --configdb localhost:27100 --fork --logpath=/www/mongoDB/shard/log/route.log --chunkSize 500

                                     步骤四： 配置Sharding

                                             [root@100 shard]# /usr/local/mongoDB/bin/mongo admin --port 40000
                                             MongoDB shell version: 2.0.7
                                             connecting to: 127.0.0.1:40000/admin
                                             mongos> db.runCommand({ addshard:"localhost:27020" })
                                             { "shardAdded" : "shard0000", "ok" : 1 }
                                             ......
                                             mongos> db.runCommand({ addshard:"localhost:27029" })
                                             { "shardAdded" : "shard0009", "ok" : 1 }
                                             mongos> db.runCommand({ enablesharding:"test" })                 #设置分片存储的数据库
                                             { "ok" : 1 }
                                             mongos> db.runCommand({ shardcollection: "test.log", key: { id:1,time:1}})
                                             { "collectionsharded" : "test.log", "ok" : 1 }

                                     步骤五： 程序代码内无需太大更改，直接按照连接普通的mongo数据库那样，将数据库连接接入接口40000

                    14. 数据备份与恢复
                             备份：【mongodump】
                                     在Mongodb中我们使用mongodump命令来备份MongoDB数据。该命令可以导出所有数据到指定目录中，还可以通过参数指定导出的数据量级转存的服务器。
                                     基本语法：
                                             mongodump -h dbhost -d dbname -o dbdirectory
                                             参数详解：
                                             -h ：MongDB所在服务器地址，例如：127.0.0.1，当然也可以指定端口号：127.0.0.1:27017
                                             -d ：需要备份的数据库实例，例如：test
                                             -o ：备份的数据存放位置，例如：c:\data\dump，当然该目录需要提前建立，在备份完成后，系统自动在dump目录下建立一个test目录，这个目录里面存放该数据库实例的备份数据
                                     mongodump --host HOST_NAME --port PORT_NUMBER                     --备份所有MongoDB数据
                                     mongodump --collection COLLECTION --db DB_NAME                        --备份指定数据库的集合
                                     mongodump --dbpath DB_PATH --out BACKUP_DIRECTORY              --
                             恢复：【mongorestore 】
                                     基本语法：
                                             mongorestore -h <hostname><:port> -d dbname <path>
                                             参数详解：
                                             --host <:port>, -h <:port>：MongoDB所在服务器地址，默认为： localhost:27017
                                             --db , -d ：需要恢复的数据库实例
                                             --drop：恢复的时候，先删除当前数据，然后恢复备份的数据。就是说，恢复后，备份后添加修改的数据都会被删除，
                                             <path>： mongorestore 最后的一个参数，设置备份数据所在位置，例如：c:\data\dump\test。你不能同时指定 <path> 和 --dir 选项，--dir也可以设置备份目录
                                             --dir：指定备份的目录

                    15. 监控
                             【mongstat】
                                      mongodb自带的状态检测工具，在命令行下使用。它会间隔固定时间获取mongodb的当前运行状态，并输出。
                                     作用：了解MongoDB的运行情况，并查看MongoDB的性能。
                                     例：
                                             D:\set up\mongodb\bin>mongostat   
                                             输出结果：
                            【 mongotop】
                                     mongodb下的一个内置工具。mongotop提供了一个方法，用来跟踪一个MongoDB的实例，查看哪些大量的时间花费在读取和写入数据。
                                     也提供每个集合的水平的统计数据。默认情况下，mongotop返回值的每一秒。
                                     例：
                                             E:\mongodb-win32-x86_64-2.2.1\bin>mongotop <sleeptime> --locks
                                             输出结果：
                                             参数详解：
                                                     <sleeptime>：等待的时间长度，以秒为单位，mongotop等待调用之间。通过的默认mongotop返回数据的每一秒
                                                     --locks：报告每个数据库的锁的使用中
                                             输出结果字段说明：
                                                     ns：包含数据库命名空间，后者结合了数据库名称和集合
                                                     db：包含数据库的名称。名为 . 的数据库针对全局锁定，而非特定数据库
                                                     total：mongod花费的时间工作在这个命名空间提供总额
                                                     read：提供了大量的时间，这mongod花费在执行读操作，在此命名空间
                                                     write：提供这个命名空间进行写操作，这mongod花了大量的时间