MongoDB（介绍，安装，操作，Springboot整合MonggoDB）

MongoDB

1 MongoDB介绍

MongoDB简介

MongoDB的特点

MongoDB使用场景

小结

2 MongoDB安装

安装MongoDB

连接MongoDB

MongoDB逻辑结构

MongoDB数据类型

小结

3 MongoDB操作

操作库和集合

操作文档-增删改

操作文档-查询

MongoDB索引

小结

4 SpringBoot整合MongoDB

介绍

使用入门

API详解

小结

MongoDB

从原型图不难看出，这部分功能主要涉及两个实体：问题和回答/评论

因此核心要设计的就是这两类数据的存储。但是问答相关的数据量比较大，且随着时间的推移会越来越大。如果使用MySQL存储海量数据，成本会比较高。因为这里使用MongoDB存储问答相关的数据

1 MongoDB介绍

MongoDB简介

MongoDB官网地址：MongoDB: The Developer Data Platform | MongoDB

MongoDB中文网：MongoDB中文网

MongoDB是一个基于分布式文档型存储的NoSQL数据库。旨在为WEB应用提供可扩展的高性能数据存储解决方案。

MongoDB由C++语言编写，是非关系数据库当中功能最丰富，最像关系数据库的，它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。

MongoDB的特点

MongoDB 最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

MongoDB像猪八戒：

不挑食：存储数据松散，对存储的数据没有要求。每一条数据都可以有完全不同的结构
干活快：性能强，对数据没有过多的校验，也支持索引，也支持热点数据的内存映射。性能比MySQL强
吃的多：存储容量大，天生是为了分布式环境设计的，非常适合搭建集群存储海量数据

MongoDB特点：

面向集合存储，易于存储对象类型的数据。“集合”相当于“表”，集合里存储的是一个个的json对象
模式自由：每个json对象的数据都可以完全不同，结构松散
支持动态查询
支持完全索引，包含内部对象
支持复制和故障恢复
使用高效的二进制数据存储，包括大型对象（如视频等）
自动处理碎片，以支持云计算层次的扩展性
支持 Python，PHP，Ruby，Java，C，C#，Javascript，Perl及C++语言的驱动程序，社区中也提供了对Erlang及.NET 等平台的驱动程序
文件存储格式为 BSON（一种 JSON 的扩展）

MongoDB使用场景

适用于

存储网站数据：

Mongo 非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
作为缓存：

由于性能很高，Mongo 也适合作为信息基础设施的缓存层。在系统重启之后，由Mongo 搭建的持久化缓存层可以避免下层的数据源过载。
存储大尺寸、低价值的数据：

使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。
高伸缩性的场景：

Mongo 非常适合由数十或数百台服务器组成的数据库，Mongo 的路线图中已经包含对MapReduce引擎的内置支持。
业务变化频繁的场景：

频繁的修改字段、增加字段等等场景，使用MongoDB的结构松散的特性，可以很方便的适应需求
用于对象及JSON 数据的存储：

Mongo 的BSON 数据格式非常适合文档化格式的存储及查询。

比如：行动轨迹的存储，例如快递物流的信息，可以存储

{
   "id": "物流单号",
   "userId": 所属用户,
   "orderId": "关联的订单id",
   "track":[
       { "地点":"xxx", "坐标":"纬度,经度", "时间":"",... },
       { "地点":"xxx", "坐标":"纬度,经度", "时间":"",... },
       ...
       { "地点":"xxx", "坐标":"纬度,经度", "时间":"",... }
   ]
}

不适用

高度事务性的系统：

例如，银行或会计系统。传统的关系型数据库目前还是更适用于需要大量原子性复杂事务的应用程序。
传统的商业智能应用：

针对特定问题的BI 数据库会产生高度优化的查询方式。对于此类应用，数据仓库可能是更合适的选择。
复杂的跨文档（表）级联查询。

MongoDB不支持多表查询

小结

MongoDB是个什么样的数据库？
   分布式的文档型NoSQL，存储的是类似json的bson格式，是所有NoSQL里功能最丰富的一个
MongoDB的特点有哪些？
   存储数据的结构松散，每一条数据都可以有不同的结构
   性能强
   适合海量数据的存储
