创建Express单例应用实例是否安全？PM2多实例场景下的可行性问询

Absolutely, this approach is totally feasible—and actually a common pattern in Express apps, even when using PM2 with multiple instances. Let me break down why it works, how to implement it, and what to watch out for:

Why it works with PM2 multi-instances #

PM2's multi-instance mode spawns separate, independent Node.js processes for your app. Each process gets its own copy of the Express app instance (since Node.js modules are cached per process, not globally across processes). This means:

• Each process runs its own isolated app singleton, so there’s no cross-process state leakage or conflicts.
• Your services will access the correct app instance for the process they’re running in, just like when you passed req.app before.

How to implement the singleton app pattern #

Here’s a straightforward way to set this up:

1. Export your app instance from your main file #

In your root app.js (or server.js), create and configure your app, then export it:

const express = require('express');
const app = express();

// Configure middleware, app.locals, etc.
app.locals.apiKey = process.env.API_KEY;
app.use(express.json());

// Import routes (they'll now use the exported app)
app.use('/users', require('./routes/users'));
app.use('/orders', require('./routes/orders'));

// Export the app before starting the server
module.exports = app;

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

2. Import the app directly in your services #

In your service files (like services/mySvc.js), you can now require the app instance directly, no need to pass it around:

const app = require('../app');

// Initialize your service using the app's properties
const myService = {
  fetchData: async () => {
    // Use app.locals or other app properties
    const apiKey = app.locals.apiKey;
    // ... your service logic here
  }
};

module.exports = myService;

3. Use the service in your routes #

Your route files can now import the service directly without passing req.app:

const express = require('express');
const router = express.Router();
const myService = require('../services/mySvc');

router.get('/abc-route', async (req, res) => {
  try {
    const data = await myService.fetchData();
    res.json(data);
  } catch (err) {
    res.status(500).send('Error fetching data');
  }
});

module.exports = router;

Key considerations #

• App initialization order: Make sure you export the app after all its configuration (middleware, app.locals, etc.) is complete. Node.js caches module exports, so any changes to the app after export won’t be reflected in imported copies—but since you configure the app before exporting, this isn’t an issue.
• Process-isolated state: Since each PM2 instance is a separate process, any state stored on the app (like app.locals) won’t be shared between processes. This is normal behavior for Node.js multi-process apps, and it’s the same as when you used req.app—so if your services rely on app-level state, just ensure each process initializes that state correctly (e.g., via environment variables or a shared database).
• Testing flexibility: If you need to test services with a mock app instance, you can use dependency injection patterns instead of direct imports. But for most production use cases, the singleton pattern is simple and reliable.

Summary #

Using a singleton Express app instance (exported and imported directly) is a clean, valid approach—even with PM2 multi-instance deployment. Each process gets its own isolated app copy, so you avoid cross-process issues while eliminating the need to pass req.app around in your routes.

内容的提问来源于stack exchange，提问作者Amarjit Singh