mongoDB使用总结

2023-11-01

windows安装

zip压缩包方式安装

下载

注意：因为现在最新版的mongodb不兼容win7,对windows系统的最低要求是win10。所以win7系统要安装mongodb数据库必须考虑使用旧版安装。

Download MongoDB Community Server | MongoDB

解压

将压缩包解压放在指定位置，创建data和logs目录用于存放数据和日志

本次安装放在D:\soft\mongodb-4.4.18，对应的data和logs目录也放在这里

启动

前台启动：

这种适用于一开始的测试，进入bin目录，启动服务

mongod.exe --logpath D:\soft\mongodb-4.4.18\logs\mongodb.log --logappend --dbpath D:\soft\mongodb-4.4.18\data  --auth  --directoryperdb --serviceName MongoDB

后台启动：

上面是前台启动，窗口不能关闭，为了使用方便，将MongoDB服务器作为Windows服务运行

打开终端，以管理员方式运行

mongod.exe --logpath D:\soft\mongodb-4.4.18\logs\mongodb.log --logappend --dbpath D:\soft\mongodb-4.4.18\data  --auth  --directoryperdb --install  --serviceName MongoDB

启动服务，后台运行

net start MongoDB

如果没有安装成功，或者需要重试，可以删除服务

sc delete MongoDB

来源：

Window7之MongoDB安装详解 - 知乎

windows安装mongodb服务简洁版教程

指定配置文件启动：

mongo启动的时候参数最好写到配置文件里，省得下次启动还得写一堆启动参数，比如和bin平级目录新建一个mongo.conf文件

 # 数据库文件
dbpath=D:\soft\mongodb-4.4.18\data
# 日志文件
logpath=D:\soft\mongodb-4.4.18\logs\mongodb.log
# 日志采用追加模式，配置后mongodb日志会追加到现有的日志文件，不会重新创建一个新文件
logappend=true
# 启用日志文件，默认启用
journal=true
# 这个选项可以过滤掉一些无用的日志信息，若需要调试使用请设置为 false
quiet=true 
# 端口号 默认为 27017
port=27017
auth=true
directoryperdb=true

#默认是绑定本地地址
bind_ip = 0.0.0.0

mongod -f D:\soft\mongodb-4.4.18\mongo.conf

来源：mongodb的启动参数大全及auth配置-04007技术笔记

验证

启动后我们可以在服务器输入 http://127.0.0.1:27017 或者 http://localhost:27017 进行查看

msi安装

注意：选择是否安装MongoDB数据库图形化界面管理工具一定要取消掉

在这里插入图片描述

来源：

Windows环境下安装MongoDB数据库_·惊鸿的博客-CSDN博客_windows安装mongodb

linux下安装

本次安装在centos7环境下

下载

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.4.4.tgz

#如果希望下载其他版本修改后面地址

wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-rhel70-3.6.2.tgz

tar -zxvf mongodb-linux-x86_64-rhel70-3.4.4.tgz

cd mongodb-linux-x86_64-rhel70-3.4.4

mkdir data

mkdir logs

创建启动配置文件

mongo.conf

#数据库文件
dbpath=/root/mongodb-linux-x86_64-rhel70-3.4.4/data
#日志文件
logpath=/root/mongodb-linux-x86_64-rhel70-3.4.4/logs/mongodb.log

 # 日志采用追加模式，配置后mongodb日志会追加到现有的日志文件

logappend=true

# 启用日志文件，默认启用
journal=true

# 这个选项可以过滤掉一些无用的日志信息，若需要调试使用请设置为 false
quiet=true

# 端口号 默认为 27017
port=27017
auth=true
directoryperdb=true

#以守护进程的方式运行MongoDB，创建服务器进程
fork=true

#默认是绑定本地地址
bind_ip = 0.0.0.0

启动

./bin/mongod -f mongo.conf

mongodb关闭

不要使用kill直接杀mongo进程的方式关闭数据节点，会造成数据损坏

#用户创建参照下面的配置认证
use admin
db.shutdownServer()

