Node.js教程：优化API设计，在单一端点中高效聚合内部路由逻辑

// all-alarms.js (部分示例，展示其思路)
const { spawn } = require('child_process');
const path = require('path');

router.get('/all-alarms', authenticateUser, getSiteIds, async (req, res) => {
  const endpoints = ['/alarm1', '/alarm2'];
  const bearerToken = req.headers.authorization;
  const processes = [];

  const handleEndpoint = (endpoint) => {
    return new Promise((resolve, reject) => {
      // 启动一个子进程来执行另一个Node.js脚本，该脚本会发起HTTP请求
      const process = spawn('node', [path.join(__dirname, '../../', 'call-alarms.js'), endpoint, bearerToken]);
      process.stdout.on('data', (data) => resolve(JSON.parse(data)));
      process.stderr.on('data', (data) => reject(data.toString()));
    });
  };

  try {
    for (const endpoint of endpoints) {
      processes.push(handleEndpoint(endpoint));
    }
    const results = await Promise.all(processes);
    res.json({ alarm1: results[0], alarm2: results[1] });
  } catch (error) {
    res.status(500).json({ error: 'Error aggregating data.' });
  }
});

// call-alarms.js (被子进程调用的脚本)
const axios = require('axios');
const endpoint = process.argv[2];
const bearerToken = process.argv[3];

axios.get(`http://localhost:3000${endpoint}`, { headers: { Authorization: bearerToken } })
  .then((response) => process.stdout.write(JSON.stringify(response.data)))
  .catch((error) => process.stderr.write(error.message));

// services/alarmService.js
const getAlarm1Data = async (userId, siteIds) => {
  console.log(`[AlarmService] Fetching alarm1 data for user ${userId} and sites ${siteIds}`);
  // 模拟异步数据获取，可能涉及数据库查询、外部API调用等
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({
        id: 'alarm1',
        status: 'active',
        message: 'Temperature high',
        triggeredBy: userId,
        relevantSites: siteIds,
        timestamp: new Date().toISOString()
      });
    }, 150); // 模拟网络延迟或数据库查询
  });
};

const getAlarm2Data = async (userId, siteIds) => {
  console.log(`[AlarmService] Fetching alarm2 data for user ${userId} and sites ${siteIds}`);
  // 模拟异步数据获取
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({
        id: 'alarm2',
        status: 'inactive',
        message: 'Pressure normal',
        triggeredBy: userId,
        relevantSites: siteIds,
        timestamp: new Date().toISOString()
      });
    }, 100);
  });
};

// 如果有更多警报，可以继续添加类似的函数
// const getAlarm3Data = async (userId, siteIds) => { /* ... */ };

module.exports = {
  getAlarm1Data,
  getAlarm2Data,
  // getAlarm3Data,
};

// routes/alarmRoutes.js
const express = require('express');
const router = express.Router();
const { getAlarm1Data, getAlarm2Data } = require('../services/alarmService');

// 模拟中间件
const authenticateUser = (req, res, next) => {
  console.log('Middleware: Authenticating user...');
  // 假设认证成功，将用户信息挂载到req上
  req.user = { id: 'user123', role: 'admin' };
  next();
};

const getSiteIds = (req, res, next) => {
  console.log('Middleware: Getting site IDs...');
  // 假设获取站点ID成功，将站点ID挂载到req上
  req.siteIds = ['siteA', 'siteB', 'siteC'];
  next();
};

// 应用全局中间件到此路由模块
// 注意：中间件会在路由处理器之前执行，其结果（如req.user, req.siteIds）可供后续路由处理器使用
router.use(authenticateUser);
router.use(getSiteIds);

// 定义单个警报的API端点
router.get('/alarm1', async (req, res) => {
  try {
    // 从req中获取中间件处理后的数据，并传递给业务逻辑函数
    const alarmData = await getAlarm1Data(req.user.id, req.siteIds);
    res.json(alarmData);
  } catch (error) {
    console.error('Error fetching alarm1:', error);
    res.status(500).json({ error: 'Failed to retrieve alarm1 data.' });
  }
});

router.get('/alarm2', async (req, res) => {
  try {
    const alarmData = await getAlarm2Data(req.user.id, req.siteIds);
    res.json(alarmData);
  } catch (error) {
    console.error('Error fetching alarm2:', error);
    res.status(500).json({ error: 'Failed to retrieve alarm2 data.' });
  }
});

module.exports = router;

// routes/alarmRoutes.js (继续上面的文件)

// 定义聚合所有警报的API端点
router.get('/all-alarms', async (req, res) => {
  try {
    // 并行调用多个业务逻辑函数
    // Promise.all 会等待所有Promise都解决后，返回一个包含所有结果的数组
    const [alarm1Result, alarm2Result] = await Promise.all([
      getAlarm1Data(req.user.id, req.siteIds),
      getAlarm2Data(req.user.id, req.siteIds)
      // 如果有更多警报，可以在这里添加 getAlarm3Data(...)
    ]);

    // 组合结果并返回
    res.json({
      alarm1: alarm1Result,
      alarm2: alarm2Result,
      aggregatedAt: new Date().toISOString()
    });
  } catch (error) {
    console.error('Error fetching all alarms:', error);
    res.status(500).json({ error: 'Failed to retrieve all alarms data.' });
  }
});

// ... (export router at the end of the file)
// module.exports = router;

// app.js (主应用文件)
const express = require('express');
const app = express();
const alarmRoutes = require('./routes/alarmRoutes'); // 引入路由模块

const PORT = 3000;

app.use(express.json()); // 用于解析JSON请求体

// 将警报路由挂载到 /api/alarms 路径下
app.use('/api/alarms', alarmRoutes);

app.get('/', (req, res) => {
  res.send('Welcome to the Alarm API!');
});

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