MongoDB分布式文件存储数据库

Jin-进

已于 2023-07-14 21:51:05 修改

阅读量943

点赞数 1

分类专栏：中间件文章标签： mongodb 数据库 nosql

于 2023-03-20 16:45:40 首次发布

本文链接：https://blog.csdn.net/weixin_45207323/article/details/129670897

版权

中间件专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、MongoDB

尚硅谷

MongoDB学习视频：尚硅谷学习视频

尚硅谷:
http://www.atguigu.com/

MongoDB学习视频(尚硅谷)：
https://www.bilibili.com/video/BV15k4y1m7BF?p=1

gitee笔记项目：
https://gitee.com/happy_sad/mongoddb

MongoDB：
https://www.mongodb.com/docs/

Mongoose ODM v6.3.1：
https://mongoosejs.com/

Mongoose v6.3.1: Schemas：
https://mongoosejs.com/docs/guide.html

一、安装下载

下载地址：https://www.mongodb.com/try/download/community

1650781389055

二、配置环境变量

1、安装目录：D:\Mongodb

1650781584499

2、配置环境变量

path里配置（D:\Mongodb\mongodb-win32-x86_64-windows-5.0.7\bin）

1650781490050

3、配置data

在bin同目录下新建data文件夹，再在data目录下新建db和log文件夹

1650781564473

三、启动与测试

1、启动mongod服务（服务端），打开cmd,输入

默认端口（27017）
mongod --dbpath D:\Mongodb\mongodb-win32-x86_64-windows-5.0.7\data\db

变换端口（10086）
mongod --dbpath D:\Mongodb\mongodb-win32-x86_64-windows-5.0.7\data\db --port 10086

1650784658831

2、启动mongo（客户端），连接数据库

mongo

1650784754648

3、默认端口为http://localhost:27017

1650781973317

4、打开cmd，输入

mongod -version

1650784517612

四、配置mongod.cfg

systemLog:
    destination: file
    path: D:\Mongodb\mongodb-win32-x86_64-windows-5.0.7\data\log\mongod.log
storage:
    dbPath: D:\Mongodb\mongodb-win32-x86_64-windows-5.0.7\data\db
net:
    port: 27017

1650788537522

1650790315717

五、管理员执行cmd

1、使用管理员权限执行

mongod --config "D:\Mongodb\mongodb-win32-x86_64-windows-5.0.7\mongod.cfg" --install --serviceName "MongoDB"

1650789883773

2、 cmd输入“services.msc “

services.msc

1650790172369

3、测试直接cmd输入”mongo“

mongo

1650790237265

4、测试直接cmd输入”mongo“，然后输入"show dbs"

mongo
show dbs		#展示数据库
show  databases

1650790507359

二、Mongodb的基本使用

#启动服务
mongo
#显示当前所有的数据库
show dbs
show  databases
#进入指定的数据库
use 数据库名
#db表示的是当前所处的数据库
db
#显示数据库中所有的集合
show collections

1650791749130

三、图形化安装界面

一、mongodbmanagerfree

1、下载的百度云连接

链接：https://pan.baidu.com/s/1As_Sxh0UpVzili_8dLCduQ 
提取码：dx73

选择安装的路劲：D:\Mongodb\NoSQL Manager for MongoDB

1650856382078

2、二、图形化界面

localhost

1650855947262

二、MongoDBCompass

1、官网下载链接

官网链接：https://www.mongodb.com/try/download/compass

1650866138294

2、图形化界面

1650866190940

1650866250292

三、Navicat Premium 12

可视化界面

1650867054256

四、Mongodb的CRUD

==CRUD官方文档：==https://www.mongodb.com/docs/manual/crud/#std-label-crud

一、新增文档

官方文档：https://www.mongodb.com/docs/manual/tutorial/insert-documents/

1、insert

/*
	向数据库插入文档
			db.<collection>.insert()
				- 向集合中插入一个或多个文档
				- 当我们向集合中插入文档时，如果没有给文档指定_id属性时，则数据库会自动为文档添加_id
						该属性作为文档的唯一标识（根据时间戳生成）
				- _id可以自己指定，如果自己指定了数据库就不会再添加了，如果自己指定了_id就需要确保它的唯一性
			db.collection.insertOne()
				- 插入一个文档对象
			db.collection.insertMany()
				- 插入多个文档对象
*/
db.stus.insert({name:"猪八戒",age:28,gender:"男"});

