1use admin   // 切换 admin 数据库
2
3db.shutdownServer()  // 关闭mongoDB

1## 通过 dbpath 目录关闭
2mongod -shutdown --dbpath /root/mongodb/db/
3
4## 通过配置文件关闭
5mongod -shutdown -f ./mongodb.conf

1use mydb   // 切换数据库
2
3show dbs  // 查看数据库列表

1use DATABASE_NAME

1db.dropDatabase()

1show collections  // 查看集合列表（show tables）

1db.createCollection(name, options)
2/*
3参数说明	
4name: 要创建的集合名称
5options: 可选参数, 指定有关内存大小及索引的选项
6		capped：可选）如果为 true，则创建固定集合（必须指定 size 参数）
7		size：（可选）为固定集合指定一个最大值，即字节数
8		max：（可选）指定固定集合中包含文档的最大数量
9*/

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

 1// 若插入的数据主键已经存在，则会抛 org.springframework.dao.DuplicateKeyException 异常，提示主键重复，不保存当前数据
 2db.COLLECTION_NAME.insert(document)
 3
 4// 用于向集合插入一个新文档
 5db.collection.insertOne(
 6   <document>,
 7   {
 8      writeConcern: <document>
 9   }
10)
11
12// 用于向集合插入一个多个文档
13db.collection.insertMany(
14   [ <document 1> , <document 2>, ... ],
15   {
16      writeConcern: <document>,
17      ordered: <boolean>
18   }
19)

1db.collection.update(
2   <query>,
3   <update>,
4   {
5     upsert: <boolean>,
6     multi: <boolean>,
7     writeConcern: <document>
8   }
9)

1db.collection.remove(
2   <query>,
3   {
4     justOne: <boolean>,
5     writeConcern: <document>
6   }
7)

 1db.col.insertMany([{
 2        "name" : "张三",
 3        "tags" : [
 4                "java",
 5                "vue",
 6        ],
 7        "age" : 43,
 8		"address": "12sad"
 9},{
10        "name" : "李四",
11        "tags" : [
12                "python",
13                "react"
14        ],
15        "age" : 65,
16		"address": "12sad"
17}])

1db.col.find({key1:value1, key2:value2}).pretty()
2
3// 查询 address='12sad' and age < 50
4db.col.find({address:'12sad',age:{$lt:50}})

 1db.col.find(
 2   {
 3      $or: [
 4         {key1: value1}, {key2:value2}
 5      ]
 6   }
 7).pretty()
 8
 9// 查询 age>50 or name ='张三'
10db.col.find({
11	$or:[
12    	{age:{$gt:50}},{name:'张三'}
13    ]
14})

1// 查询name字段为string类型数据
2db.col.find({
3    name:{$type:'string'}
4})

1// 读取指定数量的数据
2db.COLLECTION_NAME.find().limit(NUMBER)
3 
4// 跳过指定数量的数据
5db.COLLECTION_NAME.find().skip(NUMBER)
6
7// 组合使用（分页）
8db.COLLECTION_NAME.find().limit(pageSize).skip((pageSize-1)*pageNumber)

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

1// 语法中 Key 值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可
2db.collection.createIndex(keys, options)
3
4// 为 name 字段创建索引
5db.col.createIndex({"name":1})
6
7// 为 name 字段和 age 字段创建“复合索引”
8db.col.createIndex({"name":1,"age":-1})

 1db.student.insertMany([{
 2    "id": "1",
 3    "name": "小明",
 4    "age": NumberInt(12),
 5    "sex": "男",
 6    "course": ["数学", "语文", "英语"]
 7}, {
 8    "id": "2",
 9    "name": "小章",
10    "age": NumberInt(13),
11    "sex": "男",
12    "course": ["数学", "语文"]
13}, {
14    "id": "3",
15    "name": "小九",
16    "age": NumberInt(12),
17    "sex": "女",
18    "course": ["数学"]
19}]);

