当前位置：首页 > ai >正文

nodejs 集成mongodb实现增删改查

ai 2025/8/24 10:47:11

初始化项目:
npm init -y
npm install mongoose -save 安装mongoose 插件
mongoose 链接数据库语法：
mongodb://[username:password@]host1[:poert1],host2[:port2]…/[databsase]?[options…]

userame：用户名
passwrod: 密码
host1:port1,host2:port2… 链接地址，mongodb 支持分布式高可用集群模式，可以有多个地址
database : 数据库名称
?options：可以选择的get形式的的连接选项。例如poolSize=10&replicatSet=student

options 的可选内容如下:
useNewUrlParse 布尔值使用新版本的url解析器来解析链接字符串
reconnectTries 数值型，重连次数
reconnectInterval 数值型重连间隔单位是毫米
poolSize 数值连接池大小

本地链接mongodb 示例：

(node:7252) [MONGODB DRIVER] Warning: useNewUrlParser is a deprecated option: useNewUrlParser has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version
(Use node --trace-warnings ... to show where the warning was created)
数据库链接成功

mongoose 的相关概念:
Schema 模型的骨架，可以用来生成模型类，通过模型类可以生成文档
Model 由Schema 产生的构造器,具有属性和行为，，model的每一个实例就是一个Mongodb的document
Instance model的实例，通过new Model()得到

Schema 的语法：
const schema = new Schema({字段名:字段类型});
const schema = new Schema({字段名:选项});

字段类型如下：
String Boolean Number Date Object Array
选项是高度自定义的方式,可以定义字段必填,默认值等属性
,支持的属性如下：
type 数据类型
default 默认值
index 索引选项
backgroup 是否后台创建
unique 是否唯一索引
required 是否必填
unique 是否唯一索引
min 最小值
max 最大值

Schema 实例

const Post = new Schema({
title: { type: String, required: true, unique: true },
content: { type: String, required: true },
createTime: { type: Date, default: new Date(), index: { background: false, unique: true } },
tags: [String], //数组
published: Boolean，
meta: {
praise: Number,
comments: Number
}
});

定义实例方法：语法如下
schema.methods.方法名 = function(参数){
//业务代码
}

在上面的Post 实例代码中添加实例方法

connect();

//定义实例方法
Post.methods.getPraise = function(){
return this.meta.praise;
}

const Model = mongoose.model(‘Post’,Post);
const news = new Model();
news.meta = {praise: 0 ,comments:1};

console.log(news.getPraise());

==================================================
nodejs + mongodb + Schema + model 实现怎删改查

npm init -y
npm install express mongoose dotenv
npm install -D nodemon 热部署插件

添加目录结构：
在这里插入图片描述
models/User.js 定义实例对象和方法类似于java 里面一个普通的pojo

const mongoose = require(‘mongoose’);

const userSchema = new mongoose.Schema({
name: {
type: String,
required: true,
trim: true
},
email: {
type: String,
required: true,
unique: true,
lowercase: true
},
age: {
type: Number,
min: 0
},
isActive: {
type: Boolean,
default: true
},
createdAt: {
type: Date,
default: Date.now
}
});

// 可添加实例方法
userSchema.methods.getUserInfo = function() {
return Name: ${this.name}, Email: ${this.email}, Active: ${this.isActive};
};

// 可添加静态方法
userSchema.statics.findActiveUsers = function() {
return this.find({ isActive: true });
};

// 可添加查询助手
userSchema.query.byName = function(name) {
return this.where({ name: new RegExp(name, ‘i’) });
};

module.exports = mongoose.model(‘User’, userSchema);

routes/users.js 定义路由方法

const express = require(‘express’);
const router = express.Router();
const User = require(‘…/models/User’);

