头歌-Mongo入门

发表于

第一章 MongoDB数据库增删改查

1-2 Mongodb 数据库基本操作

第三关 文档操作一

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
use Testdb3   // 进入 Testdb3数据库
document = {
    _id: 1,
    name: "张小华",
    sex: "男",
    phone: "12356986594",
    hobbies: ["打篮球", "踢足球", "唱歌"]
};
db.stu1.insert(document);
db.stu2.insert(document);
db.stu3.insert(document);
db.stu2.update({ phone: "12356986594" }, { $set: { phone: "18356971462" } });
db.stu2.find().pretty(); // 查看stu2
db.stu3.save({
_id: 1,
name: "张晓晓",
sex: "女",
phone: "12365498704",
hobbies: ["跳舞", "羽毛球", "唱歌"],
});

第四关 文档操作二

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#########begin#########
echo '
    document = [
        {
                "_id" : 1,
                "name" : "西西",
                "sex" : "女",
                "age" : 23,
                "national" : "汉族"
        },
        {
                "_id" : 2,
                "name" : "东东",
                "sex" : "男",
                "age" : 20,
                "national" : "苗族"
        },
        {
                "_id" : 3,
                "name" : "北北",
                "sex" : "男",
                "age" : 19,
                "national" : "汉族"
        },
        {
                "_id" : 4,
                "name" : "南南",
                "sex" : "女",
                "age" : 15,
                "national" : "傣族"
        }
];

db.stu1.insert(document);
db.stu2.insert(document);
db.stu1.find({ age:{$gte: 15 } ,sex: "女" });
db.stu1.find({ national:"苗族"}).pretty();
db.stu1.find({ age:{$lt: 20 }, sex: "男" });
db.stu2.remove({})
'
#########end#########

第二章 MongoDB数据库的权限设置

2-1 MongoDB数据库安全

第一关 创建管理员用户

1
2
use admin
db.createUser({user:"admin",pwd:"123456",roles:[{role:"root",db:"admin"}]})

第二关 按需求创建普通用户

1
2
use firstdb 
db.createUser({user:"people",pwd:"people",roles:[{role:"read",db:"firstdb"}]})

第三关 数据库限制访问

1
2
3
4
use admin #进入admin数据库
db.shutdownServer() #关闭服务
exit #退出数据库
mongod -port 20018 --dbpath /data/db --logpath /tmp/mongodb.log --bind_ip 127.0.0.1 --fork

第三章 MongoDB数据库高级查询

3-1 MongoDB 之聚合函数查询统计

第一关 聚合管道操作符将文档定制格式输出（一）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
# 先将数据插入
use test1 
document = [
        {
                "_id" : 1,
                "course" : "Python表达式问题求解实训",
                "author" : "李暾",
                "tags" : [
                        "Python基础",
                        "求解"
                ],
                "learning_num" : 1882
        },
        {
                "_id" : 2,
                "course" : "Java语言之基本语法",
                "author" : "余跃",
                "tags" : [
                        "Java基础",
                        "语法"
                ],
                "learning_num" : 814
        },
        {
                "_id" : 3,
                "course" : "Python面向对象编程实训",
                "author" : "李暾",
                "tags" : [
                        "Python基础",
                        "面向对象"
                ],
                "learning_num" : 143
        },
        {
                "_id" : 4,
                "course" : "Android综合实训之物联网移动应用开发（1）",
                "author" : "prophet5",
                "tags" : [
                        "Android",
                        "物联网",
                        "移动开发"
                ],
                "learning_num" : 207
        }
]
db.educoder.insert(document)

#********* Begin *********#
echo "
db.educoder.aggregate({\$project:{_id:0,course:1,learning_num:1}});
db.educoder.aggregate({\$match:{learning_num:1882}});
"
#********* End *********#