什么场景不适合MongoDB？
   对事务要求比较高的场景
   不支持多表查询（跨集合的查询）
   不适合商业BI应用

2 MongoDB安装

我们使用的MongoDB版本是5.0.9

安装MongoDB

在Linux里执行以下命令，创建MongoDB容器。注意MongoDB的登录帐号：tjxt，密码123

#1. 停止并删除Linux里旧的容器
docker stop mongo
docker rm mongo

#2. 重新创建MongoDB容器
docker run -id --name=mongo --network heima-net \
-e MONGO_INITDB_ROOT_USERNAME=tjxt \
-e MONGO_INITDB_ROOT_PASSWORD=123 \
-p 27017:27017 \
-v /usr/local/src/mongo:/data/db \
--restart=always \
mongo

连接MongoDB

使用MongoDB官方提供的studio3t，或者 idea、DataGrip、Navicat Premium都可以连接MongoDB。我们这里仍然使用idea连接，步骤如下图。

MongoDB逻辑结构

MongoDB 的逻辑结构是一种层次结构。主要由：文档(document)、集合(collection)、数据库(database)这三部分组成的。逻辑结构是面向用户的，用户使用 MongoDB 开发应用程序使用的就是逻辑结构。

MongoDB 的文档（document），相当于关系数据库中的一行记录。
多个文档组成一个集合（collection），相当于关系数据库的表。
多个集合（collection），逻辑上组织在一起，就是数据库（database）。
一个 MongoDB 实例支持多个数据库（database）。

为了更好的理解，下面与SQL中的概念进行对比：

MongoDB数据类型

常用的数据类型有：

小结

MongoDB的结构：

DataBase：数据库
Collection：集合。一个DataBase里可以有多个Collection
   一个集合相当于一张表，但是理解为是一个List<Object>
Document：文档。一个Collection里可以有多个Document
   一个文档相当于一条数据，但是更甚为是List<Object>里的一个Object对应的json


Field：字段
Index：索引。提升查询数据的速度，但是影响增删改

MongoDB支持数据类型：

整数，小数，String，Boolean，数组，嵌套json对象，……

3 MongoDB操作

操作库和集合

语法

注意：并不需要提前创建集合，在向集合里插入文档数据时，如果集合不存在，会自动创建的

示例

//1. 创建库，名称为heima416。
// 如果库里没有任何内容，库仅仅是在内存里，没有落盘，所以查看库是看不到的。
use heima416
//2. 查看当前库
db
show dbs
//3. 删除库
db.dropDatabase()

//4. 创建集合：users。不需要显式的创建库，只要向集合里插入文档，如果集合不存在会自动创建再插入
// db.createCollection("users")
db.users.insertOne({ name:"王丛丛", age:21, sex:"男"})
//5. 查看集合
show collections
//6. 删除集合
db.users.drop()

操作文档-增删改

语法

其中的update要注意，默认情况下update操作会对原始文档进行覆盖。如果不想覆盖，而是仅仅做增量更新的话，要使用相应的操作符：

$set：设置字段的值。

例如db.表名/集合名.updateMany({}, { $set:{money:1000, status: 1} })

表示修改集合里所有的数据，把money设置为1000，把status设置为1
$inc：字段的值自增

例如db.表名/集合名.updateMany({}, {$inc: {money:1000} })

表示修改集合里所有的数据，给money值自增1000

示例

//1. 插入文档
db.users.insertOne({ name:"王丛丛", age:21, sex:"男"})
db.users.insertMany( [
{name:"齐天泽", age:22, sex:"男"},
{name:"吴磊", age:24, sex:"男"}
] )
// 使用js的语法操作MongoDB
var arr = [
{name:"齐天泽1", age:23, sex:"男"},
{name:"吴磊1", age:25, sex:"男"}
];
db.users.insertMany(arr)
// 利用js的fori循环定义数组，再批量插入
var arr1 = [];
for (let i = 0; i < 10; i++) {
arr1.push( {name:"王丛丛"+i, age: 20+i} )
}
db.users.insertMany(arr1)

