MongoDB理解

一、了解Mongodb

MongoDB是一种开源的面向文档的NoSQL数据库管理系统。它使用称为BSON的二进制JSON（JavaScript Object Notation）格式来存储数据，具有灵活的数据模型和强大的查询能力。

1. mongo中的集合相当于mysql中表的概念；
2. mongo中的文档相当于mysql中行的概念；
3. mongo中的域相当于mysql中字段/列的概念；

MongoDB的主要特点和概念

1.文档数据库

MongoDB是一种文档数据库，数据以文档的形式存储。每个文档相当于一个记录或行，可以包含不同的字段和值。这种数据模型非常适合存储复杂、可变结构的数据。

2.高性能：

MongoDB通过使用内存和硬盘之间的数据交换来提供高性能。它将常用数据存储在内存中，以便快速访问和查询。此外，MongoDB支持水平扩展，可以在集群中添加更多的服务器来处理更大的负载。

3.强大的查询语言：

MongoDB提供了丰富的查询功能，包括支持复杂条件、范围查询、正则表达式、聚合管道等。它还支持索引，可以加快查询的速度。

4.数据复制和故障恢复：

MongoDB支持数据复制和自动故障恢复。通过复制，数据可以在多个节点之间同步，提供冗余和高可用性。如果发生故障，系统可以自动将主节点切换到备份节点。

5.数据分片：

MongoDB支持数据分片，可以将数据水平分割成多个分片（shard），存储在不同的服务器上。这样可以提高数据的负载能力和扩展性。

6.灵活的数据模型：

MongoDB没有固定的模式和结构，文档可以根据需要随时进行更新和调整。这使得MongoDB非常适合处理半结构化和动态变化的数据。

7.安全性：

MongoDB提供了许多安全性功能，如用户认证、角色权限管理、加密传输等，以保护数据的机密性和完整性。

8.社区支持和生态系统：

MongoDB拥有庞大的社区和丰富的生态系统，有许多工具和库可用于开发、运维和集成。

总体而言，MongoDB是一种灵活、可扩展且易于使用的NoSQL数据库，适合应对各种类型和规模的数据存储需求。它广泛应用于Web应用程序、大数据分析、实时数据处理等场景。

二、Mongodb的下载与安装

1.安装Mongodb

1.1拉取mongo镜像
 docker pull mongo:4.4

1.2创建mongo数据持久化目录
mkdir -p /docker_volume/mongodb/data

1.3运行容器
docker run -itd --name mongo -v /docker_volume/mongodb/data:/data/db -p 27017:27017 mongo:4.4 --auth

-v: 将宿主机的/docker_volume/mongodb/data映射到容器的/data/db目录，将数据持久化到宿主机，以防止删除容器后，容器内的数据丢失
–auth：需要密码才能访问容器服务

2.创建用户

2.1登录mongo容器，并进入到【admin】数据库
 docker exec -it mongo mongo admin

2.2创建一个用户，mongo 默认没有用户
db.createUser({ user:'root',pwd:'123456',roles:[ { role:'userAdminAnyDatabase', db: 'admin'},'readWriteAnyDatabase']});

【user:‘root’ 】：设置用户名为root
【pwd:‘123456’】：设置密码为123456
【role:‘userAdminAnyDatabase’】：只在admin数据库中可用，赋予用户所有数据库的userAdmin权限
【db: ‘admin’】：可操作的数据库
【‘readWriteAnyDatabase’】：赋予用户读写权限

3.连接测试 

3.1连接mongodb

db.auth('root', '123456')

3.2测试数据库,插入一条语句 

 db.user.insert({"name":"zhangsan","age":18})

3.2测试数据库，查询上面插入的数据 

 db.user.find()

 

三、SpringBoot整合MongoDB 

导入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
             <version>2.3.9.RELEASE</version>
        </dependency>

添加yml配置

 编写实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.bson.types.ObjectId;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Data
@AllArgsConstructor
@NoArgsConstructor
//指定实体类和数据库文档的映射关系    默认实体类名  数据库如果没有该文档，会自动创建
@Document(value="tb_person")
public class Person {
    @Id
    private ObjectId id; //mongoDB推荐使用ID
    //指定属性名和数据库域的映射关系   默认属性名
    @Field("person_name")
    private String name;
    private int age;
    private String address;
}

