好的，基于Node.js的图书管理系统可以分为以下几个模块：
1. 用户模块：实现用户的注册、登录、修改个人信息等功能。
2. 图书模块：实现图书的添加、修改、删除、查询等功能。
3. 借阅模块：实现用户的借阅、归还操作，并提供相应的借阅记录查询功能。
4. 管理员模块：实现管理员的登录、图书管理、用户管理等功能。
下面是一个简单的实现示例：
1. 创建项目并初始化
```bash
mkdir book-management
cd book-management
npm init -y
```
2. 安装依赖
```bash
npm install express body-parser mongoose jsonwebtoken bcryptjs cors
```
3. 创建数据库模型
在项目根目录下创建`models`目录，并在该目录下创建`user.js`、`book.js`和`borrow.js`三个文件，分别表示用户、图书和借阅记录的数据库模型。
```javascript
// user.js
const mongoose = require('mongoose');
const bcrypt = require('bcryptjs');
const UserSchema = new mongoose.Schema({
username: { type: String, required: true },
password: { type: String, required: true },
email: { type: String },
avatar: { type: String }
});
UserSchema.pre('save', async function(next) {
try {
const salt = await bcrypt.genSalt(10);
const hash = await bcrypt.hash(this.password, salt);
this.password = hash;
next();
} catch (error) {
next(error);
}
});
UserSchema.methods.isValidPassword = async function(password) {
try {
return await bcrypt.compare(password, this.password);
} catch (error) {
throw error;
}
};
const User = mongoose.model('User', UserSchema);
module.exports = User;
```
```javascript
// book.js
const mongoose = require('mongoose');
const BookSchema = new mongoose.Schema({
title: { type: String, required: true },
author: { type: String, required: true },
description: { type: String },
cover: { type: String },
ISBN: { type: String, required: true, unique: true },
category: { type: String },
quantity: { type: Number, default: 0 },
borrow: { type: Number, default: 0 }
});
const Book = mongoose.model('Book', BookSchema);
module.exports = Book;
```
```javascript
// borrow.js
const mongoose = require('mongoose');
const BorrowSchema = new mongoose.Schema({
user: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
book: { type: mongoose.Schema.Types.ObjectId, ref: 'Book', required: true },
borrowDate: { type: Date, required: true },
returnDate: { type: Date }
});
const Borrow = mongoose.model('Borrow', BorrowSchema);
module.exports = Borrow;
```
4. 创建路由
在项目根目录下创建`routes`目录，并在该目录下创建`auth.js`、`book.js`和`borrow.js`三个文件，表示用户认证、图书管理和借阅记录管理的路由。
```javascript
// auth.js
const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const User = require('../models/user');
const router = express.Router();
router.post('/register', async (req, res, next) => {
try {
const { username, password, email, avatar } = req.body;
const existingUser = await User.findOne({ username });
if (existingUser) {
return res.status(400).json({ message: 'Username already exists' });
}
const user = new User({ username, password, email, avatar });
await user.save();
const token = jwt.sign({ user }, process.env.SECRET_KEY);
res.status(201).json({ user, token });
} catch (error) {
next(error);
}
});
router.post('/login', async (req, res, next) => {
try {
const { username, password } = req.body;
const user = await User.findOne({ username });
if (!user) {
return res.status(404).json({ message: 'User not found' });
}
const isMatch = await user.isValidPassword(password);
if (!isMatch) {
return res.status(401).json({ message: 'Wrong password' });
}
const token = jwt.sign({ user }, process.env.SECRET_KEY);
res.status(200).json({ user, token });
} catch (error) {
next(error);
}
});
module.exports = router;
```
```javascript
// book.js
const express = require('express');
const Book = require('../models/book');
const router = express.Router();
router.get('/', async (req, res, next) => {
try {
const books = await Book.find();
res.status(200).json(books);
} catch (error) {
next(error);
}
});
router.post('/', async (req, res, next) => {
try {
const book = new Book(req.body);
await book.save();
res.status(201).json(book);
} catch (error) {
next(error);
}
});
router.put('/:id', async (req, res, next) => {
try {
const { id } = req.params;
const book = await Book.findByIdAndUpdate(id, req.body, { new: true });
if (!book) {
return res.status(404).json({ message: 'Book not found' });
}
res.status(200).json(book);
} catch (error) {
next(error);
}
});
router.delete('/:id', async (req, res, next) => {
try {
const { id } = req.params;
const book = await Book.findByIdAndDelete(id);
if (!book) {
return res.status(404).json({ message: 'Book not found' });
}
res.status(200).json(book);
} catch (error) {
next(error);
}
});
module.exports = router;
```
```javascript
// borrow.js
const express = require('express');
const Borrow = require('../models/borrow');
const router = express.Router();
router.get('/', async (req, res, next) => {
try {
const borrows = await Borrow.find().populate('user').populate('book');
res.status(200).json(borrows);
} catch (error) {
next(error);
}
});
router.post('/', async (req, res, next) => {
try {
const { user, book, borrowDate } = req.body;
const borrow = new Borrow({ user, book, borrowDate });
await borrow.save();
res.status(201).json(borrow);
} catch (error) {
next(error);
}
});
router.put('/:id', async (req, res, next) => {
try {
const { id } = req.params;
const borrow = await Borrow.findByIdAndUpdate(id, req.body, { new: true });
if (!borrow) {
return res.status(404).json({ message: 'Borrow record not found' });
}
res.status(200).json(borrow);
} catch (error) {
next(error);
}
});
router.delete('/:id', async (req, res, next) => {
try {
const { id } = req.params;
const borrow = await Borrow.findByIdAndDelete(id);
if (!borrow) {
return res.status(404).json({ message: 'Borrow record not found' });
}
res.status(200).json(borrow);
} catch (error) {
next(error);
}
});
module.exports = router;
```
5. 创建服务器
在项目根目录下创建`server.js`文件，并在该文件中创建服务器，并将用户认证、图书管理和借阅记录管理的路由挂载到相应的路径上。
```javascript
const express = require('express');
const bodyParser = require('body-parser');
const mongoose = require('mongoose');
const cors = require('cors');
const authRouter = require('./routes/auth');
const bookRouter = require('./routes/book');
const borrowRouter = require('./routes/borrow');
require('dotenv').config();
const app = express();
const port = process.env.PORT || 3000;
const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017/book-management';
mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
.then(() => {
console.log('Connected to MongoDB');
})
.catch((error) => {
console.error(error);
});
app.use(cors());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use('/auth', authRouter);
app.use('/books', bookRouter);
app.use('/borrows', borrowRouter);
app.listen(port, () => {
console.log(`Server is running on port ${port}`);
});
```
6. 运行服务器
使用以下命令启动服务器：
```bash
node server.js
```
然后可以使用Postman等API测试工具测试API接口的功能。
499
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
