MongoDB

数据库

1. 使用数据库

use <dbname>
如果数据库不存在，则创建数据库，否则切换到指定数据库

2. 查看数据库

show dbs

3. 添加数据

db.<dbname>.insert({"name":"Wang"})

4. 删除数据库

`db.dropDatabase()`
 删除当前数据库，默认为test
**实例**

```
show dbs
use test
db.test.insert({"name":"Wang"})
db.dropDatabase()
```
删除集合
`db.collection.drop()`
**实例**

```
db.name.drop()
```

5. 插入文档

```
db.COLLECTION_NAME.insert(document)
```
**实例**

```
db.col.insert({
name:wang,
age:20,
likes:["python","NoSql"]
})
```
查询插入文档

```
db.dol.find()
```
通过变量插入数据

```
doc=({
    name:wang,
    age:20,
    likes:["python","NoSql"]
})
db.col.insert(doc)
```

6. 更新文档

```
    db.collection.update(
        <query>,
        <update>,{
        upsert:<boolean>,
        multi:<boolean>,
        writeConcern:<document> 
        }
    )
```
参数说明：
    query:update的查询条件，类似sql中的where后面的内容。
    update:update的更新对象，类似sql中的set后面的内容。
    upsert:如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入，可选。
    multi:mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新，可选。
    writeConcern:抛出异常的级别，可选。

    **实例**
    ```
    db.col.insert({
        name:wang,
        age:20,
        likes:["python","NoSql"]
    })
    db.col.update(
        {"name":"wang"},{$set:{"name":"WANG"}}
    )
    //查看结果
    db.col.find().pretty()
    ```
    如果需要多条相应记录更新，应使用multi:true。
    ```
    db.col.update(
        {"name":"wang"},{$set:{"name":"WANG"}},{multi:true}
        )
    ```
save()方法
```
db.collection.save(
    <document>,{
        writeConcern:<document>
    }
)
```
参数说明：
    document:文档数据。
    weiteConcern:抛出异常的级别，可选。
    **实例**
    ```
    db.col.save({
        "name":"wang",
        "age":40
        })
    db.col.find().pretty()
    ```
    更新第一条
    ```
    db.col.update({"name":"wang"},{$set:{"name":"WANG"}})
    db.col.update({"name":"wang"},{$set:{"name":"WANG"}},false,false)
    ```
    全部更新
    ```
    db.col.update({"name":"wang"},{$set:{"name":"WANG"}},false,ture)
    ```
    只添加一条
    ```
    db.col.update({"name":"wang"},{$set:{"name":"WANG"}},true,flase)
    ```
    全部添加加进去
    ```
    db.col.update({"name":"wang"},{$set:{"name":"WANG"}},true,true)
    ```
    全部更新
    ```
    db.col.update({"name":"wang"},{$set:{"name":"WANG"}},false,true)
    ```

7. 删除文档

```
db.collection.remove(
    <query>,
    <justOne>
    )
    db.collection.remove(
        <query>,
        {
            justOne:<boolean>,
            writeConcern:<document>
        }
        )
```
参数说明：
    query:删除文件条件，可选。
    justOne:如果设为true或者1，那么只删除一个文档，可选
    writeConcern:抛出异常的级别，可选。
    **实例**
    ```
    db.col.insert({
        name:wang,
        age:20,
        likes:["python","NoSql"]
    })
    db.col.remove({"name":"wang"})
    ```
删除第一条找到的记录
```
db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)
```
删除所有数据
```
db.col.remove()
```

8. 查询文档

```
db.collection.find(query, projection)
```
参数说明：
    query:使用查询，可选。
    projection:使用投影操作符指定返回的键。查询是返回文档中所有的键，只需要省略参数(默认省略)，可选
如果需要让返回结果更易读，可使用pretty()
```
db.col.find().pretty()
```
**实例**
等于
```
db.col.find({<key>:<value>})
db.col.find({"name":"wang"}).pretty()
```
小于
```
db.col.find({<key>:{$lt:<value>}})
db.col.find({"age":{$lt:20}}).pretty()
```
小于等于
```
db.col.find({<key>:{$lte:<value>}})
db.col.find({"age":{$lte:20}}).pretty()
```
大于
```
db.col.find({<key>:{$gt:<value>}})
db.col.find("age":{$gt:20}).pretty()
```
大于等于
```
db.col.find({<key>:{$gte:<value>}})
db.col.find({"age":{$gte:20}}).pretty
```
不等于
```
db.col.find({<key>:{$ne:<value>}})
db.col.find({"age":{$ne:20}}).pretty
```
AND条件
```
db.col.find({<key>:<value>,<key2>:<value2>}).pretty()
db.col.find("age":"20","name":"wang")
```
OR条件
```
db.col.find({$or:[
    {<key>:<value>},{<key2>:<value2>}]
    }
    ).pretty()

db.dol.find({$or:[{"name":"wang"},{"age":"20"}]}).pretty()
```
AND 和 OR 联合使用
```
db.col.find({"age": {$gt:20}, $or: [{"name": "wang"},{"like": "MongoDB"}]}).pretty()
```

