Node.js性能监控与远程桌面监控实现方案

作者：接口漫谈时间：2026-10-23 09:17:37浏览：488

本文介绍两种Node.js实用场景的实现。首先通过中间件拦截res.send()，在HTTP响应头X-Execution-Time中返回请求处理耗时，无需修改业务代码。其次详解基于Socket.IO和electron的远程桌面监控方案，涵盖服务端定时截图推送、客户端动态渲染以及通过robot-js实现鼠标键盘事件反向控制的全过程。

Node.js性能监控实现

本文介绍Node.js性能监控的相关实践。

近期需要监控Node.js应用的运行性能。由于逐一分析日志较为繁琐，采用记录每个HTTP请求处理时间并直接返回至HTTP Response Header中的方式更为简便。

记录HTTP请求耗时逻辑简单：在接收请求时记录起始时间戳，在响应请求时记录结束时间戳，两者之差即为处理耗时。

然而，res.send()调用分散在各个JS文件中，逐一修改每个URL处理函数并不现实。

正确的做法是利用中间件实现。由于Node.js没有直接拦截res.send()的方法，需要转换思路。

放弃传统面向对象编程思维，将res.send()视为函数对象。具体做法是先保存原始处理函数res.send，随后使用自定义处理函数替换它：


app.use(function (req, res, next) {
  // 记录start time:
  var exec_start_at = Date.now();
  // 保存原始处理函数:
  var _send = res.send;
  // 绑定我们自己的处理函数:
  res.send = function () {
    // 发送Header:
    res.set('X-Execution-Time', String(Date.now() - exec_start_at));
    // 调用原始处理函数:
    return _send.apply(res, arguments);
  };
  next();
});‘

仅需几行代码即可完成时间戳的记录工作。

对于res.render()方法无需额外处理，因为其内部会自动调用res.send()。

调用apply()函数时，必须传入res对象，否则原始处理函数的this指向undefined将导致错误。

实测首页响应时间为9毫秒：

x-execution-time

Node.js性能监控实现

远程桌面监控原理与实现

此外，下面介绍Node.js实现远程桌面监控的具体方法。

最近使用Node.js开发了一个远程桌面监控应用，包含服务端和客户端两部分。客户端可实时监控服务端桌面，并通过鼠标和键盘操作控制服务端桌面。

Node.js性能监控实现

由于测试环境为同一台电脑，监控画面显示如下（实际使用时需两台电脑分别运行客户端和服务端）：

原理

该应用功能主要分为两部分：一是监控，即客户端能查看服务端桌面。这部分通过服务端定时截图（如每秒数次），并通过socketio发送至客户端，客户端通过更改img的src属性逐帧显示最新图片，从而呈现动态桌面效果。

二是控制，即客户端对监控画面的操作（鼠标和键盘）能在服务端桌面生效。这在electron应用中通过监听所有鼠标和键盘事件（如keydown、keyup、keypress、mousedown、mouseup、mousemove、click等）实现，并通过socketio将事件传递至服务端，服务端利用robot-js执行相应事件，从而使客户端操作在服务端触发。

实现

原理阐述完毕，接下来进行具体实现（源码链接见原文）。

Socket通信建立

实现socket通信

首先，服务端和客户端分别引入socket.io和socket.io-client，并分别初始化。

服务端代码示例：


const app = new Koa();
const server = http.createServer(app.callback());
createSocketIO(server);

app.use((ctx): void => {
 ctx.body = 'please connect use socket';
});

server.listen(port, (): void => {
 console.log('server started at http://localhost:' + port);
});


//createSocketIO
const io = socketIO(server, {
 pingInterval: 10000,
 pingTimeout: 5000,
 cookie: false
 });