1.@Document(value=“tb_person”) ：指定实体类和数据库文档的映射关系 默认实体类名 数据库如果没有该文档，会自动创建
2. @Field(“person_name”)： //指定属性名和数据库域的映射关系 默认属性名

测试类

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.test.context.junit4.SpringRunner;
  
    /**
     * 多条件查询
     */
    @Test
    public void find() {
        //设置查询条件 age小于30,且person_name="张三"
        Criteria criteria = Criteria.where("age").lt(30)
                .and("person_name").is("张三");
        
        //设置查询条件
        Query query = new Query(criteria);
        //查询
        List<Person> list = mongoTemplate.find(query, Person.class);

        for (Person person : list) {
            System.out.println(person);
        }
    }

    /**
     * 分页查询
     */
    @Test
    public void findPage() {
        //设置查询条件 age小于30,且person_name="张三"
        Criteria criteria = Criteria.where("age").lt(30)
                .and("person_name").is("张三");

        //根据条件 查询总数
        Query queryCount = new Query(criteria);
        long count = mongoTemplate.count(queryCount, Person.class);


        //查询当前页的数据列表, 查询第二页，每页查询2条
        Query queryLimit = new Query(criteria)
                .with(Sort.by(Sort.Order.desc("age")))
                .limit(2)//每页查询条数
                .skip(2); //从第几页开始 （page-1）*size

        List<Person> list = mongoTemplate.find(queryLimit, Person.class);
        for (Person person : list) {
            System.out.println(person);
        }
    }
    
    /**
     * 更新数据
     */
    @Test
    public void update() {
        //设置查询条件 age小于30,且person_name="张三"
        Criteria criteria = Criteria.where("person_name").is("王五");
        //设置更新条件
        Query query = new Query(criteria);
        //设置更新数据
        Update update = new Update();
        update.set("age", 16);
        mongoTemplate.upsert(query, update, Person.class);
    }

    /**
     * 保存
     */
    @Test
    public void save() {
        Person person = new Person();
        person.setName("张三");
        person.setAge(18);
        mongoTemplate.save(person);
    }
    
    /**
     * 删除数据
     */
    @Test
    public void dlete() {
        mongoTemplate.remove(Query.query(Criteria.where("person_name").is("张三")), Person.class);
    }

1. mongoDB索引
   提示：1 ：升序索引 -1 ：降序索引

#查看索引

db.user.getIndexes()

#创建索引

#db.user.createIndex({'age':1})

常用查询条件

中文	符号
小于	$lt:
大于	$gt:
小于或等于	$lte:
大于或等于	$gte:
不等于	$ne:

 四、MongoDB的数据类型

ObjectId对象类型
ObjectId 类似唯一主键，可以很快的去生成和排序，包含 12 bytes，含义是：

前 4 个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间，比北京时间晚了 8 个小时
接下来的 3 个字节是机器标识码
紧接的两个字节由进程 id 组成 PID
最后三个字节是随机数

MongoDB 中存储的文档必须有一个 _id 键。这个键的值可以是任何类型的，默认是个 ObjectId 对象
由于 ObjectId 中保存了创建的时间戳，所以你不需要为你的文档保存时间戳字段，你可以通过 getTimestamp 函数来获取文档的创建时间:

ObjectId 转为字符串

ok.str

字符串:BSON 字符串都是 UTF-8 编码

五、Mongodb数据库的常用命令

1.数据库常用命令

1、Help查看命令提示
help
db.help();
db.yourColl.help();
db.youColl.find().help();
rs.help();

2、切换/创建数据库
use yourDB; 
当创建一个集合(table)的时候会自动创建当前数据库

3、查询所有数据库

show dbs;

4、删除当前使用数据库
db.dropDatabase();

5、从指定主机上克隆数据库
db.cloneDatabase(“127.0.0.1”); 
将指定机器上的数据库的数据克隆到当前数据库

6、从指定的机器上复制指定数据库数据到某个数据库
db.copyDatabase("mydb", "temp", "127.0.0.1");
将本机的mydb的数据复制到temp数据库中

7、修复当前数据库
db.repairDatabase();

8、查看当前使用的数据库
db.getName();
db; db和getName方法是一样的效果，都可以查询当前使用的数据库