db.stus.insert({_id:"hello",name:"猪八戒",age:28,gender:"男"});

db.stus.insert([
			{name:"沙和尚",age:29,gender:"男"},
			{name:"唐三藏",age:30,gender:"男"},
			{name:"小白龙",age:20,gender:"男"},
]);

/*
  向数据库插入文档
			db.<collection>.find()
				-查询集合中的信息
*/
db.stus.find();

//生成随机id（唯一标识）
ObjectId()

2、$push

#$push：用于向数组中添加一个新的元素 
db.user.update({username:"tangseng"},{$push:{"hobby.movies":"Interstellar"}})

3、 $addToSet

#$addToSet：向数组中添加一个新元素（类似于向set集合中添加，如果数组中已经存在了该元素，则添加失败，因为不可重复）
db.user.update({username:"tangseng"},{$addToSet:{"hobby.movies":"Interstellar"}})

1650869114137

# MongoDB 提供以下方法将文档插入到集合中：
db.collection.insertOne()			将单个文档插入到收藏。
db.collection.insertMany()			将多个文档插入到集合中。
# 插入的其他方法
db.collection.updateOne()与upsert: true选项一起使用时。
db.collection.updateMany()与upsert: true选项一起使用时。
db.collection.findAndModify()与upsert: true选项一起使用时。
db.collection.findOneAndUpdate()与 upsert: true选项一起使用时。
db.collection.findOneAndReplace()与 upsert: true选项一起使用时。
db.collection.bulkWrite().

二、查询文档

官方文档：

查询文件：https://www.mongodb.com/docs/manual/tutorial/query-documents/

查询嵌入/嵌套文档：https://www.mongodb.com/docs/manual/tutorial/query-embedded-documents/

查询数组：https://www.mongodb.com/docs/manual/tutorial/query-arrays/

查询潜入文档数组：https://www.mongodb.com/docs/manual/tutorial/query-array-of-documents/

/*
	查询
			db.collection.find();
				- find()用来查询集合中所有符合条件的文档
				- find()可以接受一个对象作为条件参数
					  {}  表示查询集合中所有的文档
						{属性 : 值} 查询属性是指定的文档
				- find()返回的是一个数组
			db.collection.findOne();
				- 用来查询集合中符合条件的第一个文档
				- findOne()返回的是一个对象
			db.collection.find({}).count();
				- 查询所有结果的数量
*/
db.stus.find();

db.stus.find({});

db.stus.find({_id:"hello"});

db.stus.find({name:"小白龙",age:20});

db.stus.find({age:28});

db.stus.findOne({age:28});
db.stus.findOne({age:28}).name;

db.stus.find({}).count();
db.stus.find({}).length();

1650870266867

三、更新文档

官方文档：https://www.mongodb.com/docs/manual/tutorial/update-documents/

/*
	修改
			db.collection.update(查询条件，新对象);
				- updata()默认情况下会使用新对象来替换旧对象
				- 如果需要修改指定的属性，而不是替换，需要使用“修改操作符”来完成修改
					$set 可以用来修改文档中的指定属性
					$unset 可以用来删除文档的指定属性
				- update()默认情况下只会修改一个
			db.collection.updateOne();
				- 修改一个符合条件的文档
			db.collection.updateMany();
				- 同时修改多个文档
			db.collection.replaceOne();
				-	替换一个文档
	注：1、MongoDB的文档的属性值也可以是一个文档，当一个文档的属性值是文档时，我们称这个文档为内嵌文档
	   2、MongoDB支持直接通过内嵌文档的属性进行查询，如果要查询内嵌文档可以则可以通过==.的形式来匹配，且属性名必		须使用引号==,双引号单引号都可以
*/
db.stus.find();
//替换
db.stus.update({name:"沙和尚"},{age:3});
//修改
db.stus.update(
	{"_id":ObjectId("62663e77861700005f000903")},
	{
		$set:{name:"沙和尚",gender:"male",address:"流沙河"}
	}
)
//删除
db.stus.update(
	{"_id":ObjectId("62663e77861700005f000903")},
	{
		$unset:{address:"流沙河"}
	}
)
//update()默认情况下只改第一个
db.stus.update(
	{"name":"猪八戒"},
	{
		$set:{address:"高老庄"}
	}
)
//updateMany()修改多个
db.stus.updateMany(
	{"name":"猪八戒"},
	{
		$set:{address:"猪老庄"}
	}
)