第二关 聚合管道操作符将文档定制格式输出（二）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# 先插入数据
use test2 
document = [
        {
                "_id" : 1,
                "course" : "Python表达式问题求解实训",
                "author" : "李暾",
                "tags" : [
                        "Python基础",
                        "求解"
                ],
                "learning_num" : 1882
        },
        {
                "_id" : 2,
                "course" : "Java语言之基本语法",
                "author" : "余跃",
                "tags" : [
                        "Java基础",
                        "语法"
                ],
                "learning_num" : 814
        },
        {
                "_id" : 3,
                "course" : "Python面向对象编程实训",
                "author" : "李暾",
                "tags" : [
                        "Python基础",
                        "面向对象"
                ],
                "learning_num" : 143
        },
        {
                "_id" : 4,
                "course" : "Android综合实训之物联网移动应用开发（1）",
                "author" : "prophet5",
                "tags" : [
                        "Android",
                        "物联网",
                        "移动开发"
                ],
                "learning_num" : 207
        }
]
db.educoder.insert(document)

#********* Begin *********#
echo "

db.educoder.aggregate({\$limit:3});
db.educoder.aggregate({\$sort:{learning_num:1}});
db.educoder.aggregate([{\$skip:2}]);

"
#********* End *********#

第三关 聚合表达式对文档数据进行统计