#强制关闭Mongod，应对副本集中主从时间差超过10s时不允许关闭主库的情况

db.shutdownServer({force : true})

来源：

添加mongodb认证_Mongodb安装与基础配置(centos7)_颜不糙的博客-CSDN博客

Linux 环境下MongoDB 启动和关闭-电脑知识网

配置认证

bin目录下，执行mongo，进入shell命令行

创建管理员账户

进入admin数据库

use admin

db.createUser({ user: "admin", pwd: "1234", roles: [{ role: "userAdminAnyDatabase", db: "admin" }] })

mongodb中的用户是基于身份role的，该管理员账户的 role是 userAdminAnyDatabase。admin用户用于管理账号，不能进行关闭数据库等操作。

创建admin成功以后，在该账号下可以看到所有数据库

show dbs

创建root

注意：创建root账号之前，需要认证登录admin账号，然后切换到其他的db

db.auth("admin","1234")

db.createUser({user: "root",pwd: "1234", roles: [ { role: "root", db: "admin" } ]})

创建完admin管理员，创建一个超级管理员root。角色：root。root角色用于关闭数据库。

 db.shutdownServer()

创建自己数据库的管理角色

mongodb密码和传统数据如mysql等有些区别： mongodb的用户名和密码是基于特定数据库的，而不是基于整个系统的。所有所有数据库db都需要设置密码。

注意：次操作需要先认证登录admin账号

db.auth("admin","1234")

切换自己的数据库

use test

db.createUser({user: "user",pwd: "1234",roles: [ { role: "dbOwner", db: "test" } ]})

#认证

db.auth("user","1234")

#认证以后可以修改密码

db.changeUserPassword('user','1234')

测试认证

#退出脚本

quit()

#进入脚本命令

mongo

#切换数据库

use test

#认证，如果没有报错，则表示配置失败

db.auth("user","1234")

#也可以插入数据看看能否成功

db.test.insert({ _id: 10, item: "box", qty: 20 })

#查看collections,可以理解为查看该数据库中所有表

show collections

带认证登录

mongo test --username user --host 127.0.0.1 --port 27017 --password

来源：

设置MongoDB的账户密码_踏平扶桑的博客-CSDN博客_mongodb设置用户名和密码

修改密码

#方法1：
db.changeUserPassword("usertest","changepass");
#方法2：
db.updateUser("usertest",{pwd:"changepass1"})；

修改权限

db.updateUser("usertest",{roles:[ {role:"read",db:"testDB"} ]})

客户端使用

Studio 3T

来源：Studio 3T使用教程,本人详细介绍连接Mongodb过程_晨曦之泪的博客-CSDN博客_studio 3t

Navicat

个人觉得Navicat更好用

MongoDB的可视化工具可以使用 Navicat 去查看

写好之后点击测试连接，现实成功后就可以点击确定了

看一下成功后的效果

来源：Windows下安装 MongoDB_Dragon-v的博客-CSDN博客_windows安装mongodb

NoSQLBooster

以上都是付费软件，使用免费的可以用NoSQLBooster

1.下载

NoSQLBooster for MongoDB下载-NoSQLBooster for MongoDB中文版下载-PC下载网

2.新建连接

3.输入用户名密码

4. 输入查询命令

例如

db.ToutiaoPapers.find({})
   .projection({})
   .sort({postDate:-1})
   .limit(100)

5.点击run

6.切换显示样式

常用命令

#插入

db.stu.insert({ _id: 10, item: "box", qty: 20 })

#正则查询

db.users.find({"username" : {$regex : ".*jo*"}});

#完全匹配查询

db.users.findOne({"_id" : ObjectId(“你的_id”)});

