MongoDB手册

本文最后更新于：2021年6月24日 晚上

一、MongoDB 概述

MongoDB 是一个面向文档存储的非关系型数据库，数据由键值对组成。

SQL术语/概念 MongoDB术语/概念 解释/说明
database database 数据库
table/表 collection/集合 数据库表/集合
row/行 document/文档 数据记录行/文档
column/列 field/字段 数据字段/域
index index 索引
table joins 表连接,MongoDB不支持
primary key primary key 主键,MongoDB自动将_id字段设置为主键

databaseName + collectionName 组成nameSpace

⚡ 适用场景

  • 数据量大且频繁读写的数据：MongoDB非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。

  • 占用内存空间大、但价值较低的数据，对事务要求性不高：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。

  • 高伸缩性的场景：MongoDB非常适合由数十或数百台服务器组成的数据库。MongoDB的路线图中已经包含对Map Reduce弓摩的内置支持；MongoDB的BSON数据格式非常适合文档化格式的存储 及查询。

不适用场合：

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

  • 传统的商业智能应用：针对特定问题的BI数据库会对产生高度优化的查询方式。对于此类应用，数据仓库可能是更合适的选择。

⚡ 安装

# 拉取镜像 
docker pull mongo:latest

# 创建和启动容器(端口27017、名字mymongo、配置文件地址) 
docker run -d --restart=always -p 27017:27017 --name mongodb -v /mydata/mongo/db:/data/db -d mongo

# 以交互形式进入容器 
docker exec -it mongodb /bin/bash 

# 使用MongoDB客户端进行操作 
mongo 

> show dbs #查询所有的数据库 
admin 0.000GB 
config 0.000GB 
local 0.000GB

⚡ database 数据库

一个MongoDB中可以建立多个数据库，常见操作有：

# Help查看命令提示 
db.help();

# 切换/创建数据库(如果数据库不存在，则创建数据库，否则切换到指定数据库)
use test

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

# 查询所有数据库 
show dbs;

# 查看当前使用的数据库 
db.getName();

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

# 当前db版本 
db.version();

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

⚡ collection 集合

集合就是 MongoDB 文档组，可以向集合中插入不同格式和类型的数据。但通常情况下我们插入集合的数据都会有一定的关联性。

  • 隐式创建： 当向集合中插入一个文档时，如果集合不存在，则会自动创建集合
# 创建一个集合（table)
db.createCollection( "collName");

# 得到指定名称的集合（table )
db.getCollection("user");

show collections;
show tables;

db.collectionName.drop()

⚡ document 文档

支持的数据类型

数据类型 描述
String 字符串。存储数据常用的数据类型。在 MongoDB 中，UTF-8 编码的字符串才是合法的。
Integer 整型数值。用于存储数值。根据你所采用的服务器，可分为 32 位或 64 位。
Boolean 布尔值。用于存储布尔值（真/假）。
Double 双精度浮点值。用于存储浮点值。
Min/Max keys 将一个值与 BSON（二进制的 JSON）元素的最低值和最高值相对比。
Arrays 用于将数组或列表或多个值存储为一个键。
Timestamp 时间戳。记录文档修改或添加的具体时间。
Object 用于内嵌文档。
Null 用于创建空值。
Symbol 符号。该数据类型基本上等同于字符串类型，但不同的是，它一般用于采用特殊符号类型的语言。
Date 日期时间。用 UNIX 时间格式来存储当前日期或时间。你可以指定自己的日期时间：创建 Date 对象，传入年月日信息。
Object ID 对象 ID。用于创建文档的 ID。
Binary Data 二进制数据。用于存储二进制数据。
Code 代码类型。用于在文档中存储 JavaScript 代码。
Regular expression 正则表达式类型。用于存储正则表达式。

📖 插入数据

db.comment.insert({
    "articleid":"100000",
    "content":"今天天气真好，阳光明 媚",
    "userid":"1001",
    "nickname":"Rose",
    "createdatetime":new Date(),
    "likenum":NumberInt(10),
    "state":null
})

# comment集合不存在时，会自动创建
# mongo中的数字，默认为double类型，如果要存整型，需使用NumberInt函数
# 插入的数据没有指定_id，会自动生成主键值
# 如果某个字段为null，可以赋值为null，或者直接不写该字段

1、文档中的键/值对是有序的

  • 键是不可重复的字符串，值的类型可以是包含String、Integer甚至内嵌文档在内的多种类型
  • 区分类型和大小写。