1
2
3
4
5
6
7
8
# 先插入数据 (自行插入)
#********* Begin *********#
echo "
db.educoder.aggregate([{\$group:{_id:'\$author',first_course:{\$first:'\$course'}}}]);
db.educoder.aggregate([{\$group:{_id:'\$author',learning_avg:{\$avg:'\$learning_num'}}}]);
db.educoder.aggregate([{ \$unwind:'\$tags'} , { \$group:{_id:'\$tags',course_num:{\$sum:1} } }] 
"
#********* End *********#

3-2 MongoDB 之滴滴、摩拜都在用的索引

第一关 了解并创建一个简单索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
use test 
document = [
        {
                "_id" : "1",
                "name" : "王小明",
                "age" : "15",
                "score" : "90"
        },
        {
                "_id" : "2",
                "name" : "周晓晓",
                "age" : "18",
                "score" : "86"
        },
        {
                "_id" : "3",
                "name" : "王敏",
                "age" : "20",
                "score" : "96"
        },
        {
                "_id" : "4",
                "name" : "李晓亮",
                "age" : "15",
                "score" : "74"
        },
        {
                "_id" : "5",
                "name" : "张青青",
                "age" : "21",
                "score" : "88"
        }
]
db.student.insert(document)
db.student.createIndex({score:-1})

第二关 常见索引的创建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
document = [
        {
                "_id" : "1",
                "title" : "提升程序员工作效率的6个工具利器",
                "tags" : "Alfred,幕布",
                "follwers" : 543
        },
        {
                "_id" : "2",
                "title" : "我是如何从零开始学习前端的",
                "tags" : "HTML,Html5,CSS",
                "follwers" : 1570
        },
        {
                "_id" : "3",
                "title" : "20个非常有用的JAVA程序片段",
                "tags" : "Java,编程",
                "follwers" : 1920
        }
]
use test2
db.article.insert(document)
# 用字段 follwers 和 title 创建复合升序索引；
db.article.createIndex({ follwers: 1, title: 1 });
# 用字段 tags 创建多 key 降序索引；
db.article.createIndex({ tags: -1 });
# 用_id创建哈希索引；
db.article.createIndex({ _id: "hashed" });
# 用字段 title 和 tags 创建文本索引。
db.article.createIndex(
... {
... title:"text",
... tags:"text"
... }
... )

第三关 有NM趣的地理位置索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#**********Begin**********#
echo '
  db.people.insert({
    _id: 1,
    name: "A",
    personloc: { type: "Point", coordinates: [116.403981, 39.914935] },
  });

  db.people.insert({
    _id: 2,
    name: "B",
    personloc: { type: "Point", coordinates: [116.433733, 39.909511] },
  });

  db.people.insert({
    _id: 3,
    name: "C",
    personloc: { type: "Point", coordinates: [116.488781, 39.949901] },
  });

  db.people.insert({
    _id: 4,
    name: "D",
    personloc: { type: "Point", coordinates: [116.342609, 39.948021] },
  });

  db.people.insert({
    _id: 5,
    name: "E",
    personloc: { type: "Point", coordinates: [116.328236, 39.901098] },
  });

  db.people.insert({
    _id: 6,
    name: "F",
    personloc: { type: "Point", coordinates: [116.385728, 39.871645] },
  });

  db.people.createIndex({ personloc: "2dsphere" });

  db.runCommand({
    geoNear: "people",
    near: { type: "Point", coordinates: [116.403981, 39.914935] },
    spherical: true,
    minDistance: 100,
    maxDistance: 3000,
  });
  db.runCommand({
    geoNear: "people",
    near: { type: "Point", coordinates: [116.433733, 39.909511] },
    spherical: true,
    minDistance: 100,
    maxDistance: 5000,
  });
  db.runCommand({
    geoNear: "people",
    near: { type: "Point", coordinates: [116.488781, 39.949901] },
    spherical: true,
    minDistance: 3000,
    maxDistance: 8000,
  });
  db.runCommand({
    geoNear: "people",
    near: { type: "Point", coordinates: [116.342609, 39.948021] },
    spherical: true,
    minDistance: 3000,
    maxDistance: 8000,
  });
'
#**********End**********#

3-3 MondoDB文档的高级查询操作

第一关 数据的导入导出

1
2
3
4
5
6
7
8
#  將 /home/example 路径下的文件 student.csv 导入到数据库 mydb1 的 test 集合中；
mongoimport -d mydb1 -c test --type csv  --headerline --ignoreBlanks --file /home/example/student.csv
# 将 /home/example/person.json 文件导入到数据库 mydb2 中的 test 集合中。
mongoimport -d mydb2 -c test  --type json --file /home/example/person.json
# 将数据库 mydb1 的 test 集合以 json 格式导出到 /home/test1.json 的 json 文件中；
mongoexport -d mydb1 -c test  -o /home/test1.json  --type json
# 将数据库 mydb1 的 test 集合以 csv 格式导出到 /home/test1.csv 的 CSV 文件中
mongoexport -d mydb1 -c test  -o /home/test1.csv  --type csv -f "_id,name,age,sex,major"

第二关 高级查询（一）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 执行查询命令，查找所有喜欢唱歌和跳舞的人的信息，并按照_id升序排序；
  db.test.find({ hobbies: { $all: ["唱歌", "跳舞"] } }).sort({ _id: 1 });
  // 执行查询命令，查找所有喜欢羽毛球和跳舞的人的信息，并按照_id升序排序；
  db.test.find({ hobbies: { $all: ["羽毛球", "跳舞"] } }).sort({ _id: 1 });
  // 执行查询命令，查找有3个爱好的人的信息，并按照_id升序排序；
  db.test.find({ hobbies: { $size: 3 } }).sort({ _id: 1 });
  // 执行查询命令，查找文档中存在 hobbies 字段的人的信息，并按照_id升序排序；
  db.test.find({ hobbies: { $exists: true } }).sort({ _id: 1 });
  // 执行查询命令，查找19岁和23岁的人的信息，并按照_id升序排序；
  db.test.find({ age: { $in: [19, 23] } }).sort({ _id: 1 });
  // 执行查询命令，查找不是20岁的人的信息，并按照_id升序排序；
  db.test.find({ age: { $nin: [20] } }).sort({ _id: 1 });
  // 执行查询命令，查找 age 取模9等于2的人的信息，并按照_id升序排序。
  db.test.find({ age: { $mod: [9, 2] } }).sort({ _id: 1 });
1
2
3
4
5
6
7
8
9
10
11
#********* Begin *********#
echo "
  db.test.find({ hobbies: { \$all: ['唱歌', '跳舞'] } }).sort({ _id: 1 });
  db.test.find({ hobbies: { \$all: ['羽毛球', '跳舞'] } }).sort({ _id: 1 });
  db.test.find({ hobbies: { \$size: 3 } }).sort({ _id: 1 });
  db.test.find({ hobbies: { \$exists: true } }).sort({ _id: 1 });
  db.test.find({ age: { \$in: [19, 23] } }).sort({ _id: 1 });
  db.test.find({ age: { \$nin: [20] } }).sort({ _id: 1 });
  db.test.find({ age: { \$mod: [9, 2] } }).sort({ _id: 1 });
"
#********* End *********#

第三关 高级查询（二）

1
2
3
4
5
6
7
8
9
10
11
12
13
mongoimport -d mydb3 -c test --type json --file /home/example/person.json
#********* Begin *********#
echo "
db.test.find({\$and:[{age:20},{sex:'男'}]}).sort({_id:1});
db.test.find({\$or:[{age:20},{sex:'男'}]}).sort({_id:1});
db.test.find({name:/^韩./}).sort({_id:1});
db.test.find({\$and:[{age:{\$gte:19}},{age:{\$lt:22}}]}).sort({_id:1});
db.test.find({\$or:[{age:{\$lt:19}},{age:{\$gt:21}}]}).sort({_id:1});
db.test.find({name:{\$not:/^韩./}}).sort({_id:1});
db.test.find({name:{\$not:/^韩.*/}}).sort({_id:1}).count();
db.test.find({\$and:[{age:{\$gte:19}},{age:{\$lt:22}}]}).sort({_id:1}).count();
"
#********* End *********#

第四关 游标

1
2
3
4
use mydb4
for(var i=0;i<10000;i++)db.test.insert({_id:i,title:"MongoDB"+i,content:"hello"+i})

mongoexport -d mydb4 -c test -o /home/test/test4.csv --type csv -f "_id,title,content"

第四章 MongoDB分布式集群

4-1 Mongodb复制集&分片

第一关 ACD ABD

第二关 MongoDB 复制集搭建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
mkdir -p /data/test/db1 /data/test/db2 /data/test/db3
mkdir -p /logs/test
touch { /logs/test/mongod1.log /logs/test/mongod2.log /logs/test/mongod3.log }
mkdir -p /etc/test
touch { /etc/test/mongod1.conf /etc/test/mongod2.conf /etc/test/mongod3.conf }

# 创建三个配置文件
port=20001 #配置端口号
dbpath=/data/test/db1 #配置数据存放的位置
logpath=/logs/test/mongod1.log #配置日志存放的位置
logappend=true #日志使用追加的方式
fork=true #设置在后台运行
replSet=CHANG #配置复制集名称，该名称要在所有的服务器一致

mongod -f /etc/test/mongod1.conf
mongod -f /etc/test/mongod2.conf
mongod -f /etc/test/mongod3.conf

config = {
  _id:"CHANG",
  members:[
      {_id:0,host:'127.0.0.1:20001'},
      {_id:1,host:'127.0.0.1:20002',arbiterOnly:true},
      {_id:2,host:'127.0.0.1:20003'},
  ]
}
rs.initiate(config)

image.png

第三关 MongoDB分片集搭建

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
mkdir -p /data/test2/shard1/db
mkdir -p /logs/test2/shard1/log
mkdir -p /data/test2/shard2/db
mkdir -p /logs/test2/shard2/log
mkdir -p /data/test2/shard3/db
mkdir -p /logs/test2/shard3/log
mkdir -p /data/test2/config/db
mkdir -p /logs/test2/config/log
mkdir -p /logs/test2/mongs/log
mkdir -p /etc/test2

root@evassh-6088960:/etc/test2# cat mongod1.conf mongod2.conf mongod3.conf 
# mongod1.conf
dbpath=/data/test2/shard1/db
logpath=/logs/test2/shard1/log/mongodb.log
port=21001
shardsvr=true
fork=true
# mongod2.conf
dbpath=/data/test2/shard2/db
logpath=/logs/test2/shard2/log/mongodb.log
port=21002
shardsvr=true
fork=true
# mongod3.conf
dbpath=/data/test2/shard3/db
logpath=/logs/test2/shard3/log/mongodb.log
port=21003
shardsvr=true
fork=true

# 启动mongo
mongod -f /etc/mongo/mongod1.conf
mongod -f /etc/mongo/mongod2.conf
mongod -f /etc/mongo/mongod3.conf

# 配置config
 mongod --dbpath /data/test2/config/db --logpath /logs/test2/config/log/mongodb.log --port 21004 --configsvr --replSet cs --fork
# 链接21004
mongo localhost:21004

use admin
cfg = {
  _id:'cs',
  configsvr:true,
  members:[
      {_id:0,host:'localhost:21004'}
   ]
}
rs.initiate(cfg)

# 配置route
mongos --configdb cs/localhost:21004 --logpath /logs/test2/mongs/log/mongodb.log --port 21005 --fork
# 连接 21005
mongo localhost:21005

sh.addShard('localhost:21001')
sh.addShard('localhost:21002')
sh.addShard('localhost:21003')

第五章 数据备份和恢复

第一关 数据备份

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 命令行
mongoimport -d test1 -c person --type json --file /home/example/person.json

mongoimport -d test2 -c student --type csv --headerline --ignoreBlanks --file /home/example/student.csv

# 将所有数据库被分到/opt/mongodb
mongodump -h 127.0.0.1:27017 -o /opt/mongodb
# 将 test1 数据库备份到 /opt/mongodb_1 目录下；
mongodump -h 127.0.0.1:27017 -d test1 -o /opt/mongodb_1
# 将 person 集合备份到 /opt/collection_1 目录下；
mongodump -h 127.0.0.1:27017   -d test1 -c person -o /opt/collection_1 
# 将 student 集合压缩备份到 /opt/collection_2 目录下；
mongodump -h 127.0.0.1:27017  -d test2 -c student -o /opt/collection_2 --gzip 
# 将 test2 数据库压缩备份到 /opt/mongodb_2 目录下。
mongodump -h 127.0.0.1:27017  -d test2 -o /opt/mongodb_2 --gzip

第二关 数据恢复

1
2
3
4
5
6
7
8
9
10
# 将 /opt/mongodb 目录下的数据恢复到 MongoDB 中；
mongorestore -h 127.0.0.1:27017  /opt/mongodb
# 将 /opt/mongodb_1 目录下的数据恢复到 mytest1 数据库中；
mongorestore -h 127.0.0.1:27017  -d mytest1 --drop  /opt/mongodb_1/test1/
# 将 /opt/collection_1 目录下的数据恢复到 mytest2 数据库的 person 集合中；
mongorestore -h 127.0.0.1:27017  -d mytest2 -c person --drop /opt/collection_1/test1/person.bson
# 将 /opt/collection_2 目录下的数据恢复到 mytest3 数据库的 student 集合中，并删除之前备份的表；
mongorestore -h 127.0.0.1:27017  -d mytest3  --drop -c student --gzip /opt/collection_2/test2/student.bson.gz
# 将 /opt/mongodb_2 目录下的数据恢复到 mytest4 的数据库中，并删除之前的备份的数据库。
mongorestore -h 127.0.0.1:27017  -d mytest4  --drop -c student --gzip /opt/mongodb_2/test2/student.bson.gz

第六章

第一关 优化查询原则

CD AD AC ABD BCD ABCD CD AD

第二关 MongoDB 的 Profiling 工具（一）

image.png

第三关 MongoDB 的 Profiling 工具（二）

1
2
3
4
5
use mydb3
db.setProfilingLevel(1,5)

for(var i=0;i<100000;i++)db.items1.insert({_id:i,text:"Hello MongoDB"+i})
for(var i=0;i<100000;i++)db.items2.insert({_id:i,text:"Hello MongoDB"+i})

第七章

第一关 Java 操作 MongoDB 数据库（一）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package step1;
import java.util.function.Consumer;
import java.util.logging.Level;
import java.util.logging.Logger;
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;
import com.mongodb.client.FindIterable;
import com.mongodb.Block;
public class Mongoconnect{
    public static void main( String args[] ){
        Logger log = Logger.getLogger("org.mongodb.driver");
        log.setLevel(Level.OFF);          //屏蔽带时间的输出
        try{
            //在下面补充代码，连接到mongodb服务
            /********* Begin *********/
            MongoClient mongoClient = new MongoClient("localhost",27017);     //启动本地服务，端口号为27020
            MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");     //连接名为databaseName数据库

            /********* End *********/
            //在下面补充代码，创建集合test1
            /********* Begin *********/
            mongoDatabase.createCollection("test1");     //创建集合test【如果存在将这一行内容注释】
            /********* End *********/
            //在下面补充代码，获取集合test1
            /********* Begin *********/
            MongoCollection<Document> collection = mongoDatabase.getCollection("test1"); 
            /********* End *********/
            //在下面补充代码，插入编程要求中的数据到集合test1
            /********* Begin *********/
            Document document1 = new Document();     //创建一条文档 document1，以下代码为向文档 document1 中追加数据
            document1.append("_id", "1");
            document1.append("name", "Xiaoming");
            document1.append("sex", "man");
            document1.append("age", 21);
            List<Document> documents = new ArrayList<Document>();     //将以上文档打包存放，为文档插入做准备
            documents.add(document1);
            collection.insertMany(documents);     //插入多条文档到集合中
            /********* End *********/
            //在Begin和End之间补充代码，请勿修改代码的原本框架
            FindIterable<Document> iter = collection.find();
            iter.forEach(new Consumer<Document>() {
                @Override
                public void accept(Document document) {
                    System.out.println(document.toJson());
                }
            });
            Document doc = collection.find().first();
            collection.deleteOne(doc);
        }catch (Exception e) {
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
        }
    }
}}