9. 条件操作符

(>)大于 $gt
(>=)大于等于 $gte
(<)小于 $lt
(<=)小于等于 $lte
```
db.col.insert({
    name:"wang",
    age:20
    })
db.col.insert({
    name:"li",
    age:18
    })
db.col.insert({
    name:"zhao",
    age:24
    })
//大于
db.col.find({"age":{$gt:20}})
//大于等于
db.col.find({"age":{$gte:20}})
//小于
db.col.find({"age":{$lt:20}})
//小于等于
db.col.find({"age":{$lte:20}})
//使用大于小于查询  $lt 和 $gt
db.col.find({age:{$lt:30,$gt:20}})
```

10. $type操作符

类型	数字
Double	1
String	2
Object	3
Array	4
Binary data	5
Boolean	8
Object id	7
Date	9
Null	10


db.col.find({"name":{$type:2}})

11. Limit()与Skip()

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

实例

db.col.find({},{"name":wang}).limit(1)

limit()方法中的参数不设置，则返回全部数据。
limit()方法用来返回一定数量的结果。

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

实例

db.col.find({},{"name":"wang"}).limit(1).skip(1)

skip()方法默认参数0。
使用skip()方法来跳过指定数量的数据，skip()同样接收一个数字参数作为跳过的记录条数。
实例

//读取从100条记录后的100条数据
db.COLLECTION_NAME.find().skip(100).limit(100)


12. 排序

```
db.COLLECTION_NAME.find().sort({<key>:1})
```
sort()方法可以通过参数指定排序的字段，并使用1和-1来指定排序方式，1升序、-1降序
```
db.col.find({},{"name":1}).sort("age":-1)
```

13. 索引

索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。
```
db.COLLECTION_NAME.ensureIndex({<key>:1})
```
key：创建的索引字段。
1：为指定按升序创建索引，-1则是降序创建索引
**实例**
```
db.col.ensureIndex({"name":1})
//使用多个字段创建索引
db.col.ensureIndex({"name":1,"age":1})
```

14. 聚合

类似sql中的COUNT(*)

db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

实例

db.col.aggredate([{$group:{_id:"$age",num_tutorial:{$sum:1}}}])
//类似与
select age,count(*) from col group by age


//求和
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$sum:"$age"}}}])
//平均值
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$avg:"$age"}}}])
//获取集合中所有文档对应值的最大值
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$max:"$age"}}}])
//获取集合中所有文档对应值的最小值
db.col.aggregate([{$group:{_id:"$age",num_tutorial:{$min:"$age"}}}])
//在结果文档中插入一个值到数组中
db.col.aggregate([{$group:{_id:"$age",url:{$push:"$url"}}}])
//根据文档的排序获取一个文档数据
db.col.aggregate([{$group:{_id:"$age",first_url:{$first:"$url"}}}])
//根据文档的排序获取最后一个文档数据
db.col.aggregate([{$group:{_id:"$age",last_url:{$last:"$url"}}}])

管道概念
管道在Unix和Linux中一般用于前一个命令的输出结果作为下一个命令的参数。
MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。
$match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
$limit：用来限制MongoDB聚合管道返回的文档数。$skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
$unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。$group：将集合中的文档分组，可用于统计结果。
$sort：将输入文档排序后输出。

```
db.article.aggregate(
    {$project:(
     title:1,
     author:1,)
    })
db.articles.aggregate([
    {$match :{score : {$gt :70,$lte:90}}},
    {$group :{_id:null,count:{$sum:1}}}
    ])
db.article.aggregate({
    $skip:5
    })
```

18. 复制

mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。
mongodb各个节点常见的搭配方式为：一主一从、一主多从。
主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。
特征
多个节点的集群
任何节点都可以做主节点
所有写入操作都在主节点上
自动故障一处
自动恢复

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"
rs.add(HOST_NAME:PORT)