//2. 修改文档。
//2.1 修改要使用操作符$set
// 只修改匹配到的第一条数据
db.users.updateOne( { age:21 }, { $set:{sex:"女"} } )
// 修改匹配到的所有数据
db.users.updateMany( { age:21 }, { $set:{sex:"男"} } )
// 修改所有数据，设置sex=男，address=北京昌平金燕龙
db.users.updateMany( { }, { $set:{sex:"男",address:"北京昌平金燕龙"} } )
//2.2 字段值自增使用$inc
db.users.updateMany( {}, { $inc:{age:1} } )

//3. 删除文档
// 删除age=21的第1条
db.users.deleteOne( {age:21} )
// 删除所有age=22的
db.users.deleteMany( { age:22 } )
// 删除所有文档数据
db.users.deleteMany( {} )

操作文档-查询

语法

其中：

query：表示查询条件，写成json形式，例如 {status:1}表示查询status=1的文档。如果需要其它条件，参考下一小节
fields：表示要查询哪些字段，写成json形式，例如 {name:1, age:1} 只查询name和age字段
排序条件：写成json形式，例如{age:1, money:-1} 表示按age升序排序，如果年龄相同则按money降序
skip(m)：表示跳过前m个，从索引m开始查找
limit(n)：表示只要前n个

条件操作符

查询条件操作符

多条件连接

示例

准备数据

db.users.remove({})
db.users.insert({username:'zhangsan', sex:'男', age:20, salary:8000})
db.users.insert({username:'lisi', sex:'女',age:21, salary:9000})
db.users.insert({username:'wangwu', sex:'男',age:22, salary:12000})
db.users.insert({username:'zhaoliu', sex:'男',age:22, salary:9500})
db.users.insert({username:'qianqi', sex:'女',age:25, salary:7500})
db.users.insert({username:'tom', sex:'男',age:19, salary:6500})
db.users.insert({username:'jerry', sex:'女',age:23, salary:8500})
db.users.insert({username:'jack', sex:'男',age:22, salary:4500})
db.users.insert({username:'rose', sex:'女',age:20, salary:14500})

使用示例

//1. 单字段的条件查询
// = 查询性别为男的 select * from users where sex = '男'
db.users.find( { sex:"男"} )
// > 查询年龄大于20岁的 select * from users where age > 20
db.users.find( { age:{$gt:20} } )
db.users.find( { age:{$gt:20, $lt:23} } )
// like 查询username以j开头的 select * from users where username like 'j%'
db.users.find( { username:{$regex:'^j.*$'} } )

// 查询符合条件的数据，只要name和salary列
db.users.find( {},{username:1, salary:1} )

//2. 多字段的条件查询
// 查询工资8000以上，年龄23岁以下的用户：salary，age
db.users.find( { salary:{$gt:8000}, age:{$lt:23} } )
// 查询工资8000以上，或者年龄23岁以下的用户：salary，age
db.users.find( { $or:[ {salary:{$gt:8000}},{age:{$lt:23}} ] } )

//3. 排序
db.users.find().sort({ salary:-1 })
db.users.find().sort({age:1})
db.users.find().sort({age:1, salary:-1})

//4. 分页
db.users.find().skip(3)
db.users.find().skip(3).limit(2)

MongoDB索引

MongoDB的索引底层使用的是B树。

mongoDB中常用的索引类型

单字段索引：在单字段上创建索引
复合索引：在多字段上创建索引
多键索引：在数组字段上创建索引
哈希索引：给指定字段建立hash索引，有强大的查找能力，但是不能排序及范围查询

mongoDB中常用的索引属性

唯一索引：添加唯一性约束
局部索引：只对集合里符合条件的一部分文档创建索引
稀疏索引：在有索引字段的文档上创建索引。例如给email字段加稀疏索引，只有文档里包含email字段才会加索引
TTL索引：一种特殊的单字段索引，只能用于date类型的字段，给文档添加过期时间，过期后文档会被删除掉

语法

示例

//查询集合里的索引
db.users.getIndexes();
//增加索引
db.users.createIndex( { username:1, age:1 } )
//查询数据时，验证索引是否会生效
db.users.find( {username:"tom"} ).explain(true);
//删除索引
db.users.dropIndex("username_1_age_1")

小结

查询所有库：show dbs
创建库/切换库：use 库名称
查询当前库：db
删除当前库：db.dropDatabase()

