Node.js后台进程实现问询：React-Express-Mongo应用定时任务需求

Hey there! Let's break down how to tackle your requirements step by step—since you're working with the React-Express-Mongo stack, I’ll keep things practical and code-focused so you can follow along easily.

First, let's assume you're using Mongoose (the most common ODM for MongoDB in Express apps). We'll start by defining a Config model to interact with your stored settings, then write a service to retrieve the latest configuration.

Step 1: Create the Config Model #

// models/Config.js
const mongoose = require('mongoose');

const configSchema = new mongoose.Schema({
  esIndex: { type: String, required: true }, // Elasticsearch index name
  queryInterval: { type: Number, required: true, default: 3600000 }, // Default: 1 hour (in ms)
  esQuery: { type: Object, required: true }, // Stored Elasticsearch query JSON
  esNode: { type: String, default: 'http://localhost:9200' }, // Elasticsearch node URL
  // Add any other config fields you need
}, { timestamps: true });

module.exports = mongoose.model('Config', configSchema);

Step 2: Build a Service to Fetch Config #

// services/configService.js
const Config = require('../models/Config');

async function getActiveConfig() {
  // Fetch the latest/only config document (adjust query if you have multiple configs)
  const config = await Config.findOne().sort({ updatedAt: -1 });
  if (!config) throw new Error('No configuration found in MongoDB');
  return config;
}

module.exports = { getActiveConfig };

For scheduling recurring jobs in Node.js, node-schedule or node-cron are reliable choices. We'll use node-schedule here for its flexible interval support.

Step 1: Install the Dependency #

npm install node-schedule

Step 2: Build the Scheduler Service #

This service will start the task based on your MongoDB config, and allow restarting the task if the config changes.

// services/schedulerService.js
const schedule = require('node-schedule');
const { getActiveConfig } = require('./configService');
const { fetchEsData } = require('./esService'); // We'll build this next

let currentJob = null;

async function startScheduledTask() {
  try {
    const config = await getActiveConfig();

    // Cancel existing job if it exists
    if (currentJob) currentJob.cancel();

    // Schedule job using the interval from config (in milliseconds)
    currentJob = schedule.scheduleJob(config.queryInterval, async () => {
      console.log('Starting scheduled Elasticsearch query...');
      await fetchEsData(config);
      console.log('Elasticsearch query completed successfully');
    });

    console.log(`Scheduled task started—runs every ${config.queryInterval / 1000} seconds`);
  } catch (err) {
    console.error('Failed to start scheduled task:', err.message);
  }
}

// Restart task when config is updated
async function restartScheduledTask() {
  await startScheduledTask();
}

module.exports = { startScheduledTask, restartScheduledTask };

Step 3: Initialize the Scheduler in Your Express App #

Add this to your main server file (e.g., app.js) after connecting to MongoDB:

// app.js
const mongoose = require('mongoose');
const { startScheduledTask } = require('./services/schedulerService');

// Connect to MongoDB first
mongoose.connect(process.env.MONGO_URI)
  .then(() => {
    console.log('Connected to MongoDB');
    return startScheduledTask();
  })
  .then(() => {
    app.listen(process.env.PORT, () => {
      console.log(`Server running on port ${process.env.PORT}`);
    });
  })
  .catch(err => console.error('Server startup failed:', err));

We'll use the official @elastic/elasticsearch client to run queries against your Elasticsearch instance.

Step 1: Install the Dependency #

npm install @elastic/elasticsearch

Step 2: Build the Elasticsearch Service #

// services/esService.js
const { Client } = require('@elastic/elasticsearch');

async function fetchEsData(config) {
  // Initialize ES client using config values
  const esClient = new Client({
    node: config.esNode,
    // Add auth here if needed (pull from config if stored)
    // auth: { username: config.esUsername, password: config.esPassword }
  });

  try {
    const response = await esClient.search({
      index: config.esIndex,
      body: config.esQuery // Use the stored query from MongoDB
    });

    // Process the results—example: save to MongoDB or send to frontend
    console.log(`Fetched ${response.hits.total.value} documents from Elasticsearch`);
    // Add your logic here (e.g., insert into a Data collection)
  } catch (err) {
    console.error('Elasticsearch query failed:', err.meta.body.error);
  }
}

module.exports = { fetchEsData };

If you update your config in MongoDB, you'll want to restart the scheduled task automatically. Add an Express route to trigger this:

// routes/configRoutes.js
const express = require('express');
const router = express.Router();
const Config = require('../models/Config');
const { restartScheduledTask } = require('../services/schedulerService');

// Update config and restart task
router.put('/update', async (req, res) => {
  try {
    // Update the existing config (or create if it doesn't exist)
    const updatedConfig = await Config.findOneAndUpdate(
      {}, // Adjust query if you have multiple configs
      req.body,
      { new: true, upsert: true, runValidators: true }
    );

    // Restart the scheduled task with new config
    await restartScheduledTask();

    res.status(200).json({
      message: 'Config updated and task restarted',
      config: updatedConfig
    });
  } catch (err) {
    res.status(500).json({ error: err.message });
  }
});

module.exports = router;

Don't forget to register this route in app.js:

app.use('/api/config', require('./routes/configRoutes'));

• Error Handling: Add retry logic for Elasticsearch queries (try p-retry library) to handle temporary outages.
• Logging: Use tools like winston or pino to log task runs and errors for debugging.
• Environment Variables: Store sensitive values (MongoDB URI, ES auth) in .env files (use dotenv).
• Graceful Shutdown: Cancel the scheduled task when the server stops to avoid memory leaks:

  // app.js
  process.on('SIGINT', async () => {
    if (currentJob) currentJob.cancel();
    await mongoose.disconnect();
    process.exit(0);
  });
  

内容的提问来源于stack exchange，提问作者Tanmay Bhattacharya