mongodb学习

xiaoxin的博客

已于 2022-08-17 23:12:13 修改

阅读量437

点赞数 2

分类专栏：数据库文章标签： mongodb 学习数据库

于 2022-08-15 18:11:20 首次发布

本文链接：https://blog.csdn.net/m0_47498874/article/details/126352044

版权

数据库专栏收录该内容

8 篇文章 0 订阅

订阅专栏

概述

文档型的NoSql数据库。MongoDB 是由C++语言编写的，是一个基于分布式文件存储的开源数据库系统。MongoDB 将数据存储为一个文档，数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档，数组及文档数组。

特点

1、对数据库高并发读写。

2、对海量数据的高效率存储和访问。

3、对数据库的高可扩展性和高可用性。

缺点：

1、数据库事务一致性需求

2、数据库的写实时性和读实时性需求

3、对复杂的SQL查询，特别是多表关联查询的需求

安装

拉取镜像

docker pull mongo:latest

生成容器并启动

docker run -d --restart=always -p 27017:27017 --name mymongo -v /data/db:/data/db -d mongo

进入容器，访问mongo

docker exec -it mymongo /bin/bash

使用mongo

mongo

show dbs#查询所有的数据库

MongoDB 概念解析

在这里插入图片描述

数据库

一个mongodb中可以建立多个数据库
常用操作：

1、 Help查看命令提示 
db.help();
2、 切换/创建数据库
use test
如果数据库不存在，则创建数据库，否则切换到指定数据库
3、 查询所有数据库 
show dbs;
4、 删除当前使用数据库 
db.dropDatabase();
5、 查看当前使用的数据库 
db.getName();
6、 显示当前db状态 
db.stats();
7、 当前db版本 
db.version();
8、 查看当前db的链接机器地址 
db.getMongo〇;

文档

文档是一组键值(key-value)对(即BSON)。MongoDB
的文档不需要设置相同的字段，并且相同的字段不需要相同的数据类型，这与关系型数据库有很大的区别，也是 MongoDB 非常突出的特点。

下表列出了 RDBMS 与 MongoDB 对应的术语：

需要注意的是：
1、文档中的键/值对是有序的。
2、文档中的值不仅可以是在双引号里面的字符串，还可以是其他几种数据类型（甚至可以是整个嵌入的文档)。
3、MongoDB区分类型和大小写。
4、MongoDB的文档不能有重复的键。
5、文档的键是字符串。除了少数例外情况，键可以使用任意UTF-8字符。
文档键命名规范：
1、键不能含有\0 (空字符)。这个字符用来表示键的结尾。
2、.和$有特别的意义，只有在特定环境下才能使用。
3、以下划线"_"开头的键是保留的(不是严格要求的)。

集合

集合就是 MongoDB 文档组，类似于 RDBMS （关系数据库管理系统：Relational Database Management
System)中的表格。
集合存在于数据库中，集合没有固定的结构，这意味着你在对集合可以插入不同格式和类型的数据，但通常情况下我们插入集合的数据都会有一定的关联性。

常用命令：
1、创建一个集合（table)
db.createCollection( “collName”);
2、得到指定名称的集合（table )
db.getCollection(“user”);

MongoDB 数据类型

下表为MongoDB中常用的几种数据类型：
在这里插入图片描述

适用场景

适用场景
1、网站数据：Mongo非常适合实时的插入，更新与查询，并具备网站实时数据存储所需的复制及高度伸缩性。
2、缓存：由于性能很高，Mongo也适合作为信息基础设施的缓存层。在系统重启之后，由M ongo搭建的持久化缓存层可以避免下层的数据源过载。
3、大尺寸，低价值的数据：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此之前，很多时候程序员往往会选择传统的文件进行存储。
4、高伸缩性的场景：Mongo非常适合由数十或数百台服务器组成的数据库。Mongo的路线图中已经包含对Map Reduce弓摩的内置支持。
5、用于对象及 JSON数据的存储：Mongo的BSON数据格式非常适合文档化格式的存储及查询。
不适用场合
1、高度事务性的系统：例如银行或会计系统。传统的关系型数据库目前还是更适用于需要大量原子性复杂事务的应用程序。
2、传统的商业智能应用：针对特定问题的BI数据库会对产生高度优化的查询方式。对于此类应用，数据仓库可能是更合适的选择。

常用操作

INSERT

db.User.save({name:'zhangsan',age:21,sex:true})
db.User.find()
{"_id": Objectld("4f69e680c9106ee2ec95da66"), "name": "zhangsan", "age": 21,
"sex": true}

_id组合
Objectld是、id”的默认类型。Objectld使用12字节的存储空间，每个字节二位十六进制数字，是一个24位的字符串
在这里插入图片描述