io.on('connect', (socket): void => {
 socket.emit('msg', 'connected');
}

客户端代码示例：


var socket = this.socket = io('http://' + this.ip + ':3000')
socket.on('msg', (msg) => {
 console.log(msg)
})
socket.on('error', (err) => {
 alert('出错了' + err)
})

这样，服务端和客户端便通过socketio建立了连接。

桌面监控功能实现

实现桌面监控

首先在服务端进行截图，使用screenshot-desktop包。


const screenshot = require('screenshot-desktop')

const SCREENSHOT_INTERVAL = 500;

export const createScreenshot = (): Promise<[string, Buffer]> => {
 return screenshot({format: 'png'}).then((img): [string, Buffer] => {
 return [ img.toString('base64'), img];
 }).catch((err): {} => {
 console.log('截图失败', err);
 return err;
 })
}

export const startScreenshotTimer = (callback): {} => {
 return setInterval((): void => {
 createScreenshot().then(([imgStr, img]): void => {
  callback(['data:image/png;base64,' + imgStr, img]);
 })
 }, SCREENSHOT_INTERVAL)
}

随后通过socketio的emit方法发送至客户端：


startScreenshotTimer(([imgStr, img]): void => {
 io.sockets.emit('screenshot', imgStr);
});

客户端收到图片后，将其设置到img的src属性上（此处为base64格式的图片URL）：


<img 
 class="screenshot" 
 :src="screenshot"
/>

data () {
 return {
 screenshot: ''
 }
}

socket.on('screenshot', (data) => {
 this.screenshot = data
})

如此便已实现桌面监控，有兴趣的读者可按此思路尝试实现，并不复杂。

当然，该方案存在一定问题，因为需要知晓服务端桌面的尺寸，并据此调整客户端显示图片的尺寸。

处理此细节使用了get-pixels库，可读取本地图片文件的宽高等信息。因此先将图片写入本地，再读取获取屏幕尺寸。


interface ScreenSize {
 width: number;
 height: number;
}

function getScreenSize(img): Promise<ScreenSize> {
 const imgPath = path.resolve(process.cwd(), './tmp.png');
 fs.writeFileSync(imgPath, img);
 return new Promise((resolve): void => {
 getPixels(imgPath, function(err, pixels): void {
  if(err) {
  console.log("Bad image path")
  return
  }
  resolve({
  width: pixels.shape[0],
  height: pixels.shape[1]
  });
 });
 })
}

随后通过socketio传递给客户端：


getScreenSize(img).then(({ width, height}) => {
 io.sockets.emit('screensize', {
 width,
 height
 })
});

客户端收到后调整图片大小即可。


<img 
 class="screenshot" 
 :src="screenshot"
 :style="screenshotStyle"
/>

data () {
 return {
 screenshot: '',
 screenshotStyle: '',
 }
}

socket.on('screensize', (screensize) => {
 this.screenshotStyle = {'width': screensize.width + 'px', 'height': screensize.height + 'px'}
})

至此已实现桌面监控，且图片尺寸与服务端屏幕尺寸一致。

还有一个细节：获取到的图片大小为物理像素，而客户端设置的px为设备无关像素，需除以dpr（设备像素比）得到px值。此处仅在mac下使用，故直接除以2。

远程控制功能实现

实现远程控制

代码编写至此，客户端的electron应用中已可实时显示服务端桌面（至于输入IP的弹框以及electron-vue和typescript等与主要逻辑无关的细节不再展开）。

接下来实现远程控制，包括监听事件、传递事件和执行事件三个部分。

首先定义传递事件的格式：


interface MouseEvent {
 type: string;
 buttonType: string;
 x: number;
 y: number;
}

interface KeyboardEvent {
 type: string;
 keyCode: number;
 keyName: string;
}

鼠标事件MouseEvent，type为鼠标事件类型，具体值包括mousedown、mouseup、mousemove、click、dblclick；buttonType指鼠标左键或右键，值为left或right；x和y为具体坐标。

键盘事件KeyboardEvent，type为键盘事件类型，具体值包括keydown、keyup、keypress；keyCode为键盘码，keyName为键名。

接下来在客户端监听事件：


<img 
 class="screenshot" 
 :src="screenshot"
 :style="screenshotStyle"
 @mousedown="handleMouseEvent"
 @mousemove="handleMouseEvent" 
 @mouseup="handleMouseEvent"
 @click="handleMouseEvent"
 @dblclick="handleMouseEvent" 
/>

window.onkeypress = window.onkeyup = window.onkeydown = this.handleKeyboardEvent

通过socket将事件传递至服务端。


handleKeyboardEvent (e) {
 this.socket && this.socket.emit('userevent', {
 type: 'keyboard',
 event: {
 type: e.type,
 keyName: e.key,
 keyCode: e.keyCode
 }
 })
 },
 handleMouseEvent (e) {
 this.socket && this.socket.emit('userevent', {
 type: 'mouse',
 event: {
 type: e.type,
 buttonType: e.buttons === 2 ? 'right' : 'left',
 x: e.clientX,
 y: e.clientY
 }
 })
 },

然后在服务端取出事件并执行，执行事件使用robot-js：


const { Mouse, Point, Keyboard } = require('robot-js');

interface MouseEvent {
 type: string;
 buttonType: string;
 x: number;
 y: number;
}

interface KeyboardEvent {
 type: string;
 keyCode: number;
 keyName: string;
}

export default class EventExecuter {
 public mouse;
 public keyboard;
 public constructor(){
 this.mouse = new Mouse();
 this.keyboard = new Keyboard();
 }

 public executeKeyboardEvent(event: KeyboardEvent): void {
 switch(event.type) {
  case 'keydown':
  this.keyboard.press(event.keyCode);
  break;
  case 'keyup':
  this.keyboard.release(event.keyCode);
  break;
  case 'keypress':
  this.keyboard.click(event.keyCode);
  break;
  default: break;
 }
 }

 public executeMouseEvent(event): void {
 Mouse.setPos(new Point(event.x, event.y));
 const button = event.buttonType === 'left' ? 0 : 2
 switch(event.type) {
  case 'mousedown':
  this.mouse.press(button);
  break;
  case 'mousemove':
  break;
  case 'mouseup': 
  this.mouse.release(button);
  break;
  case 'click': 
  this.mouse.click(button);
  break;
  case 'dblclick': 
  this.mouse.click(button);
  this.mouse.click(button);
  break;
  default: break;
 }
 }

 public exectue(eventInfo): void {
 console.log(eventInfo);
 switch (eventInfo.type) {
  case 'keyboard':
  this.executeKeyboardEvent(eventInfo.event);
  break;
  case 'mouse':
  this.executeMouseEvent(eventInfo.event);
  break;
  default: break;
 }
 }
}

至此，桌面监控和远程控制的客户端与服务端部分，以及两端通信均已实现。思路并不复杂，但细节较多。有兴趣的读者可下载代码运行测试，或按此思路自行实现，颇具趣味。

总结

以上所述是Node.js实现远程桌面监控的方法，希望对大家有所帮助。如有任何疑问，欢迎留言，小编会及时回复大家！

作者最新文章

全栈开发中JavaScript与Java怎么协作？前后端技术栈配合解析

2026-11-04 11:08:24

Node.js官网访问慢？国内镜像加速下载方案

2026-11-03 18:57:24

Node.js 连接 MySQL 数据库实现增删改查操作

2026-11-03 14:31:14

Windows系统安装Node.js：下载、配置与环境验证

2026-11-03 14:15:56

Linux (Ubuntu/CentOS) 环境下安装Node.js的常用方法

2026-11-03 10:18:39