1// 可以用多个构件创建一个管道，对于一连串的文档进行处理。这些构件包括：筛选操作的match、映射操作的project、分组操作的group、排序操作的sort、限制操作的limit、和跳过操作的skip
2db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

 1// 首先过滤出 age = 12 的数据，然后统计总共的数据个数
 2db.student.aggregate([
 3	{
 4		$match:{
 5			age:NumberInt(12)
 6		}
 7	},
 8	{
 9		$count:"name"
10	}
11])
12
13// 根据 sex 分组，并统计分组后各有多少人
14db.student.aggregate([ 
15    { $group: { _id: "$sex", "num": { $sum:1 } } }
16] )
17
18// 查询数据总条数
19db.student.aggregate([ { $group: { _id: null, "num": { $sum: 1 } } }] )

 1## 创建三个目录用于存放 mongoDB 数据库文件
 2mkdir -p rs1/db
 3mkdir -p rs2/db
 4mkdir -p rs3/db
 5
 6## 通过不同端口启动三个 mongoDB 实例
 7#		bind_ip 允许所有地址访问
 8#		replSet 指定副本集名称
 9mongod --bind_ip "0.0.0.0" --port "30001" --dbpath "/root/mongodb/replSet/rs1" -logpath "/root/mongodb/replSet/rs1.log" --replSet "replSet" --fork
10mongod --bind_ip "0.0.0.0" --port "30002" --dbpath "/root/mongodb/replSet/rs2" -logpath "/root/mongodb/replSet/rs2.log" --replSet "replSet" --fork
11mongod --bind_ip "0.0.0.0" --port "30003" --dbpath "/root/mongodb/replSet/rs3" -logpath "/root/mongodb/replSet/rs3.log" --replSet "replSet" --fork

 1// 切换到 admin 数据库
 2use admin
 3// 通过 initiate 方法初始化副本集，并添加节点
 4// 		arbiterOnly 是否为仲裁节点，不参与数据复制，仅选举 master 节点
 5rs.initiate({
 6	"_id":"replSet",
 7	"members":[
 8		{"_id" : 0, "host" : "127.0.0.1:30001"},
 9		{"_id" : 1, "host" : "127.0.0.1:30002"},
10		{"_id" : 2, "host" : "127.0.0.1:30003","arbiterOnly":true}
11	]
12})

 1// 副本集状态
 2rs.status()
 3
 4// 查看 master 节点相关信息
 5db.isMaster()
 6
 7// 添加节点
 8rs.add("mongod1.net:27017")
 9
10// 添加冲裁节点
11rs.addArb(“ip:port”)
12
13// 移除节点
14rs.remove("ip:port")

 1rs.initiate() 	// 使用默认配置初始化副本集
 2rs.initiate(cfg) 	// 使用配置文件cfg初始化副本集
 3rs.reconfig(cfg) 	// 修改副本集配置信息
 4rs.status() 	// 查看副本集状态
 5rs.conf() 	// 查看副本集配置
 6rs.add(hostportstr) 	// 添加新的节点 
 7rs.addArb(hostportstr) 	// 添加仲裁节点
 8rs.remove(hostportstr) 	// 删除节点
 9rs.slaveOk() 	// 允许副本节点只读，默认副本节点不允许读写
10rs.isMaster() 	// 查看哪个节点为主节点
11rs.printReplicationInfo() 	// 查看oplog大小以及oplog可用时间，可以判断系统繁忙程度
12rs.printSlaveReplicationInfo() 	// 查看复制集成员以及延迟
13rs.stepDown([stepdownSecs, catchUpSecs]) 	// 手动主从切换
14rs.freeze(secs)	 // 冻结当前节点在指定的时间内（秒）不能选举为主
15rs.syncFrom(hostportstr) 	// 管理员临时覆盖当前成员的默认同步目标。以[hostname]：[port]的形式指定要复制的成员的名称。

 1/*
 2    Shard
 3        shardSet1 : 一个实例，端口 30001
 4        shardSet2 : 一个实例，端口 30002
 5
 6    config server
 7        configRs : 一个实例，端口30011
 8
 9    mongos 端口 30021
10*/

 1// 创建数据库
 2use mydb
 3
 4// 创建集合
 5db.createCollection('testcollection')
 6
 7// 对片键的字段建立索引 db.<collection>.createIndex(<keyPatterns>,<options>) 
 8// 下例子创建了哈希索引
 9db.testcollection.createIndex({title:'hashed'})
10
11// sh.shardCollection("<database>.<collection>",{ "<key>":<value> } ) 
12// 下例子表示将数据基于哈希分片
13sh.shardCollection("mydb.testcollection",{"title":'hashed'})
14
15// 插入测试数据
16db.testcollection.insertMany([
17	{title:1},
18	{title:-1},
19	{title:3},
20	{title:-3},
21	{title:5},
22	{title:-5}
23])
24
25// 查看分片状态，返回 分片信息，分片的集合，分片的key，片键，基于什么分片（hash/范围），当前的chunks
26sh.status()