db.users.find({"title" : "这是一个测试标题");

来源：

Windows安装MongoDB（图解）

MongoDB集群

MongoDB 有三种集群部署模式，分别为主从复制（Master-Slaver）、副本集（Replica Set）和分片（Sharding）模式。

Master-Slaver 是一种主从副本的模式，目前已经不推荐使用。
Replica Set 模式取代了 Master-Slaver 模式，是一种互为主从的关系。Replica Set 将数据复制多份保存，不同服务器保存同一份数据，在出现故障时自动切换，实现故障转移，在实际生产中非常实用。
Sharding 模式适合处理大量数据，它将数据分开存储，不同服务器保存不同的数据，所有服务器数据的总和即为整个数据集

主从复制

主从复制模式的集群中只能有一个主节点，主节点提供所有的增、删、查、改服务，从节点不提供任何服务，但是可以通过设置使从节点提供查询服务，这样可以减少主节点的压力。

在主从复制的集群中，当主节点出现故障时，只能人工介入，指定新的主节点，从节点不会自动升级为主节点。同时，在这段时间内，该集群架构只能处于只读状态。

副本集

此集群拥有一个主节点和多个从节点，这一点与主从复制模式类似，且主从节点所负责的工作也类似，但是副本集与主从复制的区别在于：当集群中主节点发生故障时，副本集可以自动投票，选举出新的主节点，并引导其余的从节点连接新的主节点，而且这个过程对应用是透明的。

可以说，MongoDB 的副本集是自带故障转移功能的主从复制。

分片

副本集可以解决主节点发生故障导致数据丢失或不可用的问题，但遇到需要存储海量数据的情况时，副本集机制就束手无策了。副本集中的一台机器可能不足以存储数据，或者说集群不足以提供可接受的读写吞吐量。这就需要用到 MongoDB 的分片（Sharding）技术，这也是 MongoDB 的另外一种集群部署模式。

分片是指将数据拆分并分散存放在不同机器上的过程。有时也用分区来表示这个概念。将数据分散到不同的机器上，不需要功能强大的大型计算机就可以存储更多的数据，处理更大的负载。

来源：mongodb的3中集群方式_最爱奶油花生的博客-CSDN博客_mongodb集群搭建的三种方式

高可用集群配置

MongoDB高可用集群配置方案 - 林宇风 - 博客园

Java客户端使用

来源

java driver连接mongodb的三种方法 - 码农教程

JAVA如何操作MongoDB？_长安代号007的博客-CSDN博客

Spring Data MongoDB 与 mongo java driver 与 spring Framework 的版本兼容情况_YHJ的博客-CSDN博客_spring-data-mongodb与mongodb-driver-sync版本

maven依赖

 <!-- mongodb-driver-legacy -->
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongodb-driver-legacy</artifactId>
            <version>4.1.2</version>
        </dependency>

        <!-- jackson -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.7.0</version>
        </dependency>

        <!-- log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.2</version>
        </dependency>

        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.17.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.10</version>
            <scope>test</scope>
        </dependency>

log4j.properties

log4j.rootLogger=INFO,R,stdout
#\u6307\u5B9A\u5F53\u524D\u8F93\u51FA\u6E90\u7684\u65E5\u5FD7\u7EA7\u522B\uFF0C\u6709\u4E86\u524D\u9762\u7684\u914D\u7F6E\uFF0C\u5C31\u4E0D\u9700\u8981\u914D\u7F6E\u8BE5\u9879\u4E86
log4j.appender.console.Threshold = info
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

org.apache=INFO
org.apache.http.wire=INFO
org.apache.http.headers=INFO

log4j.appender.R=org.apache.log4j.DailyRollingFileAppender
log4j.appender.R.File=./logs/info.log
log4j.appender.R.DatePattern ='.'yyyy-MM-dd
log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

logback.xml

<configuration debug="false">
    <logger name="org.apache" level="INFO" />
    <logger name="org.apache.http.wire" level="INFO" />
    <logger name="org.apache.http.headers" level="INFO" />

    <property name="CONSOLE_LOG_PATTERN"
              value="%date{yyyy-MM-dd HH:mm:ss}  %highlight(%-5level) %magenta(%-4relative) --- [%yellow(%15.15thread)] %cyan(%-40.40logger{39}) : %msg%n"/>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>

    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

MongoTest

import com.mongodb.*;
import com.mongodb.MongoClient;
import com.mongodb.client.*;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.wg.bean.Student;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class MongoTest {

    private MongoClient mongoClient;

    @Before
    public void init(){
        //获取Mongo的链接对象
        MongoCredential credential = MongoCredential.createCredential("user", "test", "1234".toCharArray());
        MongoClientOptions options = new MongoClientOptions.Builder().build();
        ServerAddress serverAddress = new ServerAddress("localhost",27017);
        //获取库对象
         mongoClient = new MongoClient(serverAddress, credential, options);
    }

    @Test
    public void getDbs(){
        //获取库对象
        MongoDatabase database = mongoClient.getDatabase("test");

        //查看链接的MongoDB中的所有的库
        MongoIterable<String> listCollectionNames = database.listCollectionNames();
        for(String st:listCollectionNames) {
            System.out.println(st);
        }

    }


    @Test
    public void getAllTest(){
        //获取库对象
        MongoDatabase mongoDatabase = mongoClient.getDatabase("test");

        //获取表对象
        MongoCollection<Document> collection = mongoDatabase.getCollection("student");

        //全查 Document文档的集合
        FindIterable<Document> find = collection.find();

        //迭代器对象  Cursor游标就是迭代器
        MongoCursor<Document> iterator = find.iterator();

        //遍历取值
        while(iterator.hasNext()) {
            Document next = iterator.next();
            System.out.println(next);
            System.out.println(next.getDate("sbirthday"));
        }


    }


    @After
    public void close(){
        //关闭链接
        mongoClient.close();
    }


    @Test
    public void addTest(){
        //创建一个类对象
        Student su = new Student();
        su.setSbirthday(new Date());
        su.setSclassid(007);
        su.setSid(2);
        su.setSname("张三");
        su.setSsex("男");
        //获取库对象
        MongoDatabase mongoDatabase = mongoClient.getDatabase("test");
        //获取表对象
        MongoCollection<Document> table = mongoDatabase.getCollection("student");
        //创建一个document 文档 对象
        Document document = new Document();
        document.put("sid", su.getSid());
        document.put("sbirthday", su.getSbirthday());
        document.put("sclassid", su.getSclassid());
        document.put("sname", su.getSname());
        document.put("ssex", su.getSsex());
        //新增一条数据
        table.insertOne(document);
        //插入数据的id
        System.out.println(document.get("_id"));
    }

    @Test
    public void addIDTest(){
        //创建一个类对象
        Student su = new Student();
        su.setSbirthday(new Date());
        su.setSclassid(007);
        su.setSid(2);
        su.setSname("张三");
        su.setSsex("男");
        //获取库对象
        MongoDatabase mongoDatabase = mongoClient.getDatabase("test");
        //获取表对象
        MongoCollection<Document> table = mongoDatabase.getCollection("student");
        //创建一个document 文档 对象
        Document document = new Document();
        document.put("_id",1234);
        document.put("sid", su.getSid());
        document.put("sbirthday", su.getSbirthday());
        document.put("sclassid", su.getSclassid());
        document.put("sname", su.getSname());
        document.put("ssex", su.getSsex());
        //新增一条数据
        table.insertOne(document);
    }



    @Test
    public void multAddTest(){
        // 新建对象设置数值
        Student s = new Student();
        s.setSbirthday(new Date());
        s.setSclassid(100);
        s.setSid(1);
        s.setSname("张三");
        s.setSsex("男");


        // 创建多个document对象

        Document doc = new Document();
        doc.put("sid", s.getSid());
        doc.put("sname", s.getSname());
        doc.put("sbirthday", s.getSbirthday());
        doc.put("ssex", s.getSsex());
        doc.put("sclassid", s.getSclassid());


        Document doc2 = new Document();
        doc2.put("sid", 2);
        doc2.put("sname", "李四");
        doc2.put("sbirthday", new Date());
        doc2.put("ssex", "女");
        doc2.put("sclassid", 200);

        Document doc3 = new Document();
        doc3.put("sid", 3);
        doc3.put("sname", "王五");
        doc3.put("sbirthday", new Date());
        doc3.put("ssex", "男");
        doc3.put("sclassid", 300);

        //获取库对象
        MongoDatabase mongoDatabase = mongoClient.getDatabase("test");
        //获取表对象
        MongoCollection<Document> table = mongoDatabase.getCollection("student");

        //创建集合
        List<Document> dlist = new ArrayList<Document>();
        dlist.add(doc);
        dlist.add(doc2);
        dlist.add(doc3);

        // 插入多条数据
        table.insertMany(dlist);

    }

    @Test
    public void deleteTest(){
        //获取库对象
        MongoDatabase mongoDatabase = mongoClient.getDatabase("test");
        //获取表对象
        MongoCollection<Document> table = mongoDatabase.getCollection("student");
        Bson eq = Filters.eq("sname", "李四");

//        DeleteResult deleteResult = table.deleteOne(eq);
        DeleteResult deleteResult = table.deleteMany(eq);
        if(deleteResult.getDeletedCount() > 0) {
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }
    }

    @Test
    public void updateTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");

        // 条件对象   where ssex = 男 and (classid = 1 or classid = 2)
        Bson eq = Filters.and(
                Filters.eq("ssex", "男"),
                Filters.or(
                        Filters.eq("sclassid", 7),
                        Filters.eq("sclassid", 300)
                )
        );
        // 要修改的数据
        Document doc = new Document();
        doc.put("$set", new Document("sname","哈哈"));

//        UpdateResult updateOne = table.updateOne(eq, doc);
        UpdateResult updateOne = table.updateMany(eq, doc);

        System.out.println(updateOne);
    }

    @Test
    public void sortTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");
        //排序查询，1~表示升序;-1~表示降序
        Document document = new Document("sclassid",1);

        FindIterable<Document> find = table.find().sort(document);

        for(Document doc : find) {
            System.out.println(doc);
        }

    }

    @Test
    public void regexTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");
        //使用正则表达式进行模糊查询
        Bson bson = Filters.regex("sname", "张");

        FindIterable<Document> find = table.find(bson);

        MongoCursor<Document> iterator = find.iterator();

        /*for(Document doc : find) {
            System.out.println(doc);
        }*/
        //遍历取值
        while(iterator.hasNext()) {
            Document next = iterator.next();
            System.out.println(next);
        }
    }

    @Test
    public void pageTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");
        // 跳转，分页
        FindIterable<Document> bbs =table.find().skip(2).limit(2);

        MongoCursor<Document> iterator = bbs.iterator();

        for(Document doc : bbs) {
            System.out.println(doc);
        }
    }

    @Test
    public void filterTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");

        Bson b1 = Filters.eq("sname","张三3");
        FindIterable<Document> bbs = table.find(b1);
//        MongoCursor<Document> iterator = bbs.iterator();

        for(Document doc : bbs) {
            System.out.println(doc);
        }
    }
    @Test
    public void idFilterTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");
        // 方法1
//        Bson filter2 =  Filters.and(Filters.eq("_id", 1234));
        Bson filter2 =  Filters.and(Filters.eq("_id", "639ad03e52d12b52a1d2d30e"));
        FindIterable<Document> bbs = table.find(filter2);
        for(Document doc : bbs) {
            System.out.println(doc);
        }
    }



    @Test
    public void multFilterTest(){
        // 获取库对象
        MongoDatabase db = mongoClient.getDatabase("test");
        // 获取表对象
        MongoCollection<Document> table = db.getCollection("student");

        Bson b1 = Filters.and(
                Filters.eq("sname","张三"),
                Filters.gte("sclassid",7)
                );
        FindIterable<Document> bbs = table.find(b1);
//        MongoCursor<Document> iterator = bbs.iterator();

        for(Document doc : bbs) {
            System.out.println(doc);
        }
    }
}

Student

public class Student {
    private int sid;
    private Date sbirthday;
    private int sclassid;
    private String ssex;
    private String sname;
 //...
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)