1650873331814

四、删除文档

官方文档：https://www.mongodb.com/docs/manual/tutorial/remove-documents/

/*
	删除
			db.collection.remove();
				-	remove()可以根据条件来删除文档,传递的条件的方式和find()一样
				- 删除符合条件的所有文档（默认情况下会删除多个）
					- 如果remove()第二个参数传递一个true，则只会删除一个
				- 如果只传递一个空对象，则会删除集合中的所有文档
			db.collection.deleteOne();
			db.collection.deleteMany();
			db.collection.drop();
				- 删除集合（如果数据库里只有一个集合，会把数据库也一并删除）
			db.dropDatabase();
				- 删除数据库
*/
db.stus.find();

db.stus.remove({_id:"hello"});

db.stus.remove({age:28});
db.stus.remove({age:28},true);
//清空集合（性能略差）
db.stus.remove({});
//直接清空集合
db.stus.drop();
//查看集合
show collections;
//删除数据库
db.dropDatabase();

1650877047323

五、练习

#添加两万条数据的性能高，尽量少调用系统的方法
var arr=[];
for(var i=1;i<=20000;i++){
    arr.push({num:i});
}
db.user.insert(arr);
#查询user中num大于5000的文档
db.user.find({num:{$gt:500}})

#查询user中num小于30的文档
db.user.find({num:{$lt:500}})

#查询user中num大于40小于50的文档
db.user.find({num:{$gt:40,$lt:50}})

#查询user前10条的数据
db.user.find({num:{$lte:10}})

#limit()设置显示数据的上限
db.user.find().limit(10)

#查询user中第11条到20条的数据
	#skip()用于跳过指定数量的数据   skip( (页码-1)*每页显示的条数 ).limit(每页显示的条数)
	#MongoDB会自动调整limit()和skip()的位置
db.user.find().skip(10).limit(10)
db.user.find().limit(10).skip(10)

五、文档间的关系

/*
	文档之间的关系
			一对一（one to one）
					- 夫妻（一个丈夫	对应	一个妻子）
					- 在MongoDB，可以通过内嵌文档来体现出一对一的关系
			一对多（one to many）/多对一（many to one）
					-	父母	-	孩子
					-	用户	-	订单
					-	文章	-	评论
					-	也可以通过内嵌文档来映射一对多
			多对多（many to many）
					-	分类	-	商品
					-	老师	-	学生
					-	也可以通过内嵌文档来映射一对多
*/

1、一对一（one to one）

夫妻

#在MongoDB中，可以通过内嵌文档的形式来体现出一对一的关系
db.WifeAndHusband.insert([
    {
        wife:"黄蓉",
        husband:{
            name:"郭靖"
        }
    }, {
        wife:"潘金莲",
        husband:{
            name:"武大郎"
        }
    }
])

2、一对多（one to many）/ 多对一（many to one）

#一对多：父母和孩子、用户和订单、文章和评论，也可以通过内嵌文档的方式来映射一对多的关系（将1的那个属性设置为多的里面的字段）
db.order.insert({
	list:["watermelor"],
    user_id:ObjectId("5f87b1deda684b252c2fc7a5")
})

var user_id = db.users.findOne({username:"swk"})._id
//查询孙悟空的订单
db.order.find({user_id:user_id})

3、多对多（many to many）

db.teacher.insert([
	{name:"洪七公"},
    {name:"黄药师"},
    {name:"龟仙人"}
])

db.stus.insert([
    {
        name:"郭靖",
        tech_ids:[
            ObjectId("5f87b4b6da684b252c2fc7a8"),
            ObjectId("5f87b4b6da684b252c2fc7a9")
        ]
    },   
    {
        name:"孙悟空",
        tech_ids:[
            ObjectId("5f87b4b6da684b252c2fc7a8"),
            ObjectId("5f87b4b6da684b252c2fc7a9"),
            ObjectId("5f87b4b6da684b252c2fc7aa")
        ]
    }
])

4、练习

#查询工资小于1000或者大于2000的员工($or:[{}])
db.emp.find( $or:[ {sal:{$lt:1000}},{sal:{$gt:2500}} ])
db.emp.find();

#为所有工资小于1000的增加400($inc:{})
db.emp.updateMany({sal:{$lte:1000}},{$inc:{$sal:400}});
db.emp.find();

六、sort和投影

