mongodb 订阅
MongoDB是一个基于分布式文件存储 [1]  的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。 展开全文
MongoDB是一个基于分布式文件存储 [1]  的数据库。由C++语言编写。旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。它支持的数据结构非常松散,是类似json的bson格式,因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。
信息
特    点
高性能,易部署,易使用
编写语言
由C++语言编写
产品类型
基于分布式文件存储的数据库
外文名
MongoDB
mongodb特点
它的特点是高性能、易部署、易使用,存储数据非常方便。主要功能特性有:*面向集合存储,易存储对象类型的数据。 *模式自由。*支持动态查询。*支持完全索引,包含内部对象。*支持查询。*支持复制和故障恢复。*使用高效的二进制数据存储,包括大型对象(如视频等)。*自动处理碎片,以支持云计算层次的扩展性。*支持 Golang,RUBY,PYTHON,JAVA,C++,PHP,C#等多种语言。*文件存储格式为BSON(一种JSON的扩展)。*可通过网络访问。
收起全文
精华内容
下载资源
问答
  • mongodb
    千次阅读 多人点赞
    2022-03-29 17:25:54

    1. MongoDB概述

    1.1 MongoDB简介

    什么是MongoDB ? MongoDB 是由C++语言编写的,是一个基于分布式文件存储的开源数据库系统。
    mongodb官网地址:https://www.mongodb.org.cn/

    1.2 MongoDB概念

    不管我们学习什么数据库都应该学习其中的基础概念,在mongodb中基本的概念是文档、集合、数据库,下面我们挨个介绍。
    MongoDB概念解析:https://www.mongodb.org.cn/tutorial/6.html

    下表将帮助您更容易理解Mongo中的一些概念:

    SQL术语/概念MongoDB术语/概念解释/说明
    databasedatabase数据库
    tablecollection数据库表/集合
    rowdocument数据记录行/文档
    columnfield数据字段/域
    indexindex索引
    table joins表连接,MongoDB不支持
    primary keyprimary key主键,MongoDB自动将_id字段设置为主键

    数据库
    一个mongodb中可以建立多个数据库。MongoDB的默认数据库为"db",该数据库存储在data目录中。MongoDB的单个实例可以容纳多个独立的数据库,每一个都有自己的集合和权限,不同的数据库也放置在不同的文件中。

    文档
    文档是一个键值(key-value)对(即BSON)。MongoDB 的文档不需要设置相同的字段,并且相同的字段不需要相同的数据类型,这与关系型数据库有很大的区别,也是 MongoDB 非常突出的特点。
    在这里插入图片描述集合
    集合就是 MongoDB 文档组,类似于 RDBMS (关系数据库管理系统:Relational Database Management System)中的表格。
    集合存在于数据库中,集合没有固定的结构,这意味着你在对集合可以插入不同格式和类型的数据,但通常情况下我们插入集合的数据都会有一定的关联性。

    元数据
    数据库的信息是存储在集合中。它们使用了系统的命名空间。

    MongoDB 数据类型
    在这里插入图片描述

    2. MongoDB安装

    2.1 MongoDB下载

    MongoDB下载:https://www.mongodb.com/try/download

    1.打开官网地址
    在这里插入图片描述2.选择版本与下载格式
    在这里插入图片描述

    2.2 MongoDB安装

    window平台安装 MongoDB:https://www.mongodb.org.cn/tutorial/55.html
    Linux平台安装MongoDB:https://www.mongodb.org.cn/tutorial/56.html

    2.3 MongoDB启动服务

    启动Mongodb服务:https://www.mongodb.org.cn/tutorial/59.html
    window平台在你的安装目录/bin下,有一个叫mongod.exe的应用程序,这个程序就是用来启动你的mongodb服务器的。

    F:\>mongodb/bin
    F:\mongodb\bin>mongod --path=/data/db
    

    3. MongoDB操作

    3.1 MongoDB数据增删

    MongoDB数据增删:https://www.mongodb.org.cn/tutorial/8.html

    3.2 MongoDB高级查询

    MongoDB高级查询:https://www.mongodb.org.cn/tutorial/34.html

    4. MongoDB客户端工具

    4.1 Studio 3T

    Studio 3T官网下载地址:https://studio3t.com/download/
    超过 100,000 的开发人员和数据库管理员使用 Studio 3T 作为 MongoDB GUI 的首选。Studio 3T 属于收费工具,30 天的免费试用期,Studio 3T 具有更多更强大的功能并提供企业支持服务,支持副本集、独立主机和分片集群连接,支持导入导出,SQL 查询,语法填充,支持 MongoDB 4.0+ 等等。适用于 Windows,macOS 和 Linux。

    4.2 Robo 3T (Robomong) 推荐

    官网下载地址:https://robomongo.org/download
    Robo 3T 前身是 Robomongo,后被 3T 公司收购,是一款免费开源的 GUI 管理工具。支持 MongoDB 4.0+,轻量级 GUI,支持语法填充等等。适用于 Windows,macOS 和 Linux 系统。
    在这里插入图片描述

    4.3 Navicat for MongoDB

    官网下载地址:http://www.navicat.com.cn/download/navicat-for-mongodb
    老牌的数据库管理工具,支持多种数据库的集成,已集成 MongoDB 类型,属于付费型管理工具。好处是用会了一个 DB 版的 Navicat,所有 DB 版都会很顺手,维持一套操作习惯,如果再肌肉记忆一些快捷键,会更加高效。

    4.4 NoSQLBooster for MongoDB

    官网下载地址:https://nosqlbooster.com/downloads
    NoSQLBooster for MongoDB(以前叫 MongoBooster)风格有点类似于 EasyUI,支持副本集,独立主机和分片群集连接,提供了全面的服务器监控工具、fluent 查询构建器、SQL 查询、查询代码、任务调度、ESNext 支持和真正的智能感知体验等。提供了付费和免费两种版本。适用于 Windows,macOS 和 Linux 系统。

    4.5 MongoDB Compass

    官网下载地址:https://www.mongodb.com/try/download/compass
    官网教程:https://docs.mongodb.com/manual/reference/connection-string/
    MongoDB 亲儿子系列,官方自己推出的 GUI 可视化管理工具,功能有限。免费简洁,不支持 SQL 查询,支持性能监控。适用于 Windows,macOS 和 Linux 系统。

    5. MongoDB Java操作

    MongoDB Java操作:https://www.mongodb.org.cn/drivers/4.html

    1.引入依赖
    https://search.maven.org/artifact/org.mongodb/mongo-java-driver/3.12.10/jar

    <dependency>
      <groupId>org.mongodb</groupId>
      <artifactId>mongo-java-driver</artifactId>
      <version>3.12.10</version>
    </dependency>
    

    2.代码实现
    MongoUtils 实现MongoDB连接,创建,删除数据库,创建,删除,更新文档以及检索所有文档。

    package com.jerry.market.utils;
    
    import com.mongodb.MongoClient;
    import com.mongodb.MongoCredential;
    import com.mongodb.ServerAddress;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;
    import com.mongodb.client.model.Filters;
    import org.bson.Document;
    import org.junit.Test;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * MongoUtils
     *
     * @author zrj
     * @since 2022/3/29
     **/
    public class MongoUtils {
        /**
         * 获取连接,无需密码
         */
        @Test
        public void getMongoConnectionByAddress() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
    
                MongoCollection<Document> col = mongoDatabase.getCollection("col");
                FindIterable<Document> documents = col.find();
                System.out.println("col documents : " + documents);
    
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 获取连接,需密码
         */
        @Test
        public void getMongoConnectionByUser() {
            try {
                //连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址
                // ServerAddress()两个参数分别为 服务器地址 和 端口
                ServerAddress serverAddress = new ServerAddress("localhost", 27017);
                List<ServerAddress> addrs = new ArrayList<>();
                addrs.add(serverAddress);
                //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码
                MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());
                List<MongoCredential> credentials = new ArrayList<>();
                credentials.add(credential);
                //通过连接认证获取MongoDB连接
                MongoClient mongoClient = new MongoClient(addrs, credentials);
                //连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");
                System.out.println("Connect to database successfully,mongoDatabase:" + mongoDatabase);
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 创建集合
         */
        @Test
        public void createCollection() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
                mongoDatabase.createCollection("test");
                System.out.println("test集合创建成功");
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 获取集合
         */
        @Test
        public void getCollection() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
                MongoCollection<Document> collection = mongoDatabase.getCollection("test");
                System.out.println("集合 test 选择成功,collection:" + collection);
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 插入文档
         */
        @Test
        public void insertMany() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
                MongoCollection<Document> collection = mongoDatabase.getCollection("test");
                System.out.println("集合 test 选择成功");
    
    
                //插入文档
                //1. 创建文档 org.bson.Document 参数为key-value的格式
                //2. 创建文档集合List<Document>
                //3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document)
                Document document = new Document("title", "MongoDB").append("description", "database").append("likes", 100).append("by", "Fly");
                List<Document> documents = new ArrayList<>();
                documents.add(document);
                collection.insertMany(documents);
                System.out.println("文档插入成功");
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 检索所有文档
         */
        @Test
        public void find() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
                MongoCollection<Document> collection = mongoDatabase.getCollection("test");
                System.out.println("集合 test 选择成功");
    
                //检索所有文档
                //1.获取迭代器FindIterable<Document>
                //2.获取游标MongoCursor<Document>
                //3.通过游标遍历检索出的文档集合
                FindIterable<Document> findIterable = collection.find();
                MongoCursor<Document> mongoCursor = findIterable.iterator();
                System.out.println("获取游标成功,mongoCursor:" + mongoCursor);
                while (mongoCursor.hasNext()) {
                    System.out.println(mongoCursor.next());
                }
                System.out.println("检索所有文档完成");
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 更新文档
         */
        @Test
        public void updateMany() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
                MongoCollection<Document> collection = mongoDatabase.getCollection("test");
                System.out.println("集合 test 选择成功");
    
                //更新文档   将文档中likes=100的文档修改为likes=200
                collection.updateMany(Filters.eq("likes", 100), new Document("$set", new Document("likes", 200)));
                //检索查看结果
                FindIterable<Document> findIterable = collection.find();
                MongoCursor<Document> mongoCursor = findIterable.iterator();
                System.out.println("获取游标成功,mongoCursor:" + mongoCursor);
                while (mongoCursor.hasNext()) {
                    System.out.println(mongoCursor.next());
                }
                System.out.println("更新文档完成");
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
    
        /**
         * 删除文档
         */
        @Test
        public void findOneRemove() {
            try {
                // 连接到 mongodb 服务
                MongoClient mongoClient = new MongoClient("localhost", 27017);
                // 连接到数据库
                MongoDatabase mongoDatabase = mongoClient.getDatabase("mongo");
                System.out.println("Connect to database successfully");
                MongoCollection<Document> collection = mongoDatabase.getCollection("test");
                System.out.println("集合 test 选择成功");
    
                //删除符合条件的第一个文档
                collection.deleteOne(Filters.eq("likes", 200));
                //删除所有符合条件的文档
                collection.deleteMany(Filters.eq("likes", 200));
                //检索查看结果
                FindIterable<Document> findIterable = collection.find();
                MongoCursor<Document> mongoCursor = findIterable.iterator();
                System.out.println("获取游标成功,mongoCursor:" + mongoCursor);
                while (mongoCursor.hasNext()) {
                    System.out.println(mongoCursor.next());
                }
                System.out.println("删除文档完成");
            } catch (Exception e) {
                System.err.println(e.getClass().getName() + ": " + e.getMessage());
            }
        }
        
    }
    
    

    6. MongoDB集成SpringBoot

    6.1 官方文档

    Spring Data MongoDB官方文档
    https://spring.io/projects/spring-data-mongodb

    Spring Boot与Spring Data MongoDB版本兼容关系
    https://docs.spring.io/spring-data/mongodb/docs/3.2.4/reference/html/#compatibility.matrix

    注意事项
    springboot与spring data mongoDB版本兼容问题,不同版本之间互不兼容。

    6.2 引入依赖

    <parent>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-parent</artifactId>
       <version>2.5.4</version>
       <relativePath/> <!-- lookup parent from repository -->
    </parent>
    
    <dependencies>    
    	<dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-data-mongodb</artifactId>
    	</dependency>
      <!--mongodb Java驱动-->
     	<dependency>
       	<groupId>org.mongodb</groupId>
        	<artifactId>mongo-java-driver</artifactId>
        	<version>3.12.10</version>
    	</dependency>
    </dependencies>
    

    6.3 配置参数

    application.properties

    spring.data.mongodb.uri= mongodb://127.0.0.1:27017/mongo
    log4j.category.org.springframework.data.mongodb=DEBUG
    log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %40.40c:%4L - %m%n
    

    6.4 代码实现

    Repository和Template的选择。SpringData为我们提供了两种方式对数据库进行操作,第一种是继承Repository接口,第二种是直接使用Template的方式对数据进行操作。
    第一种方式,直接继承xxxRepository接口,其最终将会继承Repository标记接口,我们可以不必自己写实现类,轻松实现增删改查、分页、排序操作,但是对于比较复杂的查询,使用起来就比较费力。
    第二种方式,直接使用xxxTemplate,这需要自己写实现类,但是这样增删改查可以自己控制,对于复杂查询,用起来得心应手。

    EmployeeController

    package com.jerry.market.controller;
    
    import com.jerry.market.entity.Response;
    import com.jerry.market.service.EmployeeService;
    import io.swagger.annotations.Api;
    import io.swagger.annotations.ApiOperation;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    
    /**
     * 员工控制器
     *
     * @author zrj
     * @since 2022/3/29
     **/
    @Slf4j
    @RestController
    @RequestMapping("/employee")
    @Api(tags = "EmployeeController", description = "员工控制器")
    public class EmployeeController {
        @Resource
        private EmployeeService employeeService;
    
        /**
         * 新增接口
         */
        @GetMapping("/create")
        @ApiOperation("新增接口")
        public Response create() {
            return Response.success(employeeService.create());
        }
    
        /**
         * 更新接口
         */
        @GetMapping("/update")
        @ApiOperation("更新接口")
        public Response update() {
            return Response.success(employeeService.update());
        }
    
        /**
         * 删除接口
         */
        @GetMapping("/delete")
        @ApiOperation("删除接口")
        public Response delete() {
            return Response.success(employeeService.delete());
        }
    
        /**
         * 查询接口
         */
        @GetMapping("/select")
        @ApiOperation("查询接口")
        public Response select() {
            return Response.success(employeeService.select());
        }
    }
    
    

    Employee

    package com.jerry.market.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import org.springframework.data.annotation.Id;
    import org.springframework.data.mongodb.core.mapping.Document;
    import org.springframework.data.mongodb.core.mapping.Field;
    
    /**
     * @author zrj
     * @since 2022/3/29
     **/
    @Data
    @Builder
    @NoArgsConstructor
    @AllArgsConstructor
    @Document(collection = "employee") //通过collection参数指定当前实体类对应的文档
    public class Employee {
        @Id //用来标识主键
        private String id;
    
        private String name;
    
        @Field("pwd") //给字段起别名
        private String password;
    
        //@Indexed 用于声明字段需要索引
    }
    
    
    

    EmployeeRepository

    package com.jerry.market.repository;
    
    import com.jerry.market.entity.Employee;
    import org.springframework.data.mongodb.repository.MongoRepository;
    
    /**
     * 员工Dao
     * 定义Dao接口继承MongoRepository<实体类型,主键类型>
     *
     * @author zrj
     * @since 2022/3/29
     **/
    public interface EmployeeRepository extends MongoRepository<Employee, String> {
    }
    
    

    Response

    package com.jerry.market.entity;
    
    import lombok.Data;
    import org.springframework.stereotype.Component;
    
    /**
     * 响应对象
     *
     * @author zrj
     * @since 2022/3/23
     **/
    @Data
    @Component
    public class Response<T> {
        /**
         * 状态码
         */
        private static String successCode = "200";
        private static String successMsg = "执行成功";
        private static String failCode = "500";
        private static String failMsg = "执行失败";
    
        /**
         * 提示消息
         */
        private String message;
    
        /**
         * 状态码
         */
        private String code;
    
        /**
         * 具体返回的数据
         */
        private T data;
    
        public Response() {
        }
    
        private Response(String code, String msg) {
            this.message = msg;
            this.code = code;
        }
    
        private Response(String code, String message, T data) {
            this.message = message;
            this.code = code;
            this.data = data;
        }
    
        /**
         * 返回成功Response对象
         */
        public static <T> Response<T> success(T data) {
            return new Response<>(successCode, successMsg, data);
        }
    
        public static <T> Response<T> success(String successMessage, T data) {
            return new Response<>(successCode, successMessage, data);
        }
    
        public static <T> Response<T> success(String code, String successMessage, T data) {
            return new Response<>(code, successMessage, data);
        }
    
        /**
         * 返回错误Response对象
         */
        public static <T> Response<T> fail(String failMsg) {
            return new Response<>(failCode, failMsg);
        }
    
        public static <T> Response<T> fail(String failCode, String failMsg) {
            return new Response<>(failCode, failMsg);
        }
    
        public static <T> Response<T> fail(String failCode, String failMsg, T data) {
            return new Response<>(failCode, failMsg, data);
        }
    }
    
    
    
    
    

    EmployeeServiceImpl

    package com.jerry.market.service.impl;
    
    import cn.hutool.core.util.IdUtil;
    import com.jerry.market.entity.Employee;
    import com.jerry.market.repository.EmployeeRepository;
    import com.jerry.market.service.EmployeeService;
    import lombok.extern.slf4j.Slf4j;
    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.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.util.List;
    
    /**
     * 员工接口实现类
     * 第一种方式,直接继承xxxRepository接口,其最终将会继承Repository标记接口,我们可以不必自己写实现类,轻松实现增删改查、分页、排序操作,但是对于比较复杂的查询,使用起来就比较费力。
     * 第二种方式,直接使用xxxTemplate,这需要自己写实现类,但是这样增删改查可以自己控制,对于复杂查询,用起来得心应手。
     *
     * @author zrj
     * @since 2022/3/29
     **/
    @Slf4j
    @Service
    public class EmployeeServiceImpl implements EmployeeService {
    
        @Resource
        private EmployeeRepository employeeRepository;
    
        @Resource
        private MongoTemplate mongoTemplate;
    
        /**
         * 新增
         *
         * @return String
         */
        @Override
        public String create() {
            //第一种方式,直接继承xxxRepository接口
            Employee employee = Employee.builder().id("1").name("张三").password("123").build();
            employeeRepository.save(employee);
            log.info("第一种方式新增成功,employee:" + employee);
    
            //第二种方式,直接使用xxxTemplate
            //注意:id不能重复。MongoWriteException: E11000 duplicate key error collection: mongo.employee index: _id_ dup key: { _id: "3" }
            Employee employee2 = Employee.builder().id(IdUtil.simpleUUID()).name("李四").password("123").build();
            mongoTemplate.insert(employee2);
            log.info("第二种方式新增成功,employee:" + employee2);
    
            log.info("【员工接口】新增成功");
            return "新增成功";
        }
    
        /**
         * 更新
         *
         * @return String
         */
        @Override
        public String update() {
            //第一种方式,直接继承xxxRepository接口
            Employee employee = Employee.builder().id("1").name("张更新").password("666").build();
            employeeRepository.save(employee);
    
            //第二种方式,直接使用xxxTemplate
            Query query = Query.query(Criteria.where("id").is("2").and("name").is("王小二"));
            Update update = Update.update("name", "王更新");
            mongoTemplate.updateFirst(query, update, Employee.class);
    
            log.info("【员工接口】更新成功");
            return "更新成功";
        }
    
        /**
         * 删除
         *
         * @return String
         */
        @Override
        public String delete() {
            //第一种方式,直接继承xxxRepository接口
            employeeRepository.deleteById("1");
    
            //第二种方式,直接使用xxxTemplate
            Query query = Query.query(Criteria.where("id").is("2"));
            mongoTemplate.remove(query, Employee.class);
    
            log.info("【员工接口】删除成功");
            return "删除成功";
        }
    
        /**
         * 查询
         *
         * @return String
         */
        @Override
        public List<Employee> select() {
            //第一种方式,直接继承xxxRepository接口
            List<Employee> employeeList = employeeRepository.findAll();
            System.out.println("第一种方式,employeeList:" + employeeList);
    
            //第二种方式,直接使用xxxTemplate
            List<Employee> employeeLists = this.mongoTemplate.findAll(Employee.class);
            System.out.println("第二种方式,employeeList:" + employeeLists);
    
            log.info("【员工接口】查询成功");
            return employeeLists;
        }
    }
    
    

    EmployeeService

    package com.jerry.market.service;
    
    import com.jerry.market.entity.Employee;
    
    import java.util.List;
    
    /**
     * @author zrj
     * @since 2022/3/29
     **/
    public interface EmployeeService {
        /**
         * 新增
         * @return String
         */
        String create();
    
        /**
         * 更新
         * @return String
         */
        String update();
    
        /**
         * 删除
         * @return String
         */
        String delete();
    
        /**
         * 查询
         * @return String
         */
        List<Employee> select();
    
    }
    
    
    更多相关内容
  • C# .net core MongoDBHelper

    2022-04-07 13:55:48
    C# .net core MongoDBHelper C# .net core MongoDBHelper C# .net core MongoDBHelper C# .net core MongoDBHelper C# .net core MongoDBHelper C# .net core MongoDBHelper C# .net core MongoDBHelper C# .net ...
  • MongoDB compass

    2018-03-16 10:07:13
    包含详细教程,版本为1.13最新版,官方推出的可视化工具,支持增删改查。
  • 【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT必备】MongoDB面试题【BAT...
  • NoSQL Manager for MongoDB Pro免费版加注册机 MongoDB 可视化工具压缩包内附注册机
  • Java操作MongoDB增删改查完美入门Demo

    热门讨论 2016-06-21 21:01:00
    一个完全符合企业设计规范的Java操作MongoDB数据库,涉及各种增删改查操作及@Test增删改查使用示范,可极大方便MongoDB开发,可直接通过代码学习MongoDB的使用。 使用环境:Myeclipse、MongoDB
  • mongodb 备份恢复工具

    2022-05-06 09:59:24
    mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具mongodb 备份恢复工具...
  • mongoDBmongoDB的正确的连接方式

    千次阅读 2021-11-17 09:26:03
    \n" | /path/to/mongo --quiet "mongodb://${username}:${password}@${ip}:${port}" ${ip}:${port} 可以是主节点的IP和端口,也可以是从节点的IP和端口 注: --quiet 参数可以去掉相关数据库的连接信息输出 连接...

    一、单机版

    # systemctl status mongod

    # cat /etc/mongod.conf

    未开启认证

    在admin库创建数据库超管用户 

    # echo -e "use admin;\ndb.createUser({user:\"root\",pwd:\"Root@123\",roles:[ { role:\"userAdminAnyDatabase\",db:\"admin\"}]})" |  mongo  --host 127.0.0.1  --port  27017

    开启认证,用超管用户创建其他用户

    开启认证

    # systemctl restart mongod

    # mongo --host 127.0.0.1 -u root -p "Root@123"  --authenticationDatabase  admin

    # echo -e "use admin;\n show tables;" | mongo --host 127.0.0.1 -u root -p "Root@123" --authenticationDatabase admin

    二、复制集

    获取集合(实例)名

    $ echo -e "rs.status()['set']" |  /path/to/mongo --quiet "mongodb://${username}:${password}@${ip}:${port}"

    $ echo -e "rs.status()['set'];" |  /path/to/mongo --quiet "mongodb://${username}:${password}@${ip}:${port}"

    $ echo -e "rs.status()['set'];\n" |  /path/to/mongo --quiet "mongodb://${username}:${password}@${ip}:${port}"

    ${ip}:${port} 可以是主节点的IP和端口,也可以是从节点的IP和端口

    注: --quiet  参数可以去掉相关数据库的连接信息输出

    连接mongoDB复制集

    $ echo -e "rs.status()"  |  /path/to/mongo  --quiet  "mongodb://${username}:${password}@${primary_ip}:${port}/?replicaSet=$(set_name)"

    $ echo -e "rs.status()"  |  /path/to/mongo  --quiet  "mongodb://${username}:${password}@${primary_ip}:${port},${secondary_ip}:${port}/?replicaSet=$(set_name)"

    $ echo -e "rs.status()"  |  /path/to/mongo  --quiet  "mongodb://${username}:${password}@${primary_ip}:${port},${secondary01_ip}:${port},${secondary02_ip}:${port}/?replicaSet=$(set_name)"

    注:

    1. 主动仲裁,写主从 ip port,用逗号隔开

    2. 主从从,写主从从  ip port,用逗号隔开

    3. set_name 为mongoDB 实例名

    针对副本集mongoDB命令行登陆的2种方式:

    方式一:如果要做数据变更操作,需要提前找到谁是主节点,再登陆主节点

    mongo --host  192.168.1.101  --port  27018 -u "user" -p "passwd"  --authenticationDatabase  admin

    方式二:通过mongo连接字符串登陆,会自动登陆主节点

    1. 登录,不指定库,走admin库认证

    mongo  "mongodb://${user}:${paswd}@192.168.1.101:27018,192.168.1.102:27018/?replicaSet=${instance}&authSource=admin"

    2. 登录,指定库名,走admin认证

    mongo  "mongodb://${user}:${paswd}@192.168.1.101:27018,192.168.1.102:27018/${db_name}?replicaSet=${instance}&authSource=admin"

    3. 登录,指定库名,并且在指定库名做认证

    mongo  "mongodb://${user}:${paswd}@192.168.1.101:27018,192.168.1.102:27018/${db_name}?replicaSet=${instance}&authSource=${db_name}"

    注:replicaSet 为 mongoDB的实例名

    mongo shell 的连接字符串跟 应用客户端的连接字符串还有点不一样:

    mongo shell 连接副本集,必须指定replicaSet名称,库名指定是可选的,可指定,可不指定;

    应用(如java应用)中jdbc连接mongoDB的字符串中一定要指定库名,如果是replicaSet只需要填写所有主从的地址,而不是填写replicaSet名称

    如果登陆是从节点,那么无法做数据变更操作,因为mongoDB默认只有主节点可写

    mongo --host  192.168.1.102  --port  27018 -u "user" -p "passwd"  --authenticationDatabase  admin

    > rs.slaveOk()

    注意:对于从mongo shell登陆从节点,需要先执行 rs.slaveOk() 后才能执行相关查询操作,对客户端应用则没有这个限制,默认可以读从,可以实现读写分离。

    当客户端连接副本集时,如果以primary地址连接实例,当发生上述情况时,P节点降级为Secondary节点,客户端将无法继续执行写操作。

    为了解决这一问题,连接线上数据时,最好是使用副本集方式连接副本集。

    正确连接副本集,可以参考官网:  https://docs.mongodb.com/manual/reference/connection-string

    该文档描述了官方MongoDB drivers连接MongoDB实例的URI格式。

    URI形如:

    mongodb://[username:password@]host1[:port1][,...hostN[:portN]]][/[database][?options]]

    options都怎么写?

    参考官方 Connection String URI Format — MongoDB Manual

    mongo shell 连接常见报错:FailedToParse: Password must be URL Encoded for mongod

    #   mongo     "mongodb://root:Root@123@192.168.1.21:27017,192.168.1.22:27017/test?authSource=admin&replicaSet=8e08b0f0-7db1-49aa-8274-05c3bca10e67&readPreference=secondaryPreferred"

    FailedToParse: Password must be URL Encoded for mongodb:// URL: mongodb://root:Root@123@192.168.1.21:27017,192.168.1.22:27017/test?authSource=admin&replicaSet=8e08b0f0-7db1-49aa-8274-05c3bca10e67&readPreference=secondaryPreferredtry'mongo --help'formoreinformation

    密码必须经过URL编码 

    如果用户名或密码包含at符号@,冒号:,斜杠/或百分号%字符,请使用百分比编码

    参考 Connection String URI Format — MongoDB Manual

    在线转换工具:https://www.url-encode-decode.com

    常用的options:

    authSource= //认证用的数据库

    replicaSet=//副本集名称

    readPreference=secondaryPreferred //实现读写分离

    tls=true //启用TLS加密传输(从MongoDB 4.2开始可用)

    connectTimeoutMS  //超时之前尝试连接的时间(以毫秒为单位)。默认值是永不超时,尽管不同的驱动程序可能有所不同,请参阅驱动程序 文档。

    socketTimeoutMS //尝试超时之前在套接字上尝试发送或接收的时间(以毫秒为单位)。默认值是永不超时,尽管不同的驱动程序可能有所不同。请参阅 驱动程序文档。

    连接池选项

    maxPoolSize  //连接池中的最大连接数。默认值为100。

    minPoolSize //连接池中的最小连接数。默认值为0。 (注意minPoolSize并非所有驱动程序都支持该选项。有关驱动程序的信息,请参阅驱动程序文档。)

    maxIdleTimeMS  //在删除和关闭连接之前,连接在池中可以保持空闲状态的最大毫秒数。 (并非所有驱动程序都支持此选项。)

    waitQueueMultiple //驱动程序将maxPoolSize 值乘以的数字,以提供允许最大数量的线程从池中等待可用连接。有关默认值,请参见/ drivers 文档。

    驱动程序: https://docs.mongodb.com/drivers

    写选项

    wtimeoutMS  // wtimeoutMS指定写关注的时间限制(以毫秒为单位)。如果wtimeoutMS是0(默认),写操作永远不会超时。有关更多信息,请参见wtimeout

    连接字符串

    主从仲裁:

    mongo.url=mongodb://${user}:${passwd}@172.16.218.26:27017,172.16.218.27:27017/${db_name}?authSource=${db_name}&maxpoolsize=200&waitqueuetimeoutms=10000&sockettimeoutms=5000&connecttimeoutms=5000&readPreference=secondaryPreferred

    主从从:

    mongo.url=mongodb://${user}:${passwd}@172.16.218.26:27017,172.16.218.27:27017,172.16.218.28:27017/${db_name}?authSource=${db_name}&maxpoolsize=200&waitqueuetimeoutms=10000&sockettimeoutms=5000&connecttimeoutms=5000&readPreference=secondaryPreferred

    三、分片集

    应用客户端通过连接mongos到分片

    mongodb://${user}:${passwd}@192.168.1.101:12345,192.168.1.102:12345192.168.1.103:123456/${db_name}&authSource=${db_name}

    ##########################

    用 mongo shell 连接分片1

    mongodb://172.17.0.8:27018,172.17.0.11:27018,172.17.0.12:27018/test?replicaSet=rs_shardsvr0&authSource=${db_name}

    用mongo shell 连接分片2

    mongodb://172.17.0.13:27018172.17.0.14:27018,172.17.0.15:27018/test?replicaSet=rs_shardsvr1&authSource=${db_name}

    用mongo shell,通过mongos登陆分片集群

    # mongo --host  xx.xx.xx.xx    --port=12345    --username='user'  --password='passwd'  --authenticationDatabase=admin

    使用分片集群时你需要知道:

    1. 用户访问 mongos 跟访问单个 mongod 类似

    2. 所有 mongos 是对等关系,用户访问分片集群可通过任意一个或多个mongos

    3. mongos 本身是无状态的,可任意扩展,集群的服务能力为『Shard服务能力之和』与『mongos服务能力之和』的最小值。

    4. 访问分片集群时,最好将应用负载均匀的分散到多个 mongos 上

    通过上述方式连接分片集群时,客户端会自动将请求分散到多个mongos 上,以实现负载均衡;同时,当URI 里 mongos 数量在2个及以上时,当有mongos故障时,客户端能自动进行 failover,将请求都分散到状态正常的 mongos 上。

    当 mongos 数量很多时,还可以按应用来将 mongos 进行分组,比如有2个应用A、B、有4个mongos,可以让应用A 访问 mongos 1-2(URI里只指定mongos 1-2 的地址), 应用B 来访问 mongos 3-4(URI里只指定mongos 3-4 的地址),根据这种方法来实现应用间的访问隔离(应用访问的mongos彼此隔离,但后端 Shard 仍然是共享的)。

    四、参考

    副本集正确的连接方式

    https://www.cnblogs.com/zhangmingda/p/13183812.html

    MongoDB Manual/Write Concern

    https://docs.mongodb.com/manual/reference/write-concern/#write-concern

    MongoDB连接标准格式

    https://www.cnblogs.com/AlvinLee/p/6062167.html

    MongoDB Driver使用正确的姿势连接复制集

    https://blog.csdn.net/weixin_34258078/article/details/93186333

    MongoDB 开发:使用正确的姿势连接分片集群

    https://blog.csdn.net/weixin_30569153/article/details/94783916

    MongoDB的连接字符串

    https://www.cnblogs.com/imeiba/p/5702298.html

    MongoDB的连接字符串

    http://www.studyofnet.com/news/337.html

    mongoDB集群和分片

    https://www.freesion.com/article/7807126996

    副本集状态参考

    https://mongodb-documentation.readthedocs.io/en/latest/reference/replica-status.html

    Connection String URI Format

    https://www.bookstack.cn/read/mongodb-4.2-manual/68e775d51debcb2c.md

    https://mongoing.com/docs/reference/connection-string.html

    深入浅出MongoDB复制

    https://mongoing.com/archives/5200

    mongodb集群状态

    https://blog.csdn.net/ZhongGuoZhiChuang/article/details/46646091

    MongoDB Replica Set 安装部署

    https://blog.51cto.com/hsbxxl/2149531

    How to edit Mongo connection string?

    https://stackoverflow.com/questions/59019193/how-to-edit-mongo-connection-string

    MongoDB Manual/Security Reference

    https://docs.mongodb.com/upcoming/reference/security/#security-methods-in-the-mongo-shell

    展开全文
  • MongoDB

    万次阅读 2017-12-28 19:19:38
    本文介绍MongoDB以下内容: (1)Windows下安装MongoDB (2)安装MongoDB可视化工具 (3)使用Java对MongoDB进行增删改查 学习教程:http://www.runoob.com/mongodb/mongodb-tutorial.html 官网:...

    本文介绍MongoDB以下内容:

    (1)Windows下安装MongoDB

    (2)安装MongoDB可视化工具

    (3)使用Java对MongoDB进行增删改查

    MongoDB学习教程:http://www.runoob.com/mongodb/mongodb-tutorial.html

    MongoDB官网:https://docs.mongodb.com/manual/

    1、Windows下安装MongoDB

    (1)下载地址:https://www.mongodb.com/download-center#community

    (2)软件安装比较简单,注意,最好选择“自定义”安装,如图:


    (3)设置安装路径,记住安装路径:


    (4)安装好了过后,在windows系统中,进入安装路径下,新建一个data文件夹,和一个mongod.cfg配置文件(新建txt文件,然后改后缀)

    (5)在data文件夹里,再新建两个文件夹,如图:


    (6)回到mongod.cfg文件,在里面写入以下数据(path是log路径,dbPath是db路径):

    systemLog:
        destination: file
        path: c:\data\log\mongod.log
    storage:
        dbPath: c:\data\db

    (7)运行 MongoDB 服务器:进入到MongoDB 目录的 bin 目录中,执行以下命令:

    mongod --dbpath c:\data\db
    启动如图(如果添加了系统环境变量,在任意位置都可以),启动服务成功如图:



    (8)有时候我们每次都要打开cmd输入那行启动语句,其实是很烦的,有一种解决办法就是创建一个.bat批处理文件,以后双击就可以启动MongoDB了。做法如下:

    1)在mongodb安装的根目录下,先创建一个txt文件,在该文件里面写入如下内容:

    start mongod --dbpath=E:\software\Mongodb\data\db

    注意:上述的dbpath的路径是你的MongoDB安装路径,注意填写你自己的

    2)写完保存,把上述的txt文件修改文件后缀为bat文件,命名可以如下:


    3)以后就可以双击这个bat文件启动MongoDB了,还可以给这个文件创建一个“快捷方式”,并发送的桌面,以后就可以在电脑桌面上打开了。


    2、安装MongoDB可视化工具(Robomongo)

    (1)下载地址:https://robomongo.org/download

    (2)参考网址:http://www.veryhuo.com/a/view/156974.html

    (3)安装比较简单,如图:



    (4)安装好了就可以用了,打开界面如图,点击就可以创建了:


    3、使用Java对MongoDB进行增删改查

    MongoDB最主要的概念的理解,请看:


    请看下面的对应关系:


    先创建一个本地连接(locahost),再创建一个数据库(mycol)

    (1)连接数据库

    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoDatabase;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
              // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
           
             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
           System.out.println("Connect to database successfully");
            
          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }

    (2)创建集合

    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoDatabase;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
          // 连接到 mongodb 服务
          MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
             
           
          // 连接到数据库
          MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
          System.out.println("Connect to database successfully");
          mongoDatabase.createCollection("test");
          System.out.println("集合创建成功");
            
          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }

    (3)获取集合

    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoDatabase;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
           // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
           
             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
           System.out.println("Connect to database successfully");
          
           MongoCollection<Document> collection = mongoDatabase.getCollection("test");
           System.out.println("集合 test 选择成功");
          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }

    (4)插入文档

    import java.util.ArrayList;
    import java.util.List;
    import org.bson.Document;
    
    import com.mongodb.MongoClient;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoDatabase;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
             
             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");
             
             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");
             //插入文档  
             /** 
             * 1. 创建文档 org.bson.Document 参数为key-value的格式 
             * 2. 创建文档集合List<Document> 
             * 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document) 
             * */
             Document document = new Document("title", "MongoDB").  
             append("description", "database").  
             append("likes", 100).  
             append("by", "Fly");  
             List<Document> documents = new ArrayList<Document>();  
             documents.add(document);  
             collection.insertMany(documents);  
    	//这里也可以使用insertOne插入一个文档
    	collection.insertOne(document);
             System.out.println("文档插入成功");  
          }catch(Exception e){
             System.err.println( e.getClass().getName() + ": " + e.getMessage() );
          }
       }
    }
    (5)检索所有文档
    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
             
             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");
             
             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");
             
             //检索所有文档  
             /** 
             * 1. 获取迭代器FindIterable<Document> 
             * 2. 获取游标MongoCursor<Document> 
             * 3. 通过游标遍历检索出的文档集合 
             * */  
             FindIterable<Document> findIterable = collection.find();  
             MongoCursor<Document> mongoCursor = findIterable.iterator();  
             while(mongoCursor.hasNext()){  
                System.out.println(mongoCursor.next());  
             }  
          
          }catch(Exception e){
             System.err.println( e.getClass().getName() + ": " + e.getMessage() );
          }
       }
    }
    (6)更新文档

    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;
    import com.mongodb.client.model.Filters;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
             
             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");
             
             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");
             
             //更新文档   将文档中likes=100的文档修改为likes=200   
             collection.updateMany(Filters.eq("likes", 100), new Document("$set",new Document("likes",200)));  
    
    	 collection.updateOne(Filters.eq("likes", 100), new Document("$set",new Document("likes",200)));  //更新一条
    //检索查看结果 FindIterable<Document> findIterable = collection.find(); MongoCursor<Document> mongoCursor = findIterable.iterator(); while(mongoCursor.hasNext()){ System.out.println(mongoCursor.next()); } }catch(Exception e){ System.err.println( e.getClass().getName() + ": " + e.getMessage() ); } }}

    (7)删除第一个文档
    
    import org.bson.Document;
    import com.mongodb.MongoClient;
    import com.mongodb.client.FindIterable;
    import com.mongodb.client.MongoCollection;
    import com.mongodb.client.MongoCursor;
    import com.mongodb.client.MongoDatabase;
    import com.mongodb.client.model.Filters;
    
    public class MongoDBJDBC{
       public static void main( String args[] ){
          try{   
             // 连接到 mongodb 服务
             MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
    
             // 连接到数据库
             MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
             System.out.println("Connect to database successfully");
    
             MongoCollection<Document> collection = mongoDatabase.getCollection("test");
             System.out.println("集合 test 选择成功");
    
             //删除符合条件的第一个文档  
             collection.deleteOne(Filters.eq("likes", 200));  
             //删除所有符合条件的文档  
             collection.deleteMany (Filters.eq("likes", 200));  
             //检索查看结果  
             FindIterable<Document> findIterable = collection.find();  
             MongoCursor<Document> mongoCursor = findIterable.iterator();  
             while(mongoCursor.hasNext()){  
               System.out.println(mongoCursor.next());  
             }  
               
          }catch(Exception e){
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );
         }
       }
    }

    展开全文
  • MongoDB 教程

    2020-12-16 16:23:56
    MongoDB 教程 MongoDB 是一个基于分布式文件存储的数据库。由 C++ 语言编写。旨在为 WEB 应用提供可扩展的高性能数据存储解决方案。 MongoDB 是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中...
  • MongoDB 实战

    千次阅读 2022-06-02 15:58:42
    MongoDB是一个文档数据库(以 JSON 为数据模型),由C++语言编写,旨在为WEB应用提供可扩展的高性能数据存储解决方案。 文档来自于“JSON Document”,并非我们一般理解的 PDF,WORD 文档。 MongoDB是一个介于关系...

    1.MongoDB介绍

    1.1 什么是MongoDB

    MongoDB是一个文档数据库(以 JSON 为数据模型),由C++语言编写,旨在为WEB应用提供可扩展的高性能数据存储解决方案。
    文档来自于“JSON Document”,并非我们一般理解的 PDF,WORD 文档。
    MongoDB是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。它支持的数据结构非常松散,数据格式是BSON,一种类似JSON的二进制形式的存储格式,简称Binary JSON ,和JSON一样支持内嵌的文档对象和数组对象,因此可以存储比较复杂的数据类型。MongoDB最大的特点是它支持的查询语言非常强大,其语法有点类似于面向对象的查询语言,几乎可以实现类似关系数据库单表查询的绝大部分功能,而且还支持对数据建立索引。原则上 Oracle 和MySQL 能做的事情,MongoDB 都能做(包括 ACID 事务)。
    MongoDB在数据库总排名第5,仅次于Oracle、MySQL等RDBMS,在NoSQL数据库排名首位。从诞生以来,其项目应用广度、社区活跃指数持续上升。
    在这里插入图片描述
    MongoDB概念与关系型数据库(RDBMS)非常类似:
    在这里插入图片描述
    数据库(database):最外层的概念,可以理解为逻辑上的名称空间,一个数据库包含多个不同名称的集合。

    集合(collection):相当于SQL中的表,一个集合可以存放多个不同的文档。

    文档(document):一个文档相当于数据表中的一行,由多个不同的字段组成。

    字段(field):文档中的一个属性,等同于列(column)。

    索引(index):独立的检索式数据结构,与SQL概念一致。

    id:每个文档中都拥有一个唯一的id字段,相当于SQL中的主键(primary key)。

    视图(view):可以看作一种虚拟的(非真实存在的)集合,与SQL中的视图类似。从MongoDB3.4版本开始提供了视图功能,其通过聚合管道技术实现。

    聚合操作($lookup):MongoDB用于实现“类似”表连接(tablejoin)的聚合操作符。
    在这里插入图片描述
    半结构化,在一个集合中,文档所拥有的字段并不需要是相同的,而且也不需要对所用的字段进行声明。因此,MongoDB具有很明显的半结构化特点。除了松散的表结构,文档还可以支持多级的嵌套、数组等灵活的数据类型,非常契合面向对象的编程模型。

    弱关系,MongoDB没有外键的约束,也没有非常强大的表连接能力。类似的功能需要使用聚合管道技术来弥补。

    1.2 MongoDB技术优势

    MongoDB基于灵活的JSON文档模型,非常适合敏捷式的快速开发。与此同时,其与生俱来的高可用、高水平扩展能力使得它在处理海量、高并发的数据应用时颇具优势。

    JSON 结构和对象模型接近,开发代码量低

    JSON的动态模型意味着更容易响应新的业务需求

    复制集提供99.999%高可用

    分片架构支持海量数据和无缝扩容

    简单直观:从错综复杂的关系模型到一目了然的对象模型
    在这里插入图片描述
    快速:最简单快速的开发方式
    在这里插入图片描述
    灵活:快速响应业务变化
    在这里插入图片描述
    MongoDB优势:原生的高可用
    在这里插入图片描述
    MongoDB优势:横向扩展能力
    在这里插入图片描述

    1.3 MongoDB应用场景

    从目前阿里云 MongoDB 云数据库上的用户看,MongoDB 的应用已经渗透到各个领域:

    游戏场景,使用 MongoDB 存储游戏用户信息,用户的装备、积分等直接以内嵌文档的形式存储,方便查询、更新;

    物流场景,使用 MongoDB 存储订单信息,订单状态在运送过程中会不断更新,以MongoDB 内嵌数组的形式来存储,一次查询就能将订单所有的变更读取出来;

    社交场景,使用 MongoDB 存储存储用户信息,以及用户发表的朋友圈信息,通过地理位置索引实现附近的人、地点等功能;

    物联网场景,使用 MongoDB 存储所有接入的智能设备信息,以及设备汇报的日志信息,并对这些信息进行多维度的分析;

    视频直播,使用 MongoDB 存储用户信息、礼物信息等;

    大数据应用,使用云数据库MongoDB作为大数据的云存储系统,随时进行数据提取分析,掌握行业动态。|

    国内外知名互联网公司都在使用MongoDB:
    在这里插入图片描述
    如何考虑是否选择MongoDB?
    没有某个业务场景必须要使用MongoDB才能解决,但使用MongoDB通常能让你以更低的成本解决问题。如果你不清楚当前业务是否适合使用MongoDB,可以通过做几道选择题来辅助决策。
    !](https://img-blog.csdnimg.cn/95ebe48a6ec948d9b689eb31dfa05231.png)

    只要有一项需求满足就可以考虑使用MongoDB,匹配越多,选择MongoDB越合适。

    今天就分享到这里了,文章后续及更多java学习资料,关注我,免费领取

    展开全文
  • [MongoDB权威指南-英文版8天学通MongoDB10天掌握MongoDB(2012完整版)MongoDB基础教程MongoDB权威指南MongoDB实战MongoDB实战中文版mongodb学习手册以mongodb为主的nosql调研
  • MongoDB数据库安装部署及警告优化

    万次阅读 多人点赞 2021-12-14 14:04:31
    MongoDB安装部署及警告优化 1.软件下载 3.6.13版本:https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-3.6.13.tgz 4.0.14版本:https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-4.0.14.tgz 官网文档...
  • springboot整合mongodb

    千次阅读 2021-01-08 14:26:11
    今天学习了springboot整合mongodb,这节课完成后,王军伟老师的springboot技术栈的全套视频就学完了,很高兴自己坚持下来了,而且每节课后都有练习和总结。 1.mongodb的安装和简介 1.1简介 MongoDB 是由C++语言...
  • MongoDB的增删改查操作

    千次阅读 2021-11-25 16:26:45
    前面介绍了MongoDB的基本概念与常见的操作,本文来重点分析下MongoDB的增删改查操作 文章目录概述 概述
  • Data Modeling for MongoDB

    热门讨论 2014-07-27 23:45:56
    MongoDB建模方法和技巧,到底是文档嵌套还是应用,看看就知道了!
  • 基础篇(能解决工作中80%的问题): MongoDB的概述、应用场景、下载方式、连接方式和发展历史等 MongoDB数据类型、重要概念以及shell常用指令 MongoDB文档的各种增加、更新、删除操作总结 MongoDB各种查询操作总结 ...
  • CentOS 安装 mongodb

    千次阅读 2022-04-16 11:11:59
    CentOS 安装 mongodb 推荐使用 yum 源头安装方式,便于管理 创建 mongodb yum 源头 vim /etc/yum.repos.d/mongodb-org-5.0.repo 编辑刚刚创建的文件,将下面内容写入 [mongodb-org-5.0] name=MongoDB ...
  • 搭建mongodb

    千次阅读 2022-04-09 15:52:10
    MongoDB安装过程以及问题记录 一、MongoDB安装 下载MongoDB 官方地址:MongoDB Community Download | MongoDB 可能需要注册一下我这里是Centos7系统所以选择的是RHEL7.0的TGZ,其他系统自行选择 如果不想注册...
  • MongoDB 使用介绍

    千次阅读 多人点赞 2021-06-10 15:55:31
    MongoDB 是由 C++ 语言编写的,是一个基于分布式文件存储的非关系型开源数据库系统。其优势在于可以存放海量数据,具备强大的查询功能,是一个独立的面向集合文档形式的。
  • MongoDB数据库授权认证

    万次阅读 多人点赞 2021-12-28 09:48:21
    MongoDB数据库授权认证 文章目录MongoDB数据库授权认证1.与用户相关的命令2.配置mongodb登陆授权认证2.1.创建一个用户2.2.修改配置文件启用用户认证2.3.重启mongodb2.4.使用口令登陆mongodb3.授权用户并赋予多个权限...
  • MongoDB+Docker+Linux实现副本集集群搭建

    千次阅读 2022-02-06 20:54:55
    MongoDB+Docker+Linux实现副本集集群搭建
  • Django项目连接MongoDB的三种方法

    千次阅读 2021-09-16 08:53:37
    有三种方法连接Django到MongoDB数据库 1.PyMongo:PyMongo 是 MongoDB 与 Django 交互的标准驱动程序。这是在 Python 中使用 MongoDB 的官方和首选方式。 PyMongo 提供了执行所有数据库操作的功能,例如搜索、删除...
  • MongoDB和Compass安装教程

    千次阅读 2020-11-14 19:49:36
    MongoDB和Compass安装教程 MongoDB Compass 就是一个MongoDB的可视化连接工具,提供了丰富的功能。 安装MongoDB 下载MongoDB ​ 进入MongoDB官网 : ​ 点击进去后会有好几个菜单,我们选择 MongoDB Community ...
  • MongoDB部署分片集群

    千次阅读 2021-04-02 23:00:06
    mongodb分片集群简介 分片集群简介 mongos,数据库集群请求的入口,所有的请求都通过mongos进行协调,不需要在应用程序添加一个路由选择器,mongos自己就是一个请求分发中心,它负责把对应的数据请求转发到对应的...
  • mongodb目前是很多企业业务上常用的nosql数据库。我们需要对这些业务mongodb数据库进行 数据同步到 数据仓库中进行 数据分析处理。 技术选型 CDC介绍 CDC (Change Data Capture) 是一种用于捕捉数据库变更数据的技术...
  • 什么是MongoDB ? MongoDB 是由C++语言编写的,是一个基于分布式文件存储的开源数据库系统。 MongoDB 可在高负载的情况下,添加更多的节点,可以保证服务器性能。 MongoDB 可为Web应用提供可扩展的高性能数据存储...
  • windows2008服务器搭建mongodb并设置远程访问1、下载 安装 配置 mongodb创建数据目录连接MongoDB配置 MongoDB 服务安装 MongoDB服务启动MongoDB服务关闭MongoDB服务移除 MongoDB 服务MongoDB 后台管理 Shell2、配置...
  • 在Linux上安装MongoDB

    千次阅读 2022-04-21 19:48:07
    主要介绍了linux下安装MongoDB 这一步点击进入网络和主机名,上面有一个ON ,选择ON,一定不要忘记!!! 这一步设置好后,点击完成。等待安装。然后...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 413,395
精华内容 165,358
关键字:

mongodb

友情链接: AES.rar