Node.js路由聚合优化：解耦业务逻辑以避免HTTP调用和子进程

// services/alarmService.js (或类似的模块)

/**
 * 获取告警1的数据。
 * @param {object} req - 请求对象，可能包含用户上下文或站点ID。
 * @returns {object} 告警1的数据。
 */
function getAlarm1Data(req) {
  // 假设这里是实际获取告警1数据的逻辑，例如查询数据库、调用其他内部服务等
  // req对象可以用于访问中间件添加的数据，如req.siteIds
  console.log('Fetching data for Alarm 1. Site IDs:', req.siteIds);
  return {
    id: 'alarm1-uuid',
    status: 'active',
    message: 'Temperature critical in zone A',
    timestamp: new Date().toISOString()
  };
}

/**
 * 获取告警2的数据。
 * @param {object} req - 请求对象。
 * @returns {object} 告警2的数据。
 */
function getAlarm2Data(req) {
  // 假设这里是实际获取告警2数据的逻辑
  console.log('Fetching data for Alarm 2. Site IDs:', req.siteIds);
  return {
    id: 'alarm2-uuid',
    status: 'inactive',
    message: 'Pressure normal in zone B',
    timestamp: new Date().toISOString()
  };
}

// 如果有更多告警，可以继续添加 getAlarm3Data, getAlarm4Data 等

module.exports = {
  getAlarm1Data,
  getAlarm2Data,
  // ...其他告警函数
};

// routes/alarmRoutes.js (或在主应用文件中)
const express = require('express');
const router = express.Router();
const { authenticateUser } = require('../middleware/auth/authenticateUser'); // 假设存在
const { getSiteIds } = require('../middleware/sites/getSiteIds'); // 假设存在
const { getAlarm1Data, getAlarm2Data } = require('../services/alarmService');

// 应用中间件到所有相关告警路由
router.use(authenticateUser);
router.use(getSiteIds);

// 单个告警1路由
router.get('/alarm1', async (req, res) => {
  try {
    const data = getAlarm1Data(req); // 直接调用业务逻辑函数
    res.json(data);
  } catch (error) {
    console.error('Error fetching alarm1:', error);
    res.status(500).json({ error: 'Failed to retrieve alarm1 data.' });
  }
});

// 单个告警2路由
router.get('/alarm2', async (req, res) => {
  try {
    const data = getAlarm2Data(req); // 直接调用业务逻辑函数
    res.json(data);
  } catch (error) {
    console.error('Error fetching alarm2:', error);
    res.status(500).json({ error: 'Failed to retrieve alarm2 data.' });
  }
});

// ...其他独立告警路由

// routes/alarmRoutes.js (续)

// 聚合所有告警的路由
router.get('/all-alarms', async (req, res) => {
  try {
    // 假设业务逻辑函数可能返回Promise（如果它们是异步的）
    // 为了演示，这里假设它们是同步的，但如果实际是异步的，则需要await
    const alarm1Promise = Promise.resolve(getAlarm1Data(req)); // 模拟异步
    const alarm2Promise = Promise.resolve(getAlarm2Data(req)); // 模拟异步
    // ... 添加其他告警的Promise

    const [alarm1Result, alarm2Result] = await Promise.all([
      alarm1Promise,
      alarm2Promise
      // ... 其他告警Promise
    ]);

    const aggregatedData = {
      alarm1: alarm1Result,
      alarm2: alarm2Result
      // ... 组合其他告警结果
    };

    res.json(aggregatedData);
  } catch (error) {
    console.error('Error aggregating all alarms:', error);
    res.status(500).json({ error: 'Failed to retrieve all alarms data.' });
  }
});

module.exports = router;

// app.js (主应用文件)
const express = require('express');
const app = express();
const PORT = 3000;

// 模拟中间件
const authenticateUser = (req, res, next) => {
  console.log('Authenticating user...');
  // 假设认证成功，设置用户ID
  req.user = { id: 'user123' };
  next();
};

const getSiteIds = (req, res, next) => {
  console.log('Fetching site IDs...');
  // 假设根据用户ID获取站点ID
  req.siteIds = ['siteA', 'siteB'];
  next();
};

// 模拟业务逻辑服务
const alarmService = {
  getAlarm1Data: (req) => {
    console.log(`[Service] Getting Alarm 1 data for user ${req.user.id}, sites: ${req.siteIds}`);
    return {
      type: 'alarm1',
      status: 'active',
      message: 'High CPU usage',
      source: 'serverX',
      timestamp: new Date().toISOString()
    };
  },
  getAlarm2Data: (req) => {
    console.log(`[Service] Getting Alarm 2 data for user ${req.user.id}, sites: ${req.siteIds}`);
    return {
      type: 'alarm2',
      status: 'resolved',
      message: 'Network issue fixed',
      source: 'routerY',
      timestamp: new Date(Date.now() - 3600000).toISOString() // 1 hour ago
    };
  },
  getAlarm3Data: async (req) => { // 模拟一个异步操作
    console.log(`[Service] Getting Alarm 3 data (async) for user ${req.user.id}, sites: ${req.siteIds}`);
    return new Promise(resolve => {
      setTimeout(() => {
        resolve({
          type: 'alarm3',
          status: 'pending',
          message: 'Disk space low',
          source: 'storageZ',
          timestamp: new Date().toISOString()
        });
      }, 500); // 模拟500ms延迟
    });
  }
};

// 创建Express路由实例
const router = express.Router();

// 应用全局中间件到所有由该路由器处理的路由
router.use(authenticateUser);
router.use(getSiteIds);

// 定义单个告警路由
router.get('/alarm1', (req, res) => {
  try {
    const data = alarmService.getAlarm1Data(req);
    res.json(data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

router.get('/alarm2', (req, res) => {
  try {
    const data = alarmService.getAlarm2Data(req);
    res.json(data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

router.get('/alarm3', async (req, res) => {
  try {
    const data = await alarmService.getAlarm3Data(req);
    res.json(data);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// 定义聚合告警路由
router.get('/all-alarms', async (req, res) => {
  try {
    // 并行调用所有告警数据获取函数
    const [alarm1, alarm2, alarm3] = await Promise.all([
      Promise.resolve(alarmService.getAlarm1Data(req)), // 同步函数也可以用Promise.resolve包装
      Promise.resolve(alarmService.getAlarm2Data(req)),
      alarmService.getAlarm3Data(req) // 异步函数直接调用
    ]);

    res.json({
      alarm1,
      alarm2,
      alarm3
    });
  } catch (error) {
    console.error('Error fetching all alarms:', error);
    res.status(500).json({ error: 'Failed to retrieve all alarms.' });
  }
});

// 将路由挂载到应用
app.use('/', router);

app.listen(PORT, () => {
  console.log(`Server running on http://localhost:${PORT}`);
});

// 示例调用：
// GET http://localhost:3000/alarm1
// GET http://localhost:3000/alarm2
// GET http://localhost:3000/alarm3
// GET http://localhost:3000/all-alarms