# find（）查询文档时，默认情况是按照_id的值进行升序排列
# sort（）可以用来指定文档的排序的规则，需要传递一个属性来指定排序规则，1表示升序，-1表示降序
db.users.find({}).sort({sal:1})
db.users.find({}).sort({sal:1,empno:-1}) //先指定sale的升序 再empno的降序
# limit、skip、sort可以任意顺序的调用
# 查询时，我们可以在第二个参数的位置来设置查询结果的投影,1表示显示，0表示不显示
db.users.find({},{ename:1,_id:0,sal:1})

七、Mongoose

一、什么是mongoose

1、一般我们不会直接用MongoDB的函数来操作MongoDB数据库 ，
2、而Mongose就是一套操作MongoDB数据库的接口。
3、简而言之就是:mongoose也可以操作mongodb数据库，而且它来操作数据库会有更多好处

二、 mongoose的优点有哪些

1、可以为mongodb的文档创建一个模式结构(Schema),说白了就是一个**约束的条件**
2、比原生的Node相比更容易操作mongodb数据库，也就是**更方便**
3、可以使用中间件和其他的应用业务挂钩，可以和其他的应用**结合使用**
4、数据可以通过类型转换转换成对象模型，也就是有方法可以使用。

三、 Mongoose的三个新对象

# Schema(模式对象)
定义了约束mongodb的文档结构的条件
# Model
相当于mongodb中的 collection(集合)
# Document
document表示集合中的具体文档
# 注：值得注意的是这三个都是对象，是对象的话则有它们对应的方法和属性。

八、Mongoose操作MongoDBM

一、搭建项目

1、新建一个文件存放项目

1651115583456

2、使用VSCode打开

建立package.json文件

{
	"name": "mongoose_01",
	"version": "0.0.1"
}

建立helloMongoose.js文件

1651135342774

安装与配置

当需要在webstorm或vscode时编写mongoose时,需要先将mongoose模块引入。步骤如下:
使用Mongoose:
1、下载安装 在终端输入命令行: npm i mongoose --save
2、引入mongose模块
    const mongoose = require('mongoose');
3、 连接mongoDB数据库
    mongoose.connect('mongodb://数据库的ip地址:端口号/数据库名');
    - 端口号是默认的 (27017), 则可以省略不写
4、断开连接(一般不用)
    mongoose.disconnect();
    一般只需要连接一次，除非项目停止服务器关闭，否则连接一般不会断开

-- 监听MongoDB数据库的连接状态
    - 在momgoose对象中, 有一个属性叫 connnection 用来监视数据库的链接状态
    mongoose.connection.once("open", ()=>{});
    mongoose.connection.once("close", ()=>{});

3、npm i mongoose --save

PS E:\FrontEndProject\Mongoose\mongoose_01> npm i mongoose --save
npm notice created a lockfile as package-lock.json. You should commit this file.
npm WARN mongoose_01@0.0.1 No description
npm WARN mongoose_01@0.0.1 No repository field.
npm WARN mongoose_01@0.0.1 No license field.

+ mongoose@6.3.1
added 28 packages from 67 contributors in 4.246s

4、引入与连接数据库

//引入
var mongoose = require("mongoose");
//连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");

5、运行

在VSCode安装Code Runner
然后右击js，点击Run Code运行

1651135490697

6、node运行连接数据库

//引入
var mongoose = require("mongoose");
//连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");

mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

PS E:\FrontEndProject\Mongoose> cd .\mongoose_01\
PS E:\FrontEndProject\Mongoose\mongoose_01> node helloMongoose.js
数据库连接成功~~~

1651135980316

7、node运行断开数据库

//引入
var mongoose = require("mongoose");
//连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");

mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

mongoose.connection.once("close", ()=>{
	console.log("数据库连接断开~~~");
});

//断开数据库连接
mongoose.disconnect();

PS E:\FrontEndProject\Mongoose\mongoose_01> node .\helloMongoose.js
数据库连接成功~~~
数据库连接断开~~~
PS E:\FrontEndProject\Mongoose\mongoose_01>

1651136233894

二、Schema和Model

01_mongoose_demo.js

//引入
var mongoose = require("mongoose");
//连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");

mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

//创建Schema(模式)对象
//将mongoose.Schema 赋值给一个变量
var Schema = mongoose.Schema;

//创建Schema（模式）对象
var stuSchema = new Schema({
	name:String,
	age:Number,
	gender:	{
		type:String,
		default:"female"
	},
	address:String,
});

