nodejs 集成mongodb實現增刪改查

初始化項目:
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’)
解決步驟：