头歌mongodb

第一章 MongoDB数据库增删改查

1-2 Mongodb 数据库基本操作

第三关 文档操作一

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: [“跳舞”, “羽毛球”, “唱歌”],
});
第四关 文档操作二

#########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:{KaTeX parse error: Expected 'EOF', got '}' at position 9: gte: 15 }̲ ,sex: "女" }); …lt: 20 }, sex: “男” });
db.stu2.remove({})
’
#########end#########
第二章 MongoDB数据库的权限设置

2-1 MongoDB数据库安全

第一关 创建管理员用户

use admin
db.createUser({user:“admin”,pwd:“123456”,roles:[{role:“root”,db:“admin”}]})
第二关 按需求创建普通用户

use firstdb
db.createUser({user:“people”,pwd:“people”,roles:[{role:“read”,db:“firstdb”}]})
第三关 数据库限制访问

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 之聚合函数查询统计

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

先将数据插入

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 *********#
第二关 聚合管道操作符将文档定制格式输出（二）

先插入数据

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 *********#

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

先插入数据 (自行插入)

#********* 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 之滴滴、摩拜都在用的索引

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

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})
第二关 常见索引的创建

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趣的地理位置索引

#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文档的高级查询操作

第一关 数据的导入导出

將 /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”
第二关 高级查询（一）

// 执行查询命令，查找所有喜欢唱歌和跳舞的人的信息，并按照_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 });
#********* 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 *********#
第三关 高级查询（二）

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 *********#
第四关 游标

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 复制集搭建

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分片集搭建

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’)
第五章 数据备份和恢复

第一关 数据备份

命令行

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
第二关 数据恢复

将 /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 工具（二）

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 数据库（一）

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 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 documents = new ArrayList();     //将以上文档打包存放，为文档插入做准备
            documents.add(document1);
            collection.insertMany(documents);     //插入多条文档到集合中
            /********* End *********/
            //在Begin和End之间补充代码，请勿修改代码的原本框架
            FindIterable iter = collection.find();
            iter.forEach(new Consumer() {
                @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 数据库（二）

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 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 documents = new ArrayList();     //将以上文档打包存放，为文档插入做准备
        documents.add(document1);
        documents.add(document2);
        documents.add(document3);

        collection.insertMany(documents);     //插入多条文档到集合中
        /********* End *********/
        //在Begin和End之间补充代码，请勿修改代码的原本框架
        FindIterable iter = collection.find();
        System.out.println("文档插入结果如下：");
        iter.forEach(new Block() {
          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 findIterable = collection.find();  
        MongoCursor 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 iter1 = collection.find();
        System.out.println("删除信息后的文档内容为：");
        
        iter1.forEach(new Consumer() {
            @Override
            public void accept(Document document) {
                System.out.println(document.toJson());
            }
        });

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