//通过Schema创建Model
//Model代表的是数据库中的集合，通过Model才能对数据库进行操作
//mongoose.model(modelName,schema);
//modelName就是要映射的集合名(mongoose会自动将集合名变成复数)
var StuModel = mongoose.model("student",stuSchema);

//向数据库里插入一个文档(创建一个文档并插入到数据库中)
// StuModel.create({
// 	name:"孙悟空",
// 	age:18,
// 	gender:"male",
// 	address:"花果山"
// },function(err){
// 	if(!err){
// 		console.log("插入成功");
// 	}else{
// 		console.log("插入失败");
// 	}
// });
StuModel.create({
	name:"白骨精",
	age:16,
	address:"白骨洞"
},function(err){
	if(!err){
		console.log("插入成功");
	}else{
		console.log("插入失败");
	}
});

PS E:\FrontEndProject\Mongoose\mongoose_01> node .\01_mongoose_demo.js
数据库连接成功~~~
插入成功

1651138172138

1651138192869

三、Model

#共有部分
var mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

var Schema = mongoose.Schema;

var stuSchema = new Schema({
	name:String,
	age:Number,
	gender:	{
		type:String,
		default:"female"
	},
	address:String,
});

var StuModel = mongoose.model("student",stuSchema);

1、插入文档

# 创建一个或多个对象
Model.create(doc,[callback]);
# 创建一个对象
Model.createOne(doc, [callback]);
# 创建多个对象
Model.createMany(doc, [callback]);
	-doc是需要插入的文档
	-callback(err) 是回调函数，可以用来提示是否创建成功了

// CRUD操作
//插入操作
StuModel.create([
	{	name:"猪八戒",	age:28,	gender:"male",	address:"高老庄"},
	{	name:"唐僧",	age:16,	gender:"male",	address:"女儿国"}
	],function(err){
	if(!err){
		console.log("插入成功");
	}else{
		console.log("插入失败");
	}
});

1651213040846

1651213062672

// CRUD操作
//插入操作
StuModel.create([
	{	name:"沙和尚",	age:38,	gender:"male",	address:"流沙河"},
	],function(err){
	if(!err){
		console.log(arguments);
		console.log("插入成功");
	}else{
		console.log("插入失败");
	}
});

1651213808551

1651213823550

2、查询文档

# 查询一个或多个文档
Model.find(condition, 投影, [options], [callback]);
	-- 返回的是数组
# 根据id查询一个文档
Model.findById(id, 投影, [callback]);
# 查询多个文档
Model.findMany(condition, 投影. [callback]); 
# 查询一个文档
Model.findOne(condition, [projection], [options], [callback]);
	-- condition 			查询条件
	-- 投影/ projection: 	投影，也就是 查询条件，有两种方式
			{name: 1, _id:0}: 1是显示，0是不显示	"name  -_id"显示name, 不显示 _id
    -- options:  	查询的选项, skip是跳过，limit是限制 {skip: 3, limit:3}
    -- callback: 	回调函数,有两个参数(err, doc) err是错误类型, doc是文档。

//查询操作
StuModel.find({name:"唐僧"},function(err,docs){
	if(!err){
		console.log(docs);
		console.log("查询成功");
	}else{
		console.log("查询失败");
	}
})

1651214417486

//查询操作
StuModel.find({name:"唐僧"},function(err,docs){
	if(!err){
		console.log(docs);
		console.log(docs instanceof StuModel);
		console.log("查询成功");
	}else{
		console.log("查询失败");
	}
})
StuModel.findById({_id:"626b82c9516240d7632ba335"},function(err,docs){
	if(!err){
		console.log(docs);
		console.log(docs instanceof StuModel);
		console.log("查询成功");
	}else{
		console.log("查询失败");
	}
})

1651215164299

3、修改

# 修改一个或多个文档
Model.updateMany(condition, doc, [options], [callback]);
# 修改一个文档
Model.updateOne(condition, doc, [options], callback);
	** Model.update() 已经不适用了
-- condition 修改的条件
-- doc 修改后的内容/需要修改的内容

# 需要配合修改操作符来使用:
	$set		表示需要设置指定的属性
	$unset		表示需要删除指定的属性
	$push		表示给数组添加一个新元素，因为文档内也会有数组，数组便会有数组元素
	$addToset 	表示给数组添加一个新元素，和push的区别是，如果出现同名的数组元素，则不会再添加
	$gt			大于
	$gte		大于等于
	$lt			小于
	$lte		小于等于
	$or [{条件一,条件二}]		表示或的意思，符合条件一或者条件二	
	$inc		表示自增，用在在原来数据的基础上对数据加减，可用于加薪减薪的操作