第二关 Java 操作 MongoDB 数据库（二）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package step2;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.FindIterable;
import com.mongodb.Block;  
import com.mongodb.client.model.Filters;
import com.mongodb.client.MongoCursor;
public class Mongo{
    public static void main( String args[] ){
        Logger log = Logger.getLogger("org.mongodb.driver");  
        log.setLevel(Level.OFF);          //屏蔽带时间的输出
        try{ 
            //仿照第一关，连接数据库mydb2并选择集合test2
            /********* Begin *********/ 
            MongoClient mongoClient = new MongoClient("localhost",27017);     //启动本地服务，端口号为27017
            MongoDatabase mongoDatabase = mongoClient.getDatabase("mydb2");     //连接名为mydb2数据库
            MongoCollection<Document> collection = mongoDatabase.getCollection("test2"); 

            /********* End *********/
            //在下面补充代码，插入文档到集合test2中
            /********* Begin *********/ 
            Document document1 = new Document();      
            document1.append("_id", "1");
            document1.append("name", "Xiaoming");
            document1.append("sex", "man");
            document1.append("age", 21);

            Document document2 = new Document();      
            document2.append("_id", "2");
            document2.append("name", "Xiaohong");
            document2.append("sex", "woman");
            document2.append("age", 20);

            Document document3 = new Document();      
            document3.append("_id", "3");
            document3.append("name", "Xiaoliang");
            document3.append("sex", "man");
            document3.append("age", 22);

            List<Document> documents = new ArrayList<Document>();     //将以上文档打包存放，为文档插入做准备
            documents.add(document1);
            documents.add(document2);
            documents.add(document3);

            collection.insertMany(documents);     //插入多条文档到集合中
            /********* End *********/
            //在Begin和End之间补充代码，请勿修改代码的原本框架
            FindIterable<Document> iter = collection.find();
            System.out.println("文档插入结果如下：");
            iter.forEach(new Block<Document>() {
              public void apply(Document _doc) {
                System.out.println(_doc.toJson());
              }
            });
            //在下面补充代码，更新 Xiaohong 的信息为23岁
            /********* Begin *********/ 
            collection.updateMany(Filters.eq("name", "Xiaohong"), new Document("$set",new Document("age",23)));

            /********* End *********/
            //在Begin和End之间补充代码，请勿修改代码的原本框架
            FindIterable<Document> findIterable = collection.find();  
            MongoCursor<Document> mongoCursor = findIterable.iterator(); 
            System.out.println("更新后文档内容如下：");
            while(mongoCursor.hasNext()){  
            System.out.println(mongoCursor.next());  
            };
            //在下面补充代码，删除Xiaoliang的信息
            /********* Begin *********/ 
            collection.deleteOne(Filters.eq("name", "Xiaoliang"));
            /********* End *********/ 
            //在Begin和End之间补充代码，请勿修改代码的原本框架
            FindIterable<Document> iter1 = collection.find();
            System.out.println("删除信息后的文档内容为：");
            
            iter1.forEach(new Consumer<Document>() {
                @Override
                public void accept(Document document) {
                    System.out.println(document.toJson());
                }
            });

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

本文转载自: 掘金

开发者博客 – 和开发相关的 这里全都有

0%