Hoàn thành bài "Bài 4: Xử lý dữ liệu request và xây dựng các endpoint CRUD" trước để mở khoá bài này.Đến bài trước

Giới thiệu

Mọi API đều nhận dữ liệu mà nó không tạo ra. Người dùng gửi JSON sai định dạng, thiếu trường, gửi chuỗi vào vị trí cần số, và các payload về mặt kỹ thuật là hợp lệ nhưng sai về mặt logic. Nếu không có lớp xác thực, những vấn đề đó sẽ âm thầm làm hỏng cơ sở dữ liệu của bạn hoặc kích hoạt các lỗi 500 khó hiểu. Nếu không có lớp xử lý lỗi nhất quán, mỗi route sẽ xử lý khác nhau khi có sự cố — một số trả về chuỗi thuần, một số trả về trang lỗi HTML, một số thậm chí không trả về gì cả.

Bài học này sẽ xây dựng cả hai lớp: xác thực yêu cầu bằng thư viện express-validator, và một bộ xử lý lỗi tập trung mang lại cho mọi phản hồi lỗi cùng một hình dạng có thể dự đoán được.

Xác thực dữ liệu yêu cầu đến

express-validator bao bọc thư viện validator.js đã được kiểm thử kỹ lưỡng và tích hợp trực tiếp vào middleware của Express. Cài đặt nó cùng với dự án của bạn:

bash
npm install express-validator

Các quy tắc xác thực được định nghĩa dưới dạng một mảng middleware và được gắn vào một route trước khi handler chạy. Dưới đây là một route POST /users yêu cầu email hợp lệ và mật khẩu có ít nhất tám ký tự:

javascript
const { body, validationResult } = require('express-validator');
const createUserRules = [
body('email').isEmail().withMessage('Must be a valid email address'),
body('password')
.isLength({ min: 8 })
.withMessage('Password must be at least 8 characters'),
];
router.post('/users', createUserRules, (req, res, next) => {
const errors = validationResult(req);
if (!errors.isEmpty()) {
return res.status(422).json({ errors: errors.array() });
}
// safe to use req.body here
res.status(201).json({ message: 'User created' });
});

Gọi validationResult(req) sẽ thu thập mọi vi phạm mà chuỗi quy tắc tìm thấy. Nếu mảng không rỗng, yêu cầu sẽ bị từ chối ngay lập tức với HTTP 422 Unprocessable Entity — mã trạng thái đúng về mặt ngữ nghĩa khi máy chủ hiểu yêu cầu nhưng không thể thực hiện vì dữ liệu không hợp lệ.

Lưu đồ hiển thị luồng yêu cầu: yêu cầu POST đến -> chuỗi middleware xác thực -> kiểm tra validationResult -> nếu có lỗi trả về phản hồi 422, nếu không có lỗi tiếp tục đến route handler

Bạn có thể tách các quy tắc xác thực ra một file riêng khi số lượng route tăng lên, giữ cho các file route chỉ tập trung vào logic nghiệp vụ.

Xây dựng bộ xử lý lỗi tập trung

Express có một chữ ký middleware đặc biệt để xử lý lỗi: bốn tham số thay vì ba. Bất kỳ middleware hoặc route nào gọi next(err) hoặc throw bên trong async wrapper sẽ bỏ qua middleware thông thường và rơi vào đây.

Tạo một file riêng cho nó:

javascript
// middleware/errorHandler.js
function errorHandler(err, req, res, next) {
const statusCode = err.statusCode || 500;
const message = err.message || 'Internal Server Error';
res.status(statusCode).json({
error: {
message,
...(process.env.NODE_ENV === 'development' && { stack: err.stack }),
},
});
}
module.exports = errorHandler;

Đăng ký nó sau tất cả các route trong file app chính. Thứ tự rất quan trọng — Express chỉ gọi handler này nếu nó được định nghĩaở cuối cùng:

javascript
const errorHandler = require('./middleware/errorHandler');
app.use('/api', router);
app.use(errorHandler); // must come after all routes