9、显示当前db状态
db.stats();

10、当前db版本
db.version();

11、查看当前db的链接机器地址
db.getMongo();

2.Collection聚合集合

 

1、创建一个聚集集合（table）
db.createCollection(“collName”, {size: 20, capped: 5, max: 100});
//创建成功会显示{“ok”:1}
//判断集合是否为定容量db.collName.isCapped();

2、得到指定名称的聚集集合（table）
db.getCollection("account");

3、得到当前db的所有聚集集合
db.getCollectionNames();

4、显示当前db所有聚集索引的状态
db.printCollectionStats();

3.Mongodb用户相关命令

1、添加一个用户
db.addUser("name");
db.addUser("userName", "pwd123", true); 
添加用户、设置密码、是否只读

2、数据库认证、安全模式
db.auth("userName", "123123");

3、显示当前所有用户
show users;

4、删除用户
db.removeUser("userName");

4.聚合集合查询 

1、查询所有记录
db.userInfo.find();
相当于：select* from userInfo;

默认每页显示20条记录，当显示不下的情况下，可以用it迭代命令查询下一页数据。注意：键入it命令不能带“；”
但是你可以设置每页显示数据的大小，用DBQuery.shellBatchSize= 50;这样每页就显示50条记录了。

2、查询去掉后的当前聚集集合中的某列的重复数据

db.userInfo.distinct("name");
会过滤掉name中的相同数据
相当于：select distict name from userInfo;

3、查询age = 22的记录
db.userInfo.find({"age": 22});
相当于： select * from userInfo where age = 22;

4、查询age > 22的记录
db.userInfo.find({age: {$gt: 22}});
相当于：select * from userInfo where age >22;

5、查询age < 22的记录
db.userInfo.find({age: {$lt: 22}});
相当于：select * from userInfo where age <22;

6、查询age >= 25的记录
db.userInfo.find({age: {$gte: 25}});
相当于：select * from userInfo where age >= 25;

7、查询age <= 25的记录
db.userInfo.find({age: {$lte: 25}});

8、查询age >= 23 并且 age <= 26
db.userInfo.find({age: {$gte: 23, $lte: 26}});

9、查询name中包含 mongo的数据
db.userInfo.find({name: /mongo/});
//相当于%%
select * from userInfo where name like ‘%mongo%';

10、查询name中以mongo开头的
db.userInfo.find({name: /^mongo/});
相当于：select * from userInfo where name like ‘mongo%';

11、查询指定列name、age数据
db.userInfo.find({}, {name: 1, age: 1});
相当于：select name, age from userInfo;
当然name也可以用true或false,当用ture的情况下河name:1效果一样，如果用false就是排除name，显示name以外的列信息。

12、查询指定列name、age数据, age > 25

db.userInfo.find({age: {$gt: 25}}, {name: 1, age: 1});
相当于：select name, age from userInfo where age >25;

13、按照年龄排序
升序：db.userInfo.find().sort({age: 1});
降序：db.userInfo.find().sort({age: -1});

14、查询name = zhangsan, age = 22的数据
db.userInfo.find({name: 'zhangsan', age: 22});
相当于：select * from userInfo where name = ‘zhangsan' and age = ‘22';

15、查询前5条数据
db.userInfo.find().limit(5);
相当于：selecttop 5 * from userInfo;

16、查询10条以后的数据
db.userInfo.find().skip(10);
相当于：select * from userInfo where id not in (
selecttop 10 * from userInfo
);

17、查询在5-10之间的数据
db.userInfo.find().limit(10).skip(5);
可用于分页，limit是pageSize，skip是第几页*pageSize

18、or与查询

db.userInfo.find({$or: [{age: 22}, {age: 25}]});
相当于：select * from userInfo where age = 22 or age = 25;

19、查询第一条数据
db.userInfo.findOne();
相当于：selecttop 1 * from userInfo;
db.userInfo.find().limit(1);

20、查询某个结果集的记录条数
db.userInfo.find({age: {$gte: 25}}).count();
相当于：select count(*) from userInfo where age >= 20;

21、按照某列进行排序
db.userInfo.find({sex: {$exists: true}}).count();
相当于：select count(sex) from userInfo;

5.索引

