MongoDB手册

本文最后更新于:2021年3月26日 上午

一、简介

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

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

image-20210324102254646

⚡ 安装

# 拉取镜像 
docker pull mongo:latest

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

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

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

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

⚡ 数据库

一个mongodb中可以建立多个数据库,常见操作有:

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

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

# 查询所有数据库 
show dbs;

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

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

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

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

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

⚡ 文档

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

  • 键是字符串,且不可重复

  • 值不仅可以是在双引号里面的字符串,还可以是其他几种数据类型(甚至可以是整个嵌入的文档)。

2、MongoDB区分类型和大小写

3.键命名规范:

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

⚡ 集合

集合就是 MongoDB 文档组,一般没有固定的结构,这意味着你在对集合可以插入不同格式和类型的数据,但通常情况下我们插入集合的数据都会有一定的关联性。

# 创建一个集合(table)
db.createCollection( "collName");

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

⚡ 数据类型

数据类型 描述
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 正则表达式类型。用于存储正则表达式。

⚡ 适用场景

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

  • 缓存:由于性能很高,Mongo也适合作为信息基础设施的缓存层。在系统重启之后,由Mongo搭建的持久化缓存层可以避免下层的数据源过载。

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

  • 高伸缩性的场景:Mongo非常适合由数十或数百台服务器组成的数据库。Mongo的路线图中已经包含对Map Reduce弓摩的内置支持。

  • 用于对象及JSON数据的存储:Mongo的BSON数据格式非常适合文档化格式的存储 及查询。

不适用场合:

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

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

SpringBoot集成

⚡ 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>
  • 添加Mongo服务器路径

    # application.properties
    
    spring.data.mongodb.uri=mongodb://42.192.52.14:27017/test

⚡ 基于 MongoTemplate 开发 CRUD

  • 创建User实体类

    @Data
    @Document("User")
    public class User {
        @Id
        private String id;
        private String name;
        private Integer age;
        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());
    }

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