查看当前库里所有集合：show collections
在当前库里创建集合：
* 方式1：向集合里插入文档，如果集合不存在，就怎么创建。db.集合名.insertOne(json对象)
* 方式2：显式创建集合：db.createCollection("集合名")
删除当前库里某集合：db.集合名.drop()

操作文档增删改

//3.新增文档
db.users.insertOne({name:"李四",age:24,gender:"女"});
db.users.insertMany([
{name:"王五",age:25, gender:"男"},
{name:"赵六",age:26, email: "zl@163.com"},
{name:"钱七",age:27, gender:"女"}
]);

//var arr = [
// {name:"王五5",age:25, gender:"男"},
// {name:"赵六6",age:26, gender:"女"}
//];
//db.users.insertMany(arr);
//for(var i = 0; i<arr.length; i++){
// db.users.insertOne(arr[i]);
//}

//4. 修改文档：$set修改字段值，$inc字段值自增
db.users.updateOne( {gender:"男"}, { $set: {age:30, salary:10000} } );
db.users.updateMany( {gender:"男"}, { $set: {age:30, salary:10000} } );
db.users.updateMany( {gender:"男"}, { $inc: {salary:-5000} } );

//5. 删除文档
db.users.deleteOne( {gender:"男"} );
db.users.deleteMany( {gender:"男"} );

操作文档查询

整体的语法：
db.集合名.find( query,fields ).sort({排序字段:1或-1, 排序字段:1或-1}).skip(起始索引).limit(查询数量)
db.users.find().sort({age:-1, salary:1}).skip(5).limit(5)

查询条件：
* 以字段为单位写条件的 { 字段1:{}, 字段2:{} }
* 条件运算符：$gt, $gte, $lt, $lte, $ne, $in, $nin, $regex等等

1. 单字段的条件查询
// 查询性别为男的 select * from users where sex = '男'
db.users.find( {sex:"男"})

// 查询年龄大于20岁的 select * from users where age > 20
db.users.find( { age:{$gt:20} } )
// 查询年龄大于20，并且小于25的
db.users.find( { age:{ $gt:20, $lt:25} } )
// 查询年龄大于20，并且小于25的性别为男的
db.users.find( { age:{$gt:20, $lt:25}, sex:"男" } )

// like 查询username以j开头的 select * from users where username like 'j%'
db.users.find( { username:{ $regex: /^j.*$/ } } )

4 SpringBoot整合MongoDB

介绍

SpringBoot提供了操作MongoDB的起步依赖：spring-boot-starter-data-mongodb，已经帮我们提供了操作MongoDB的一些API，包括两种形式：

JPA形式的操作：实现了JPA规范的操作方式，简单的CURD操作更方便，但是复杂操作不够灵活

UserRepository, findByUsernameAndSex, findById
MongoTemplate形式的操作：更灵活的操作MongoDB的方式，我们使用这种方式

使用入门

使用步骤如下：

准备工作

添加起步依赖spring-boot-starter-data-mongodb

配置MongoDB的连接信息
使用入门

准备实体类

操作MongoDB

准备工作

起步依赖

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

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>


<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>

配置文件

spring:
data:
mongodb:
#uri的格式： mongodb://帐号:密码@ip:端口/库名称?authSource=admin
uri: mongodb://tjxt:123@192.168.150.101:27017/demo416?authSource=admin

使用入门

准备实体类

package com.itheima.com.itheima;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;


@Data
@Document("course")
public class Course {
    @Id
    private String id;
    private String name;
    private Integer price;
    private Integer status;
}

新增一条文档

package com.itheima;

import com.itheima.com.itheima.Course;
import com.mongodb.client.MongoIterable;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.mongodb.core.MongoTemplate;


@SpringBootTest
public class MongoTest {
    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    public void testInsert(){
        Course course = new Course();
        course.setName("Java基础");
        course.setPrice(1);
        course.setStatus(1);
		
        mongoTemplate.insert(course);
    }
}

API详解

常用方法

mongoTemplate提供了一系列操作MongoDB的常用方法：

注意其中的query和update

query：用于设置查询条件
update：用于设置要修改的数据

使用示例

package com.itheima;

import com.itheima.com.itheima.Course;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.domain.PageRequest;
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 java.util.ArrayList;
import java.util.List;