1、创建索引
db.userInfo.ensureIndex({name: 1});
db.userInfo.ensureIndex({name: 1, ts: -1});

2、查询当前聚集集合所有索引
db.userInfo.getIndexes();

3、查看总索引记录大小
db.userInfo.totalIndexSize();

4、读取当前集合的所有index信息
db.users.reIndex();

5、删除指定索引
db.users.dropIndex("name_1");

6、删除所有索引索引
db.users.dropIndexes();

6.集合数据操作命令

1、添加
db.users.save({name: ‘zhangsan', age: 25, sex: true});
添加的数据的数据列，没有固定，根据添加的数据为准

2、修改

db.users.update({age: 25}, {$set: {name: 'changeName'}}, false, true);
相当于：update users set name = ‘changeName' where age = 25;
db.users.update({name: 'Lisi'}, {$inc: {age: 50}}, false, true);
相当于：update users set age = age + 50 where name = ‘Lisi';
db.users.update({name: 'Lisi'}, {$inc: {age: 50}, $set: {name: 'hoho'}}, false, true);
相当于：update users set age = age + 50, name = ‘hoho' where name = ‘Lisi';

3、删除
db.users.remove({age: 132});

4、查询修改删除
db.users.findAndModify({
    query: {age: {$gte: 25}}, 
    sort: {age: -1}, 
    update: {$set: {name: 'a2'}, $inc: {age: 2}},
    remove: true
});
db.runCommand({ findandmodify : "users", 
    query: {age: {$gte: 25}}, 
    sort: {age: -1}, 
    update: {$set: {name: 'a2'}, $inc: {age: 2}},
    remove: true
});

update 或 remove 其中一个是必须的参数; 其他参数可选。
参数    详解     默认值 
query    查询过滤条件    {} 
sort    如果多个文档符合查询过滤条件，将以该参数指定的排列方式选择出排在首位的对象，该对象将被操作    {} 

remove    若为true，被选中对象将在返回前被删除 N/A 

update    一个修改器对象 N/A 

new    若为true，将返回修改后的对象而不是原始对象。在删除操作中，该参数被忽略。  false 

fields    参见Retrieving a Subset of Fields (1.5.0+)  All fields 

upsert    创建新对象若查询结果为空。 示例 (1.5.4+) false 

7.语句块操作

1、简单Hello World
print("Hello World!");
这种写法调用了print函数，和直接写入"Hello World!"的效果是一样的；

2、将一个对象转换成json

tojson(new Object());
tojson(new Object('a'));

3、循环添加数据
> for (var i = 0; i < 30; i++) {
... db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
... };
这样就循环添加了30条数据，同样也可以省略括号的写法
复制代码 代码如下:
> for (var i = 0; i < 30; i++) db.users.save({name: "u_" + i, age: 22 + i, sex: i % 2});
也是可以的，当你用db.users.find()查询的时候，显示多条数据而无法一页显示的情况下，可以用it查看下一页的信息；

4、find 游标查询
>var cursor = db.users.find();
> while (cursor.hasNext()) { 
    printjson(cursor.next()); 
}
这样就查询所有的users信息，同样可以这样写
var cursor = db.users.find();
while (cursor.hasNext()) { printjson(cursor.next); }
同样可以省略{}号

5、forEach迭代循环
db.users.find().forEach(printjson);
forEach中必须传递一个函数来处理每条迭代的数据信息。

6、将find游标当数组处理
var cursor = db.users.find();
cursor[4];
取得下标索引为4的那条数据
既然可以当做数组处理，那么就可以获得它的长度：cursor.length();或者cursor.count();
那样我们也可以用循环显示数据
for (var i = 0, len = c.length(); i < len; i++) printjson(c[i]);

7、将find游标转换成数组
> var arr = db.users.find().toArray();
> printjson(arr[2]);
用toArray方法将其转换为数组。

8、定制我们自己的查询结果

只显示age <= 28的并且只显示age这列数据
db.users.find({age: {$lte: 28}}, {age: 1}).forEach(printjson);
db.users.find({age: {$lte: 28}}, {age: true}).forEach(printjson);
排除age的列
db.users.find({age: {$lte: 28}}, {age: false}).forEach(printjson);

9、forEach传递函数显示信息

db.things.find({x:4}).forEach(function(x) {print(tojson(x));});