API 开发

### **Node.js API 开发**

以下是关于 Node.js API 开发的详细介绍，包括常见模式、增删改查、分页和关联查询：

---

### **1. 常见 API 开发模式**
- **RESTful API**：使用 HTTP 方法（`GET`、`POST`、`PUT`、`DELETE`）操作资源。
- **RPC（远程过程调用）**：调用远程服务中的过程或函数。
- **GraphQL**：提供灵活的数据查询和操作方式。

---

### **2. 增删改查（CRUD）**
以下是一个基于 Express.js 和 MongoDB 的 CRUD 示例：

#### **项目结构**
```
api/
├── config/
│   └── db.js
├── models/
│   └── user.js
├── routes/
│   └── users.js
├── controllers/
│   └── userController.js
└── app.js
```

#### **连接 MongoDB**
**config/db.js**
```javascript
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/api_demo', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const db = mongoose.connection;

db.on('error', console.error.bind(console, 'MongoDB connection error:'));
```

#### **用户模型**
**models/user.js**
```javascript
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const userSchema = new Schema({
  name: String,
  email: String,
  age: Number,
  createdAt: {
    type: Date,
    default: Date.now
  }
});

module.exports = mongoose.model('User', userSchema);
```

#### **用户控制器**
**controllers/userController.js**
```javascript
const User = require('../models/user');

exports.getAllUsers = async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};

exports.createUser = async (req, res) => {
  try {
    const user = new User(req.body);
    await user.save();
    res.status(201).json(user);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
};

exports.updateUser = async (req, res) => {
  try {
    const user = await User.findByIdAndUpdate(req.params.id, req.body, {
      new: true
    });
    res.json(user);
  } catch (err) {
    res.status(400).json({ message: err.message });
  }
};

exports.deleteUser = async (req, res) => {
  try {
    await User.findByIdAndDelete(req.params.id);
    res.json({ message: 'User deleted' });
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};
```

#### **用户路由**
**routes/users.js**
```javascript
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');

// 获取所有用户
router.get('/', userController.getAllUsers);

// 创建用户
router.post('/', userController.createUser);

// 更新用户
router.put('/:id', userController.updateUser);

// 删除用户
router.delete('/:id', userController.deleteUser);

module.exports = router;
```

#### **应用入口**
**app.js**
```javascript
const express = require('express');
const app = express();
const userRoutes = require('./routes/users');
require('./config/db');

app.use(express.json());
app.use('/api/users', userRoutes);

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
});
```

#### **测试 API**
使用工具如 Postman 或 curl 测试 API：
- **GET** `http://localhost:3000/api/users`：获取所有用户
- **POST** `http://localhost:3000/api/users`：创建用户
- **PUT** `http://localhost:3000/api/users/:id`：更新用户
- **DELETE** `http://localhost:3000/api/users/:id`：删除用户

---

### **3. 分页**
在 `getAllUsers` 控制器中实现分页：

```javascript
exports.getAllUsers = async (req, res) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 10;
    const startIndex = (page - 1) * limit;
    const endIndex = page * limit;

const results = {};

if (endIndex < await User.countDocuments().exec()) {
      results.next = {
        page: page + 1,
        limit: limit
      };
    }

if (startIndex > 0) {
      results.previous = {
        page: page - 1,
        limit: limit
      };
    }

results.data = await User.find().limit(limit).skip(startIndex).exec();
    res.json(results);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};
```

**测试分页**：
- `http://localhost:3000/api/users?page=1&limit=2`

---

### **4. 关联查询**
假设有一个 `Post` 模型，`User` 模型与 `Post` 模型存在关联（一对多关系）。

#### **Post 模型**
```javascript
const mongoose = require('mongoose');
const Schema = mongoose.Schema;

const postSchema = new Schema({
  title: String,
  content: String,
  author: {
    type: Schema.Types.ObjectId,
    ref: 'User'
  }
});

module.exports = mongoose.model('Post', postSchema);
```

#### **获取用户及其帖子**
修改 `userController` 中的方法：
```javascript
exports.getUserWithPosts = async (req, res) => {
  try {
    const user = await User.findById(req.params.id).populate('posts');
    res.json(user);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};
```

#### **关联路由**
```javascript
router.get('/:id/posts', userController.getUserWithPosts);
```

**测试关联查询**：
- `http://localhost:3000/api/users/:userId/posts`

### **总结**
通过以上步骤，你可以构建一个功能齐全的 Node.js API，支持 CRUD 操作、分页和关联查询。结合 Express.js 和 Mongoose，可以快速搭建出高效且可扩展的 API 服务。如果你需要更高级的功能（如认证、授权等），可以考虑使用 JWT 或 Passport.js 等工具。