@SpringBootTest
public class MongoTest {
    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    public void testInsert() {
        Course course = new Course();
        course.setName("Java基础");
        course.setPrice(1);

        mongoTemplate.insert(course);
    }

    @Test
    public void testInsertAll() {
        List<Course> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            Course course = new Course();
            course.setName("Java基础" + i);
            course.setPrice(100 + i);

            list.add(course);
        }
        mongoTemplate.insertAll(list);
    }
    

    @Test
    public void testUpdateFirst() {
        Query query = Query.query(Criteria.where("name").is("Java基础"));
        Update update = Update.update("status", 0);
        mongoTemplate.updateFirst(query, update, Course.class);
    }

    @Test
    public void testUpdateMulti() {
        Query query = Query.query(Criteria.where("price").gt(150));
        Update update = Update.update("status", 0);
        mongoTemplate.updateMulti(query, update, Course.class);
    }

    @Test
    public void testRemove() {
        Query query = Query.query(Criteria.where("name").is("Java基础"));
        mongoTemplate.remove(query, Course.class);
    }

    @Test
    public void testFindById() {
        mongoTemplate.findById("6588372d561ff41f2377fc4e", Course.class);
    }

    @Test
    public void testFindOne() {
        Query query = Query.query(Criteria.where("name").is("Java基础1"));
        Course course = mongoTemplate.findOne(query, Course.class);
        System.out.println("course = " + course);
    }

    @Test
    public void testFindAndCount() {
        //1. 统计符合条件的文档数量
        Query query = Query
                //设置查询条件：where price > 120 and status is null
                .query(Criteria.where("price").gt(120).and("status").is(null));
        long count = mongoTemplate.count(query, Course.class);
        System.out.println("count = " + count);

        //2. 分页查询符合条件的文档列表
        query
                //设置排序条件：order by name desc
                .with(Sort.by(Sort.Order.desc("name")))
                //设置分页条件：查询第1页的10条。 注意：这里的页码从0开始
                .with(PageRequest.of(0, 10));
        List<Course> list = mongoTemplate.find(query, Course.class);
        list.forEach(System.out::println);
    }
}

小结

SpringDataMongo操作MongoDB

准备工作：
   1. 先导入依赖spring-boot-starter-data-mongodb
   2. 修改配置文件，配置MongoDB的连接地址
       spring.data.mongodb.uri=地址
       地址写法：
           mongodb://帐号:密码@服务器ip:端口/库名称?authSource=admin
           mongodb://tjxt:123@192.168.150.101:27017/demo418?authSource=admin
使用方式：
   1. 需要注入MongoTemplate对象
   2. 使用MongoTemplate操作MongoDB

操作方法的小结

//构造查询条件
//	1. 创建一个Query对象，设置where条件
//	2. 设置排序条件
//	3. 设置分页条件。页码是从0开始的
//方式1
Query query = new Query()
    .addCretiria(Criteria.where("字段名").is(值).and("字段名").gt(值)...)
    .with(Sort.by(Sort.Order.desc("字段名"), Sort.Order.asc("字段名"), ...))
    .with(PageRequest.of(页码, 每页几条));
//方式2
Query query = Query
    .query(Criteria.where("字段名").is(值).and("字段名").gt(值)...)
    .with(Sort.by(Sort.Order.desc("字段名"), Sort.Order.asc("字段名"), ...))
    .with(PageRequest.of(页码, 每页几条))

//查询
Course course = mongoTemplate.findById(id值, Course.class);
Course course = mongoTemplate.findOne(query, Course.class);
List<Course> list = mongoTemplate.find(query, Course.class);
long count = mongoTemplate.count(query, Course.class);


//构造update对象
//方式1
Update update = new Update()
    .set("字段名", 值)
    .inc("字段名", 值)...;
//方式2
Update update = Update
    .update("字段名", 值)
    .inc("字段名", 值)...;

//修改
mongoTemplate.updateFirst(query, update, Course.class);
mongoTemplate.updateMulti(query, update, Course.class);

//删除
mongoTemplate.remove(query, Course.class);

//新增
mongoTemplate.insert(对象);
mongoTemplate.insertAll(集合);