Node.js中控制器与模型使用类是否合适？实例方案咨询

Great question—let’s break this down clearly, especially since Node.js and Laravel’s runtime models are pretty different, which matters a lot for this choice (and your performance priorities).

Absolutely. Using classes for controllers and models is a solid, maintainable choice in Node.js. Here’s why:

• Structured organization: Classes let you group related logic (e.g., all user-related CRUD methods in a UserController) in a way that’s easy to follow, especially as your app scales.
• Reusability & inheritance: You can create base classes (like a BaseController with common error-handling methods) and extend them for specific controllers, reducing code duplication.
• Familiar OOP patterns: If you’re coming from Laravel or other OOP-heavy frameworks, this approach feels intuitive, making it easier to onboard team members.

Models benefit even more from classes—you can encapsulate database logic, validation, and business rules in a single place instead of scattering them across functions.

This is where Node.js and Laravel diverge sharply, and your performance priority is key here. Let’s break it down by use case:

When to use a single instance (preferred for performance) #

Node.js runs on a single-threaded event loop, so avoiding unnecessary object instantiation is a quick win for performance. You can safely use a single instance if your class is stateless—meaning it doesn’t store any request-specific data in instance properties (like this.currentUser or this.requestParams).

Example: Stateless Controller/Model #

// Stateless UserModel (no instance-specific state)
class UserModel {
  async findById(userId) {
    return await db.query('SELECT * FROM users WHERE id = ?', [userId]);
  }

  async update(userId, data) {
    return await db.query('UPDATE users SET ? WHERE id = ?', [data, userId]);
  }
}

// Stateless UserController (all logic relies on incoming req/res)
class UserController {
  constructor(userModel) {
    this.userModel = userModel; // Dependency injection, still stateless
  }

  async getById(req, res) {
    const user = await this.userModel.findById(req.params.id);
    res.json(user);
  }

  async updateProfile(req, res) {
    const updatedUser = await this.userModel.update(req.params.id, req.body);
    res.json(updatedUser);
  }
}

// Create single instances once, reuse across all requests
const userModel = new UserModel();
const userController = new UserController(userModel);

// Attach to routes (bind to preserve `this` context)
app.get('/users/:id', userController.getById.bind(userController));
app.put('/users/:id', userController.updateProfile.bind(userController));

This approach minimizes memory overhead and object creation time—critical for high-throughput apps. Since there’s no request-specific state stored in the instance, there’s zero risk of cross-request contamination (a big concern in Node.js’s shared event loop).

When to create a per-request instance #

You need a new instance only if your class stores request-specific state in instance properties. For example, if you want to share a currentUser across multiple methods in a controller without passing it around every time:

Example: Stateful Controller #

class UserController {
  constructor(req) {
    this.currentUser = req.user; // Request-specific state stored in instance
  }

  async getProfile() {
    // Reuse this.currentUser instead of passing it in
    return await db.query('SELECT * FROM profiles WHERE user_id = ?', [this.currentUser.id]);
  }

  async updateProfile(data) {
    return await db.query('UPDATE profiles SET ? WHERE user_id = ?', [data, this.currentUser.id]);
  }
}

// Create a new instance for every request
app.get('/profile', async (req, res) => {
  const controller = new UserController(req);
  const profile = await controller.getProfile();
  res.json(profile);
});

In this case, a single instance would be dangerous—if two requests come in at the same time, the currentUser property would be overwritten, leading to bugs. The tradeoff here is slightly higher overhead from instantiation, but it’s necessary for correctness.

• Default to single instances for controllers and models whenever possible—this gives you the best performance in Node.js, as long as you keep your classes stateless.
• Use per-request instances only when you need to store request-specific state—don’t do it just because Laravel does it (Laravel’s PHP runtime is request-isolated by default, so it’s a different paradigm).

内容的提问来源于stack exchange，提问作者Ángel Barrios