时间戳：时间不断变化的
机器：主机的唯_标识码。通常是机器主机名的散列值，这样可以确保不同主机生成不同的Objectld ,不产生冲突。
PID:为了确保在同一台机器上并发的多个进程产生的Objectld是唯一的，所以加上进程标识符(PID).
计数器：前9个字节保证了同一秒钟不同机器不同进程产生的Objectld是唯一的。后3个字节就是一个自动增加的计数器，确保相同进程同一秒产生的Objectld也是不一样。同一秒最多允许每个进程拥有IS 777 2托个不同的Objectld。

Query

1、WHERE

# select * from User where name = 'zhangsan'
db.User.find({name:"zhangsan"})

2、FIELDS

# select name, age from User where age = 21
> db.User.find({age:21}, {'name':1, 'age':1})

3、SORT
在 MongoDB 中使用 sort() 方法对数据进行排序，sort() 方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列。

# select * from User order by age
> db.User.find().sort({age:1})

4、SUCE
在 MongoDB 中使用 limit()方法来读取指定数量的数据，skip()方法来跳过指定数量的数据

# select * from User skip 2 limit 3
> db.User.find().skip(0).limit(3)

5、IN

# select * from User where age in (21, 26, 32)
> db.User.find({age:{$in:[21,26,32]}})

6、COUNT

# select count(*) from User where age >20
> db.User.find({age:{$gt:20}}).count()

7、0R

# select * from User where age = 21 or age = 28
> db.User.find({$or:[{age:21}, {age:28}]})

Update

可直接用类似T-SQL条件表达式更新，或用SaveO更新从数据库返回到文档对象。

# update Userset age = 100, sex = 0 where name = 'user1'
> db.User.update({name:"zhangsan"}, {$set:{age:100, sex:0}})

Update()有几个参数需要注意。

db.collection.update(criteria, objNew, upsert, mult)
criteria:需要更新的条件表达式
objNew:更新表达式 upsert:如FI标记录不存在，是否插入新文档。
multi:是否更新多个文档。

Remove

removeO用于删除单个或全部文档，删除后的文档无法恢复。

> db.User.remove(id)
//移除对应id的行
> db.User.remove({})
//移除所有

aggregate

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)

插入数据

>db.article.insert({
    title: 'MongoDB Overview', 
   description: 'MongoDB is no sql database',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 100
})
>db.article.insert({
   title: 'NoSQL Overview', 
   description: 'No sql database is very fast',
   by_user: 'runoob.com',
   url: 'http://www.runoob.com',
   tags: ['mongodb', 'database', 'NoSQL'],
   likes: 10
})
>db.article.insert({
   title: 'Neo4j Overview', 
   description: 'Neo4j is no sql database',
   by_user: 'Neo4j',
   url: 'http://www.neo4j.com',
   tags: ['neo4j', 'database', 'NoSQL'],
   likes: 750
})

统计sum
现在我们通过以上集合计算每个作者所写的文章数

# select by_user, count(*) from article group by by_user
> db.article.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])

{
"result" : [
      {
"_id" : "runoob.com",
"num_tutorial" : 2
      },
      {
"_id" : "Neo4j",
"num_tutorial" : 1
      }
   ],
"ok" : 1
}

在上面的例子中，我们通过字段 by_user 字段对数据进行分组，并计算 by_user 字段相同值的总和。

常见的聚合表达式

在这里插入图片描述

索引

索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。
这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构。

>db.User.createIndex({"name":1})

语法中 name值为你要创建的索引字段，1 为指定按升序创建索引，如果你想按降序来创建索引指定为 -1 即可

集成mongodb

spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongodb，MongoRepository操作简单，MongoTemplate操作灵活，我们在项目中可以灵活适用这两种方式操作mongodb，MongoRepository的缺点是不够灵活，MongoTemplate正好可以弥补不足

MongoTemplate

添加依赖

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

添加mongo配置

#mongo 配置

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

实体类

@Data
@Document("User")
public class User {
 @Id
 private String id;
 private String name;
 private Integer age;
 private String email;
 private String createDate;
 
}

常用方法

mongoTemplate.findAll(User.class): 查询User文档的全部数据
mongoTemplate.findById(<id>, User.class): 查询User文档id为id的数据
mongoTemplate.find(query, User.class);: 根据query内的查询条件查询
mongoTemplate.upsert(query, update, User.class): 修改
mongoTemplate.remove(query, User.class): 删除
mongoTemplate.insert(User): 新增

Query对象

1、创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
2、 精准条件：criteria.and(“key”).is(“条件”)
    模糊条件：criteria.and(“key”).regex(“条件”)
3、封装条件：query.addCriteria(criteria)
4、大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）
   小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）
5、Query.addCriteria(new Criteria().andOperator(gt,lt));
6、一个query中只能有一个andOperator()。其参数也可以是Criteria数组。
7、排序 ：query.with（new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))

@RestController
@RequestMapping("/mongo1")
class TestMongo1 {
 
    @Autowired
    private MongoTemplate mongoTemplate;
 
    //新增
    @GetMapping("create")
    private void create(){
        User user = new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("4932200@qq.com");
        User user1 = mongoTemplate.insert(user);
        System.out.println("user1 = " + user1);
    }
 