// CREATE - 创建新用户
router.post(‘/’, async (req, res) => {
try {
const user = new User(req.body);
const savedUser = await user.save();
res.status(201).json({
success: true,
data: savedUser,
message: ‘User created successfully’
});
} catch (error) {
if (error.name === ‘ValidationError’) {
const errors = Object.values(error.errors).map(err => err.message);
return res.status(400).json({
success: false,
message: ‘Validation error’,
errors
});
}
res.status(500).json({
success: false,
message: ‘Server error’,
error: error.message
});
}
});

// READ - 获取所有用户
router.get(‘/’, async (req, res) => {
try {
const { name, active } = req.query;
let query = User.find();
// 查询条件示例
if (name) {
query = query.byName(name);
}
if (active !== undefined) {
query = query.where(‘isActive’).equals(active === ‘true’);
}

const users = await query.sort({ createdAt: -1 });
res.json({success: true,count: users.length,data: users
});

} catch (error) {
res.status(500).json({
success: false,
message: ‘Server error’,
error: error.message
});
}
});

// READ - 根据ID获取单个用户
router.get(‘/:id’, async (req, res) => {
try {
const user = await User.findById(req.params.id);
if (!user) {
return res.status(404).json({
success: false,
message: ‘User not found’
});
}
res.json({
success: true,
data: user
});
} catch (error) {
if (error.name === ‘CastError’) {
return res.status(400).json({
success: false,
message: ‘Invalid user ID’
});
}
res.status(500).json({
success: false,
message: ‘Server error’,
error: error.message
});
}
});

// UPDATE - 更新用户
router.put(‘/:id’, async (req, res) => {
try {
const user = await User.findByIdAndUpdate(
req.params.id,
req.body,
{
new: true, // 返回更新后的文档
runValidators: true // 运行验证
}
);

if (!user) {return res.status(404).json({success: false,message: 'User not found'});
}res.json({success: true,data: user,message: 'User updated successfully'
});

} catch (error) {
if (error.name === ‘ValidationError’) {
const errors = Object.values(error.errors).map(err => err.message);
return res.status(400).json({
success: false,
message: ‘Validation error’,
errors
});
}
res.status(500).json({
success: false,
message: ‘Server error’,
error: error.message
});
}
});

// DELETE - 删除用户
router.delete(‘/:id’, async (req, res) => {
try {
const user = await User.findByIdAndDelete(req.params.id);
if (!user) {
return res.status(404).json({
success: false,
message: ‘User not found’
});
}
res.json({
success: true,
message: ‘User deleted successfully’
});
} catch (error) {
if (error.name === ‘CastError’) {
return res.status(400).json({
success: false,
message: ‘Invalid user ID’
});
}
res.status(500).json({
success: false,
message: ‘Server error’,
error: error.message
});
}
});

module.exports = router;

.env 文件保存服务中所需要的配置项
创建一个.env 文件加入如下内容

MONGODB_URI=mongodb://localhost:27017/student
PORT=3000

app.js 定义服务入口,包括组件引入，路由挂载，配置加载和服务启动等功能

const express = require(‘express’);
const mongoose = require(‘mongoose’);
const path = require(‘path’);
require(‘dotenv’).config();

//const userRoutes = require(‘./routes/users’);
// 正确导入路由 - 使用绝对路径
const userRoutes = require(path.join(__dirname, ‘routes’, ‘users’));

const app = express();
const PORT = process.env.PORT || 3000;

// 中间件
app.use(express.json());

// 连接 MongoDB
mongoose.connect(process.env.MONGODB_URI || ‘mongodb://localhost:27017/student’, {
useNewUrlParser: true,
useUnifiedTopology: true
})
.then(() => console.log(‘Connected to MongoDB’))
.catch(err => console.error(‘Could not connect to MongoDB:’, err));

// 路由
app.use(‘/api/users’, userRoutes);

// 启动服务器
app.listen(PORT, () => {
console.log(Server is running on port ${PORT});
});

遇到的问题:
https://dotenvx.com/radar
c:\Users\Lei.Wang170\Desktop\project\node_modules\router\index.js:151
throw new TypeError(‘argument callback is required’)
解决步骤：