Node.js 为messenger体系结构选择哪种方法？

我们正在编写一个即时通讯程序，供我们的应用程序中私人使用。当前版本的计划负载是数百个用户，可能是一千或两个

作为一个数据库，我使用Mongo。消息写入

消息

（通过聊天id与用户聊天，uid与用户数据库中的外部表链接）。消息到达客户机时会产生一系列响应事件（标记读取）。很明显，我需要排队。如何做得更好？是否有方法对队列进行优先级排序

一个节点在真空中的球形过程应该承受多少用户？它应该使用多少内存？我使用pm2进行过程管理，使用节点ipc进行广播

向何处求助，向谁请求优化对数据库的请求。现在有一个如下所示的快速书面结构。此示例请求所有聊天，对于每个聊天，它选择最后一条消息、未读消息的数量和最后看到的用户。在MySQL中，我只需要一个大请求就可以完成它。在Mongo这样做更好吗？我和Mongo的水平仍然在中间。

建筑本身。现在，来自客户机的操作来到处理程序，处理程序知道如何处理该操作，并且需要通知处理程序该操作。通常，处理程序通知相应的管理器，并且它已经写入数据库，并且在必要时通知其他进程

---

const loadUserChatsStatistic=async（chatIds，userId）=>{
const startExecTime=新日期（）；
const userChats=await db（）
.collection（“用户聊天”）
.合计([
{$match:{uid:userId，chats_id:{$in:chatIds.map（ObjectID）}，
{
$lookup：{
来自：“聊天室”，
localField:“聊天室id”，
foreignField:“\u id”，
as：“聊天”
}
},
{$REWIND:“$chat”}，
{
$lookup：{
发件人：“上次看到的用户”，
localField:“聊天室id”，
外域：“聊天室id”，
as：“最后一次见面”
}
}
])
.toArray（）；
const chats=等待承诺(
userChats.map（异步userChat=>{
const userscont=await db（）
.collection（“用户聊天”）
.find（{chats_id:userChat.chats_id}）
.count（）；
让unreadCountQuery={}；
if（userChat.last_read）{
unreadCountQuery={u id:{$gt:userChat.last_read}；
}否则{
unreadCountQuery={{u id:{$gt:userChat.\u id}}；
}
const unreadCount=await db（）
.收集（“信息”）
.find（{…unreadCountQuery，chats\u id:userChat.chats\u id}）
.count（）；
常量消息=
（等待db（）
.收集（“信息”）
.findOne（{chats_id:userChat.chats_id}，{sort:{u id:-1}}））||
{};
返回{…userChat，userscont，unreadCount，message}；
})
);
console.log(
“loadUserChatsStatistic的执行时间”，
新日期（）-startExecTime
);
return chats.sort（（a，b）=>{
如果（！a.message.\u id）{
返回true；
}
如果（！b.message.\u id）{
返回false；
}
返回(
新日期（ObjectID（a.message.\u id）.getTimestamp（））<
新日期（ObjectID（b.message.\u id）.getTimestamp（））
);
});
};

很抱歉出现代码截图。Stackoverflow不允许我格式化我的JS代码。为您解决了这个问题。我会在Redis列表中保留所有聊天的头50条消息，异步写入Mongo。未读计数仅保留在Redis中（保留上次读取的邮件id，回答顶部的邮件id-上次读取的id）。

const loadUserChatsStatistic = async (chatIds, userId) => {
  const startExecTime = new Date();
  const userChats = await db()
    .collection("user_chats")
    .aggregate([
      { $match: { uid: userId, chats_id: { $in: chatIds.map(ObjectID) } } },
      {
        $lookup: {
          from: "chats",
          localField: "chats_id",
          foreignField: "_id",
          as: "chat"
        }
      },
      { $unwind: "$chat" },
      {
        $lookup: {
          from: "user_last_seen",
          localField: "chats_id",
          foreignField: "chats_id",
          as: "last_seens"
        }
      }
    ])
    .toArray();

  const chats = await Promise.all(
    userChats.map(async userChat => {
      const usersCount = await db()
        .collection("user_chats")
        .find({ chats_id: userChat.chats_id })
        .count();

      let unreadCountQuery = {};

      if (userChat.last_read) {
        unreadCountQuery = { _id: { $gt: userChat.last_read } };
      } else {
        unreadCountQuery = { _id: { $gt: userChat._id } };
      }
      const unreadCount = await db()
        .collection("messages")
        .find({ ...unreadCountQuery, chats_id: userChat.chats_id })
        .count();
      const message =
        (await db()
          .collection("messages")
          .findOne({ chats_id: userChat.chats_id }, { sort: { _id: -1 } })) ||
        {};

      return { ...userChat, usersCount, unreadCount, message };
    })
  );

  console.log(
    "Execution time for loadUserChatsStatistic",
    new Date() - startExecTime
  );

  return chats.sort((a, b) => {
    if (!a.message._id) {
      return true;
    }

    if (!b.message._id) {
      return false;
    }

    return (
      new Date(ObjectID(a.message._id).getTimestamp()) <
      new Date(ObjectID(b.message._id).getTimestamp())
    );
  });
};