    //查询所有
    @GetMapping("findAll")
    private void findAll(){
        List<User> users = mongoTemplate.findAll(User.class);
        users.forEach(System.out::println);
    }
 
    //根据id查询
    @GetMapping("findById")
    private void findById(){
        User user = mongoTemplate.findById("62d7a40acbe5f410de8cc636", User.class);
        System.out.println("user = " + user);
    }
 
    //条件查询
    @GetMapping("findUser")
    private void findUserList(){
        Query query = new Query(
                Criteria.where("name").is("test")
                        .and("age").is(20));
 
        List<User> users = mongoTemplate.find(query, User.class);
        users.forEach(System.out::println);
    }
 
    //模糊查询
    @GetMapping("findLike")
    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));
        List<User> users = mongoTemplate.find(query, User.class);
        users.forEach(System.out::println);
    }
 
    //分页查询
    @GetMapping("findPage")
    public void findUsersPage() {
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        int pageNo = 1;
        int pageSize = 10;
 
        //模糊查询
        Pattern pattern = Pattern.compile(regex,Pattern.CASE_INSENSITIVE);
        Query query = new Query(
                Criteria.where("name").regex(pattern));
        //总记录数
        long total = mongoTemplate.count(query, User.class);
        //分页条件设置
        query.skip((pageNo-1)*pageSize).limit(pageSize);
 
        List<User> users = mongoTemplate.find(query, User.class);
        users.forEach(System.out::println);
        System.out.println("total = " + total);
    }
 
    //修改
    @GetMapping("update")
    public void updateUser() {
        User user = mongoTemplate.findById("62d7a40acbe5f410de8cc636", User.class);
        user.setName("test_1");
        user.setAge(25);
        user.setEmail("493220990@qq.com");
        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);
        long count = result.getModifiedCount();
        System.out.println(count);
    }
 
    //删除操作
    @GetMapping("delete")
    public void delete() {
        Query query =
                new Query(Criteria.where("_id").is("62d7a40acbe5f410de8cc636"));
        DeleteResult result = mongoTemplate.remove(query, User.class);
        long count = result.getDeletedCount();
        System.out.println(count);
    }
 
 
}

MongoRepository

添加Repository类

参数：实体类，主键类型

@Repository
public interface UserRepository extends MongoRepository<User, String> {
}

编写测试类

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

package com.atguigu.yygh.hosp.testmongo;
 
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.*;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.util.List;
 
@RestController
@RequestMapping("/mongo2")
public class TestMongo2 {
 
    @Autowired
    private UserRepository userRepository;
 
    //添加
    @GetMapping("create")
    public void createUser() {
        User user = new User();
        user.setAge(20);
        user.setName("张三");
        user.setEmail("3332200@qq.com");
        User user1 = userRepository.save(user);
        System.out.println("user1 = " + user1);
    }
    //查询所有
    @GetMapping("findAll")
    public void findAll() {
        List<User> users = userRepository.findAll();
        users.forEach(System.out::println);
    }
 
    //根据id查询
    @GetMapping("findById")
    public void findById(){
        User user = userRepository.findById("62d7a40acbe5f410de8cc636").get();
        System.out.println(user);
    }
 
    //根据条件查询
    @GetMapping("findUser")
    public void findUserList(){
        User user = new User();
        user.setName("张三");
        user.setAge(20);
 
        Example<User> example = Example.of(user);
        List<User> users = userRepository.findAll(example);
        users.forEach(System.out::println);
    }
 
    //模糊查询
    @GetMapping("findLike")
    public void findUsersLikeName() {
        User user = new User();
        user.setName("三");
 
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)
                .withIgnoreCase(true);
 
        Example<User> example = Example.of(user,matcher);
        List<User> users = userRepository.findAll(example);
        users.forEach(System.out::println);
    }
 
    //分页查询
    @GetMapping("findPage")
    public void findUsersPage() {
        Sort sort = Sort.by(Sort.Direction.DESC, "age");
        //第一页从零开始
        Pageable pageable = PageRequest.of(0,10,sort);
 
        User user = new User();
        user.setName("三");
 
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING) //改变默认字符串匹配方式：模糊查询
                .withIgnoreCase(true);//改变默认大小写忽略方式：忽略大小写
        //创建实例
        Example<User> example = Example.of(user,matcher);
        Page<User> userPage = userRepository.findAll(example, pageable);
 
        System.out.println(userPage.getTotalElements());
        userPage.getContent().forEach(System.out::println);
    }
 
    //修改
    @GetMapping("update")
    public void updateUser() {
        User user = userRepository.findById("62d7b1624868d359d7cd3e24").get();
        user.setName("张三_1");
        user.setAge(25);
        user.setEmail("883220990@qq.com");
        User save = userRepository.save(user);
        System.out.println(save);
    }
 
    //删除
    @GetMapping("delete")
    public void delete() {
        userRepository.deleteById("60b8d57ed539ed5b124942de");
    }
 
 
}