Bây giờ bất kỳ route nào cũng có thể báo hiệu sự cố bằng cách gắn statusCode vào một đối tượng Error và truyền nó vào next:

javascript
router.get('/users/:id', async (req, res, next) => {
try {
const user = await User.findById(req.params.id);
if (!user) {
const err = new Error('User not found');
err.statusCode = 404;
return next(err);
}
res.json(user);
} catch (error) {
next(error); // unexpected errors get 500
}
});

Mọi lỗi, dù mong đợi hay không, giờ đây đều chảy qua cùng một handler và trả về cùng một cấu trúc JSON. Các team frontend có thể viết một hàm phân tích lỗi duy nhất thay vì phải đoán xem mỗi endpoint trả về gì.

Tạo một lớp AppError tùy chỉnh

Việc truyền các đối tượng Error thô với thuộc tính statusCode được gắn thủ công sẽ trở nên lặp đi lặp lại. Một lớp tùy chỉnh nhỏ sẽ giúp mọi thứ gọn gàng hơn:

javascript
// utils/AppError.js
class AppError extends Error {
constructor(message, statusCode) {
super(message);
this.statusCode = statusCode;
this.isOperational = true; // distinguishes expected errors from bugs
}
}
module.exports = AppError;

Cờ isOperational cho phép error handler của bạn xử lý khác nhau đối với các lỗi bạn cố tình throw so với các sự cố runtime không mong muốn:

javascript
const AppError = require('../utils/AppError');
// in a route
if (!user) {
return next(new AppError('User not found', 404));
}

Bạn có thể kiểm tra isOperational trong error handler để quyết định xem có ghi log toàn bộ stack trace, gửi cảnh báo, hay chỉ đơn giản trả về message nguyên bản.

Sơ đồ hiển thị hai luồng lỗi: lỗi vận hành (isOperational true) đi đến phản hồi JSON an toàn, và lỗi không mong muốn (isOperational false) đi đến bước ghi log/cảnh báo rồi trả về phản hồi 500 chung

Những lỗi thường gặp

Đặt error handler trước các route là sai lầm thường gặp nhất — nó không bao giờ được kích hoạt vì chưa có lỗi nào được truyền đến. Hãy luôn đăng ký nóở cuối cùng.

Dùng HTTP 400 cho mọi lỗi phía client là không chính xác. Hãy dùng 400 cho cú pháp sai, 401 khi thiếu xác thực, 403 khi người dùng đã xác thực nhưng không có quyền, 404 khi tài nguyên không tồn tại, và 422 khi cấu trúc hợp lệ nhưng nội dung vi phạm quy tắc nghiệp vụ.

Để lộ stack trace ở môi trường production là một rủi ro bảo mật thực sự. Conditional spread trong ví dụ errorHandler ở trên (`process.env.NODE_ENV === 'development'`) đảm bảo stack trace chỉ hiển thị ở môi trường local.

Quên wrap các async route handler trong try/catch đồng nghĩa với việc các unhandled promise rejection sẽ bỏ qua hoàn toàn error handler của bạn. Một tiện ích wrapper async mỏng có thể ép buộc pattern này trên tất cả các route mà không cần boilerplate.

Tóm tắt

Validation với express-validator chặn dữ liệu xấu ngay từ đầu và trả về phản hồi có cấu trúc cho client. Một error handler tập trung với định dạng JSON nhất quán giúp API của bạn dễ đoán cho người dùng và dễ bảo trì hơn khi mở rộng. Lớp AppError kết nối cả hai mối quan tâm — cung cấp cho bạn cách sạch sẽ để báo hiệu các lỗi mong đợi từ bất kỳ đâu trong codebase và để một handler duy nhất quyết định cách phản hồi.

Luyện tập sau buổi học

Bài kiểm tra cuối bài

Ôn lại kiến thức, thử sức và nhận góp ý cho bài làm.

0/1
Đã trả lời · 0/1