1## 启动命令
2mongod --bind_ip_all --port "30001" --dbpath "/root/mongodb/replSet/rs1" -logpath "/root/mongodb/replSet/rs1.log" --replSet "replSet" --fork
3mongod --bind_ip_all --port "30002" --dbpath "/root/mongodb/replSet/rs2" -logpath "/root/mongodb/replSet/rs2.log" --replSet "replSet" --fork
4mongod --bind_ip_all --port "30003" --dbpath "/root/mongodb/replSet/rs3" -logpath "/root/mongodb/replSet/rs3.log" --replSet "replSet" --fork

 1// 连接任意节点初始化副本集
 2// arbiterOnly 仲裁节点，不参与数据的复制，仅选举 master 节点
 3rs.initiate({
 4	"_id":"replSet",
 5	"members":[
 6		{"_id" : 0, "host" : "192.168.56.101:30001"},
 7		{"_id" : 1, "host" : "192.168.56.101:30002"},
 8		{"_id" : 2, "host" : "192.168.56.101:30003","arbiterOnly":true}
 9	]
10})
11
12// 切换数据库
13use myDB
14
15// 插入测试数据
16db.testCollection.insertMany([
17	{name:'张三',title:'测试1',age:22},
18	{name:'李四',title:'测试2',age:24},
19	{name:'王五',title:'测试3',age:29}
20])
21
22// 查询数据
23db.testCollection.find({})

 1public class CH05MongoDBDemo {
 2    public static void main(String[] args) {
 3        ConnectionString connectionString=new ConnectionString("mongodb://192.168.56.101:30001,192.168.56.101:30002/?replicaSet=replSet");
 4        try (MongoClient mongoClient = MongoClients.create(connectionString)) {
 5            MongoDatabase database = mongoClient.getDatabase("myDB");
 6            MongoCollection<Document> collection = database.getCollection("testCollection");
 7
 8            // 插入数据
 9//            insertMethod(collection);
10
11            // 查询数据
12//            findMethod(collection);
13
14            // 更新数据
15//            updateMethod(collection);
16
17            // 删除数据
18//            deleteMethod(collection);
19
20            // 分页查询
21            pageMethod(collection);
22
23        }
24
25    }
26
27    private static void pageMethod(MongoCollection<Document> collection) {
28        final int pageSize=2;
29        final int pageIndex=2;
30        FindIterable<Document> documentFindIterable = collection.find();
31
32        // 通过 age 升序排序
33        documentFindIterable.sort(Document.parse("{age:-1}"));
34
35        documentFindIterable.limit(pageSize);
36        documentFindIterable.skip(pageIndex*(pageSize-1));
37
38        MongoCursor<Document> iterator = documentFindIterable.iterator();
39        while (iterator.hasNext()){
40            System.out.println(iterator.next().toJson());
41        }
42    }
43
44    private static void deleteMethod(MongoCollection<Document> collection) {
45        Document query = Document.parse("{name:'张三'}");
46        DeleteResult deleteResult = collection.deleteOne(query);
47        System.out.println(deleteResult.wasAcknowledged());
48    }
49
50    private static void updateMethod(MongoCollection<Document> collection) {
51        Document query = Document.parse("{name:'张三'}");
52        Bson bson = Updates.combine(
53                Updates.set("age", 66)
54        );
55
56        UpdateResult updateResult = collection.updateOne(query, bson);
57
58        System.out.println(updateResult.wasAcknowledged());
59    }
60
61    private static void findMethod(MongoCollection<Document> collection) {
62        FindIterable<Document> documentFindIterable = collection.find();
63        MongoCursor<Document> iterator = documentFindIterable.iterator();
64        while (iterator.hasNext()){
65            System.out.println(iterator.next().toJson());
66        }
67
68    }
69
70    private static void insertMethod(MongoCollection<Document> collection) {
71        List<Document> documentList=new ArrayList<>();
72        documentList.add(Document.parse("{name:'张三',title:'测试1',age:22}"));
73        documentList.add(Document.parse("{name:'李四',title:'测试2',age:24}"));
74        documentList.add(Document.parse("{name:'王五',title:'测试3',age:29}"));
75        InsertManyResult result = collection.insertMany(documentList);
76        System.out.println(result.wasAcknowledged());
77    }
78}