2、键命名规范：

  • 键不能含有\0 (空字符)。这个字符用来表示键的结尾。
  • .和$有特别的意义，只有在特定环境下才能使用
  • 以下划线_开头的键是保留的(不是严格要求的)

📖 批量插入数据

db.comment.insertMany([ {"_id":"1","articleid":"100001","content":"我们不应该把清晨浪费在手机上，健康很重要，一杯温水幸福你我他。","userid":"1002","nickname":"相忘于江湖","createdatetime":new Date("2019-0805T22:08:15.522Z"),"likenum":NumberInt(1000),"state":"1"}, 

{"_id":"2","articleid":"100001","content":"我夏天空腹喝凉开水，冬天喝温开水","userid":"1005","nickname":"伊人憔悴","createdatetime":new Date("2019-08-05T23:58:51.485Z"),"likenum":NumberInt(888),"state":"1"}, 

{"_id":"3","articleid":"100001","content":"我一直喝凉开水，冬天夏天都喝。","userid":"1004","nickname":"杰克船长","createdatetime":new Date("2019-08-06T01:05:06.321Z"),"likenum":NumberInt(666),"state":"1"}, 

{"_id":"4","articleid":"100001","content":"专家说不能空腹吃饭，影响健康。","userid":"1003","nickname":"凯
撒","createdatetime":new Date("2019-08-06T08:18:35.288Z"),"likenum":NumberInt(2000),"state":"1"},

{"_id":"5", "articleid":"100001", "content":"研究表明，刚烧开的水千万不能喝，因为烫嘴。", "userid":"1003", "nickname":"凯撒", "createdatetime":new Date("2019-0806T11:01:02.521Z"), "likenum":NumberInt(3000), "state":"1"}
]);
  • 插入时指定了_id，则主键就是该值。
  • 如果某条数据插入失败，将会终止插入，但已经插入成功的数据不会回滚掉。

📖 查询数据

db.collectionName.find(<query>, [projection])
 
db.comment.find()   # 查询comment集合中的所有文档（包含全部字段）
db.comment.find({userid:'1003'}) 
db.comment.findOne({userid:'1003'})  # 查询满足条件的第一条数据

db.comment.find({userid:"1003"},{userid:1,nickname:1}) # 查询结果仅包含默认字段_id和userid、nickname字段
db.comment.find({userid:"1003"},{userid:1,nickname:1,_id:0})  # 查询结果不显示_id字段

📖 常用命令小结

  • 选择切换数据库：use articledb
  • 插入数据：db.comment.insert({bson数据})
  • 查询所有数据：db.comment.find();
  • 条件查询数据：db.comment.find({条件})
  • 查询符合条件的第一条记录：db.comment.findOne({条件})
  • 查询符合条件的前几条记录：db.comment.find({条件}).limit(条数)
  • 查询符合条件的跳过的记录：db.comment.find({条件}).skip(条数)
  • 修改数据：db.comment.update({条件},{修改后的数据}) 或db.comment.update({条件},{$set:{要修改部分的字段:数据})
  • 修改数据并自增某字段值：db.comment.update({条件},{$inc:{自增的字段:步进值}})
  • 删除数据：db.comment.remove({条件})
  • 统计查询：db.comment.count({条件})
  • 模糊查询：db.comment.find({字段名:/正则表达式/})
  • 条件比较运算：db.comment.find({字段名:{$gt:值}})
  • 包含查询：db.comment.find({字段名:{$in:[值1，值2]}})或db.comment.find({字段名:{$nin:[值1，值2]}})
  • 条件连接查询：db.comment.find({$and:[{条件1},{条件2}]})或db.comment.find({$or:[{条件1},{条件2}]})

二、MongoDB 索引

MongoDB基于BTree而不是B+Tree实现索引。

  • BTree：数据存放在整棵树上
  • B+Tree：数据仅存放在叶子节点上，查询任何数据时都需从root走到叶子节点，查询性能稳定

⚡ 索引类型

  • 单字段索引：在文档的单个字段上创建索引

  • 联合索引：如下图所示的联合索引，先按照字段userid顺序排序，再按照字段score逆序排序

⚡ 管理索引

  • 创建索引

    db.collectionName.createIndex(keys, options)

# 为userid字段创建升序索引
db.comment.createIndex({userid:1});
{"createdCollectionAutomatically" : false, "numIndexesBefore" : 1, "numIndexesAfter" : 2, "ok" : 1}

# userid字段和nickname字段创建联合索引，先按userid升序，再按nickname降序
db.comment.createIndex({userid:1,nickname:-1})

  • 查看索引

    db.comment.getIndexes()

  • 删除索引

    db.comment.dropIndex({userid:1})   # 删除指定索引
db.comment.dropIndexes()   # 删除索引索引（默认字段_id的索引是无法删除的）

⚡ 通过Explain查看是否使用了索引

  • 和MySQL一样，通过explain可查看执行计划
> db.comment.find({userid:"1003"}).explain(); 
{
    "queryPlanner" : { 
        "plannerVersion" : 1, 
        "namespace" : "articledb.comment", 
        "indexFilterSet" : false, 
        "parsedQuery" : { "userid" : { "$eq" : "1003"}},
        "winningPlan" : { 
            "stage" : "COLLSCAN",  # 全集合扫描
            "filter" : { "userid" : { "$eq" : "1003"}},
            "direction" : "forward"},
        "rejectedPlans" : [ ]
    },
    "serverInfo" : { 
        "host" : "9ef3740277ad", "port" : 27017, "version" : "4.0.10", 
        "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
    }, 
    "ok" : 1
}

通过winningPlan中的stage字段，可以看到没索引时，mongoDB会进行全集合的扫描

但如果对userid字段创建了索引，此语句在执行时就会走索引

> db.comment.createIndex({userid:1});
{
	"createdCollectionAutomatically" : false,
	"numIndexesBefore" : 1, 
	"numIndexesAfter" : 2, 
	"ok" : 1
}


> db.comment.find({userid:"1003"}).explain(); 
{
    "queryPlanner" : { 
        "plannerVersion" : 1, 
        "namespace" : "articledb.comment", 
        "indexFilterSet" : false, 
        "parsedQuery" : { "userid" : { "$eq" : "1003"}},
        "winningPlan" : { 
        	"stage" : "FETCH",  # 走索引
        	"inputStage" : { 
        		"stage" : "IXSCAN", 
        		"keyPattern" : { "userid" : 1}, 
        		"indexName" : "userid_1",  # 索引名称
        		"isMultiKey" : false,   # 是否为复合索引
        		"multiKeyPaths" : { "userid" : [ ]}, 
        		"isUnique" : false, 
        		"isSparse" : false, 
        		"isPartial" : false, 
        		"indexVersion" : 2, 
        		"direction" : "forward", 
        		"indexBounds" : { "userid" : [ "[\"1013\", \"1013\"]"] } 
        	}
		},
        "rejectedPlans" : [ ]
    },
    "serverInfo" : { 
        "host" : "9ef3740277ad", "port" : 27017, "version" : "4.0.10", 
        "gitVersion" : "c389e7f69f637f7a1ac3cc9fae843b635f20b766"
    }, 
    "ok" : 1
}

三、SpringBoot集成 MongoDB

⚡ Demo环境搭建

  • 创建SpringBoot工程

  • 引入依赖

    <dependencies>
    <!-- MongoDB 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.1</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

  • 添加MongoDB服务器路径

    # application.properties

spring.data.mongodb.uri=mongodb://42.192.52.14:27017/test

⚡ 基于 MongoTemplate 开发 CRUD

  • 创建User实体类

    • @Document(collection="mongodb 对应 collection 名")：将Java类声明为mongoDB的文档。若省略了Document注释，默认使用『类的小写』和mongoDB文档进行映射
    • @Id：主键标识，该属性的值会自动对应mongodb的主键字段”_id”。如果该成员变量名就叫“id”，则该注解可以省略，否则必须写
    • @Field：将成员变量和mongoDB的字段进行映射。如果两者一致，可以省略不写。
    • @Indexed：单字段的索引
    • @CompoundIndex( def = "{'userid': 1, 'nickname': -1}")：创建userid字段和nickname字段的联合索引
    @Data  // Lombok的注解，自动为成员变量生成set、get等方法
@Document("User")  // 将java类声明为mongoDB的文档
public class User {
    @Id
    private String id;
    @Indexed
    private String name;
    private Integer age;
    @Field("e-mail")
    private String email;
    private String createDate;
}

  • 测试

    @SpringBootTest
class MongodbDemoApplicationTests {

    /*
    * MongoTemplate常用方法：
    *       mongoTemplate.insert(User): 新增
    *       mongoTemplate.remove(query, User.class): 删除
    *       mongoTemplate.upsert(query, update, User.class): 修改
    *
    *       mongoTemplate.findAll(User.class): 查询User文档的全部数据
    *       mongoTemplate.findById(<id>, User.class): 查询User文档id为id的数据
    *       mongoTemplate.find(query, User.class): 根据query内的查询条件查询
    
    *       Query对象
    *            1、创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
    *                 精准条件：criteria.and(“key”).is(“条件”)
    *                 模糊条件：criteria.and(“key”).regex(“条件”)
    *                对条件进行封装：query.addCriteria(criteria)
    *            2、一个query中只能有一个andOperator()，其参数也可以是Criteria数组：
    *               大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）
    *               小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）
    *               Query.addCriteria(new Criteria().andOperator(gt,lt));
    *            3、排序 ：query.with（new Sort(Sort.Direction.ASC, "age").and(new Sort(Sort.Direction.DESC, "date")))
    * */
    
    @Autowired
    private MongoTemplate mongoTemplate;

    // 1.新增数据
    @Test
    void createUser(){
        User user = new User();
        user.setAge(24);
        user.setName("test");
        user.setEmail("462549693@qq.com");
        User user1 = mongoTemplate.insert(user);
        System.out.println(user1);
        // { "_id" : ObjectId("605a8ac3086e2a4fce140863"), "name" : "gaowl", "age" : 24, "email" : "462549693@qq.com", "_class" : "com.gaowl.mongo.entity.User" }

    }

    // 2.删除（移除满足条件的对象）
    @Test
    public void delete() {
        Query query = new Query(Criteria.where("_id").is("605a8c7f75110d71d67e5b34"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        long count = result.getDeletedCount();
        System.out.println(count);
    }

    // 3.修改
    @Test
    void update(){
        User user = mongoTemplate.findById("605a8ac3086e2a4fce140863", User.class);
        user.setEmail("1123@163.com");
        user.setAge(25);
        Query query = new Query(Criteria.where("_id").is(user.getId()));
        Update update = new Update();
        update.set("name", user.getName());
        update.set("age", user.getAge());
        update.set("email", user.getEmail());

        UpdateResult result = mongoTemplate.upsert(query, update, User.class);
        System.out.println(result);
        System.out.println(result.getModifiedCount());

    }

    // 4.1 查询所有
    @Test
    void findUser() {
        List<User> userList = mongoTemplate.findAll(User.class);
        System.out.println(userList);
    }

    // 4.2 根据id查询
    @Test
    void getById() {
        User user = mongoTemplate.findById("605a8c9d073a121b693616af", User.class);
        System.out.println(user);
    }

    // 4.3 条件查询
    @Test
    public void findUserList(){
        Query query = new Query(Criteria.where("name").is("test").and("age").is(24));  // 别导错包
        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);

    }

    // 4.4 模糊查询
    @Test
    public void findUsersLikeName() {
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$"); //
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Query query = new Query(Criteria.where("name").regex(pattern));  // name需符合该正则表达式

        List<User> userList = mongoTemplate.find(query, User.class);
        System.out.println(userList);
    }

    // 4.5 分页查询
    @Test
    void findUserPage(){
        String name = "est";
        int pageNo = 1;
        int pageSize = 2;

        Query query = new Query();
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        query.addCriteria(Criteria.where("name").regex(pattern));
        int totalCount = (int) mongoTemplate.count(query, User.class);  // 查询符合条件的数据的数量
        List<User> userList = mongoTemplate.find(query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);  // 跳过多少、每页显示多少

        Map<String, Object> pageMap = new HashMap<>();
        pageMap.put("list", userList);   // 将查询到的数据存放到pageMap中
        pageMap.put("totalCount",totalCount);
        System.out.println(pageMap);
    }
}

⚡ 基于 MongoRepository 开发 CRUD

Spring Data提供了对mongodb数据访问的支持，只需要继承MongoRepository接口，按照Spring Data规范就可以了.

  • 添加Repository接口

    package com.gaowl.mongo.respository;

import com.gaowl.mongo.entity.User;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;

// 泛型中前者为实体类，后者为id
@Repository
public interface UserRepository extends MongoRepository<User, String> {

}

  • 测试

    /*
*  基于MongoRepository开发CRUD
*       userRepository.save(Object object)  新增/修改
*       userRepository.deleteById(String id)   根据id删除
*       userRepository.findById(String id).get()  根据id查询
*       userRepository.findAll()    查询所有
*
*       Example<User> userExample = Example.of(user);
*       userRepository.findAll(userExample)  查询所有符合条件的
*
*       Example<User> userExample = Example.of(user, matcher);
*       List<User> userList = userRepository.findAll(userExample);  //  模糊查询
*
*       Example<User> example = Example.of(user, matcher);
*       Page<User> pages = userRepository.findAll(example, pageable);  // 分页查询
*
* */

@Autowired
private UserRepository userRepository;

// 1.添加数据
@Test
public void createUser2() {
    User user = new User();
    user.setAge(20);
    user.setName("张三");
    user.setEmail("3332200@qq.com");
    User user1 = userRepository.save(user);
    System.out.println(user1);
}

// 2.删除数据
@Test
public void delete2() {
    userRepository.deleteById("605a93543bffd80c433a3eb9");
}

// 3.修改（先拿到符合条件的元素，然后设置需要更新的元素，最后保存即可）
@Test
public void updateUser() {
    User user = userRepository.findById("605a989045bb635d62144264").get();
    user.setName("张三_1");
    User save = userRepository.save(user);
    System.out.println(save);
}

// 4.1 查询所有
@Test
public void findUser2() {
    List<User> userList = userRepository.findAll();   // 之前声明UserRepository时已经传入了User类，因此不同于MongoTemplate（其此处还得传入User.class）
    System.out.println(userList);
}

// 4.2 根据id查询
@Test
public void getById2() {
    User user = userRepository.findById("605a8ac3086e2a4fce140863").get();
    System.out.println(user);
}

// 4.3 条件查询（条件的属性用条件关键字连接、条件属性首字母大写）
@Test
public void findUserList2() {
    User user = new User();
    user.setName("test");
    user.setAge(24);
    Example<User> userExample = Example.of(user);  // 样例

    List<User> userList = userRepository.findAll(userExample);
    System.out.println(userList);
}

// 4.4 模糊查询
@Test
public void findUsersLikeName2() {
    //创建匹配器，即如何使用查询条件
    ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
            .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
            .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
    User user = new User();
    user.setName("三");
    Example<User> userExample = Example.of(user, matcher);

    List<User> userList = userRepository.findAll(userExample);
    System.out.println(userList);
}

// 4.5 分页查询
@Test
public void findUsersPage() {
    Sort sort = Sort.by(Sort.Direction.DESC, "age");  // 年龄降序
    Pageable pageable = PageRequest.of(0, 4, sort);  // 0为第一页，每页4个

    //创建匹配器，即如何使用查询条件
    ExampleMatcher matcher = ExampleMatcher.matching() //构建对象
            .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
            .withIgnoreCase(true); //改变默认大小写忽略方式：忽略大小写
    User user = new User();
    user.setName("test");

    //创建实例
    Example<User> example = Example.of(user, matcher);
    Page<User> pages = userRepository.findAll(example, pageable);
    System.out.println(pages.getContent());
}

四、副本集

五、分片集群

六、安全认证

分片是将数据水平切分到不同的物理节点。当应用数据越来越大的时候，数据量也会越来越大。当数据量增长时，单台机器有可能无法存储数据或可接受的读取写入吞吐量。利用分片技术可以添加更多的机器来应对数据量增加以及读写操作的要求。

MongoDB 事务

  • 单行事务：原子更新一个文档中的多个字段；

  • 副本集的跨行事务(v4.0)：在副本集上，跨多个文档、多个表、多个 DB 的多个操作保持原子性

  • 集群的跨行事务(v4.2)：在分片集群上，跨多个文 档、多个表、多个 DB 的多个操作保持原子性

  • 事务包含部分 DDL(v4.4)：包括创建表和索引。

image-20210616105314746

（1）单行事务

image-20210616105930719

数据文档如下

_id: ObjectId( “57d7a121fa937f710a7d4877”)
last_name: “Turner” 
quote: “Vero iste odit voluptas sunt harum totam.” 
job: “Purchasing manager” 
ssn: “579-34-3243” 
address: Object 
	city: “Kellyhaven” 
	street: “3096 Jones Parkway Suite 928”
	zip: “09697”
first_name: “Nicholas”
company_id: ObjectId( “57d7a121fa937f710a7d486d”)
employer: “Terry and Sons” 
birthday: 2013-06-26T12: 59: 01.000+00: 00 
email: “steven03@hancock.info”
数据库
MongoDB

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议 ，转载请注明出处！