19. 备份与恢复

 ```
 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目录，这个目录里面存放该数据库实例的备份数据。

实例
进入Mongodb安装目录用命令行输入

mongodump
//备份所有mongoDB数据
mongodump --host HOST_NAME --port PORT_NUMBER
//被封制定数据库的集合
mongodump --collection COLLECTION --db DB_NAME

恢复

mongorestore -h <hostname><:port> -d dbname <path>

参数说明：
–host <:port>, -h <:port>：MongoDB所在服务器地址，默认为： localhost:27017。
–db, -d：需要回复的数据库实例。
–drop：回复的时候，先删除当前数据，然后恢复备份的数据，恢复后，备份后添加修改的数据会销毁，谨慎使用。
：mongorestore的最后一个参数，设置备份数据所在位置，不能懂事制定和–dir选项,–dir 也可以设置备份目录。
–dir：指定备份的目录，不能同时指定和–dir选项。
实例
进入Mongodb安装目录用命令行输入

mongorestore

20. 监控
MongoDB中提供了mongostat 和 mongotop 两个命令来监控MongoDB的运行情况。
mongostat 命令
进入Mongodb安装目录用命令行输入mongostat

mongostat

mongotop 命令
进入Mongodb安装目录用命令行输入mongotop
输出结果参数说明：
ns:数据库命名空间，结合数据库名称和集合。
db:数据库名称。
total:mongod话费的时间工作，在这个操作过程中。
read:提供了大量的时间，这mongod花费在执行读操作，在此命名空间。
write:提供这个命名空间进行写操作，这mongod花了大量的时间。
21. MongoDB JDBC
驱动下载http://mongodb.github.io/mongo-java-driver/
“`
//链接数据库
import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
           // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");  
           System.out.println("Connect to database successfully");

          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }
    //账号密码登陆
    import java.util.ArrayList;  
    import java.util.List;  
    import com.mongodb.MongoClient;  
    import com.mongodb.MongoCredential;  
    import com.mongodb.ServerAddress;  
    import com.mongodb.client.MongoDatabase;  

    public class MongoDBJDBC {  
        public static void main(String[] args){  
            try {  
                //连接到MongoDB服务,如果是远程连接可以替换“localhost”为服务器所在IP地址  
                //ServerAddress()两个参数分别为 服务器地址 和 端口  
                ServerAddress serverAddress = new ServerAddress("localhost",27017);  
                List<ServerAddress> addrs = new ArrayList<ServerAddress>();  
                addrs.add(serverAddress);  

                //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码  
                MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());  
                List<MongoCredential> credentials = new ArrayList<MongoCredential>();  
                credentials.add(credential);  

                //通过连接认证获取MongoDB连接  
                MongoClient mongoClient = new MongoClient(addrs,credentials);  

                //连接到数据库  
                MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");  
                System.out.println("Connect to database successfully");  
            } catch (Exception e) {  
                System.err.println( e.getClass().getName() + ": " + e.getMessage() );  
            }  
        }  
    } 
    //创建集合
    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoDatabase;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
          // 连接到 mongodb 服务
          MongoClient mongoClient = new MongoClient( "localhost" , 27017 );


          // 连接到数据库
          MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
          System.out.println("Connect to database successfully");
          mongoDatabase.createCollection("test");
          System.out.println("集合创建成功");

          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }
    //获取集合
    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoDatabase;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
           // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
           System.out.println("Connect to database successfully");

           MongoCollection<Document> collection = mongoDatabase.getCollection("test");
           System.out.println("集合 test 选择成功");
          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }
    //插入文档
    import java.util.ArrayList;
    import java.util.List;
    import org.bson.Document;

    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoDatabase;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");

             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");
             //插入文档  
             /** 
             + 1. 创建文档 org.bson.Document 参数为key-value的格式 
             + 2. 创建文档集合List<Document> 
             + 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document) 
             + */
             Document document = new Document("title", "MongoDB").  
             append("description", "database").  
             append("likes", 100).  
             append("by", "Fly");  
             List<Document> documents = new ArrayList<Document>();  
             documents.add(document);  
             collection.insertMany(documents);  
             System.out.println("文档插入成功");  
          }catch(Exception e){
             System.err.println( e.getClass().getName() + ": " + e.getMessage() );
          }
       }
    }
    //检索文档
    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");

             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");

             //检索所有文档  
             /** 
             + 1. 获取迭代器FindIterable<Document> 
             + 2. 获取游标MongoCursor<Document> 
             + 3. 通过游标遍历检索出的文档集合 
             + */  
             FindIterable<Document> findIterable = collection.find();  
             MongoCursor<Document> mongoCursor = findIterable.iterator();  
             while(mongoCursor.hasNext()){  
                System.out.println(mongoCursor.next());  
             }  

          }catch(Exception e){
             System.err.println( e.getClass().getName() + ": " + e.getMessage() );
          }
       }
    }
    //更新文档
    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;
    import com.mongodb.client.model.Filters;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");

             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");

             //更新文档   将文档中likes=100的文档修改为likes=200   
             collection.updateMany(Filters.eq("likes", 100), new Document("$set",new Document("likes",200)));  
             //检索查看结果  
             FindIterable<Document> findIterable = collection.find();  
             MongoCursor<Document> mongoCursor = findIterable.iterator();  
             while(mongoCursor.hasNext()){  
                System.out.println(mongoCursor.next());  
             }  

          }catch(Exception e){
             System.err.println( e.getClass().getName() + ": " + e.getMessage() );
          }
       }
    }
    //删除第一个文档
    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;
    import com.mongodb.client.model.Filters;

    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");

             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");

             //删除符合条件的第一个文档  
             collection.deleteOne(Filters.eq("likes", 200));  
             //删除所有符合条件的文档  
             collection.deleteMany (Filters.eq("likes", 200));  
             //检索查看结果  
             FindIterable<Document> findIterable = collection.find();  
             MongoCursor<Document> mongoCursor = findIterable.iterator();  
             while(mongoCursor.hasNext()){  
               System.out.println(mongoCursor.next());  
             }  

          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }
 ```

文章内容通过学习所得借鉴一些书籍网站内容，如有侵权请告知。