//修改操作
StuModel.updateOne({name:"唐僧"},{$set:{age:20}},function(err){
		if(!err){
		console.log("修改成功");
	}else{
		console.log("修改失败");
	}
})
StuModel.find({name:"唐僧"},function(err,docs){
	if(!err){
		console.log(docs);
		console.log("查询成功");
	}else{
		console.log("查询失败");
	}
})

1651215970078

1651215809352

4、删除操作

# 移除一个文档
Model.remove(condition, [callback]);
# 删除一个文档
Model.deleteOne(condition, [callback]);
# 删除多个文档
Model.deleteMany(condition, [callback]);
	-- condition 条件

//删除操作
StuModel.remove({name:"白骨精"},function(err){
	if(!err){
		console.log("删除成功");
	}else{
		console.log("删除失败");
	}
})

1651216361681

1651216371644

5、查看数量

# 获取当前这个集合的符合条件的文档数量
Model.count(condition, [callback]);

StuModel.count({},function(err,count){
	if(!err){
		console.log(count);
	}
})

1651216560498

四、Document

    document.save([options], [callback])
    document.update([options], [callback])
        collection.update不推荐使用。改用updateOne、updateMany或bulkWrite。
    doc.get(name)
        获取指定属性值
        doc.get("name") === doc.name
    doc.set("name", "猪猪") === doc.name = "猪猪"
    doc.id  
        属性, 获取id
    doc.toJSON()
        - 转换成 JSON
    doc.toObject()
        将doc对象 转换成 普通JS对象, 转换后, 所有doc的属性和方法都不能使用了
          --这样就可以将 address给删掉了, 表面上删掉了, 数据库中没有删除
            doc = doc.toObject;
            delete doc.address;
            console.log(doc);

var mongoose = require("mongoose");
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

var Schema = mongoose.Schema;

var stuSchema = new Schema({
	name:String,
	age:Number,
	gender:	{
		type:String,
		default:"female"
	},
	address:String,
});

var StuModel = mongoose.model("student",stuSchema);

//传建一个document
var stu = new StuModel({
	name:"奔波霸",
	age:48,
	gender:"male",
	address:"碧波谭"
})

console.log(stu);
stu.save(function(err){
	if(!err){
		console.log("保存成功~~~");
	}
})

1651220025326

1651220036889

StuModel.findOne({},function(err,doc){
	if(!err){
		console.log("查询成功~~~");
		console.log(doc);
	}
})

五、封装

一、连接mongodb数据库封装

1、创建tools文件夹，创建conn_mongodb.js文件

conn_mongodb.js

//引入
var mongoose = require("mongoose");
//连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
//监听
mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

1651220843404

2、创建index.js文件

require("./tools/conn_mongodb.js")

1651221488301

二、模块封装

1、创建tools文件夹，创建conn_mongodb.js文件

conn_mongodb.js

//引入
var mongoose = require("mongoose");
//连接数据库
mongoose.connect("mongodb://127.0.0.1/mongoose_test");
//监听
mongoose.connection.once("open", ()=>{
	console.log("数据库连接成功~~~");
});

1651220843404

2、创建models文件夹，创建Student.js文件

Student.js

/*
	用来定义Student模型
*/
var mongoose = require("mongoose");

var Schema = mongoose.Schema;

var StuSchema = new Schema({
	name:String,
	age:Number,
	gender:	{
		type:String,
		default:"female"
	},
	address:String,
})

//定义模型
var StuModel = mongoose.model("student",StuSchema);

// exports.model = StuModel;
module.exports = StuModel;

3、创建index.js文件

index.js

require("./tools/conn_mongodb.js");

// var Student = require("./models/Student.js").model;
var Student = require("./models/Student.js");

// console.log(Student);

Student.find({},function(err,docs){
	if(!err){
		console.log(docs);
		console.log("查找成功");
	}else{
		console.log("查找失败");
	}
})

1651591799376

Jin-进

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
MongoDB分布式文件存储数据库

MongoDB是一个基于分布式文件存储的数据库。MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。它支持的数据结构非常松散，是类似json的bson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是它支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。
复制链接

扫一扫