一文带你搞懂Electron如何优雅的进行进程间通讯_Javascript

electron 本身提供的进程间通讯的方法比较偏底层，使用起来有些繁琐、不易维护。electron 中渲染进程和主进程之间的通讯，其实就像传统 web 开发中网页端与服务器的通讯。那么 electron 中进程间通讯能不能实现像调用 http 请求一样方便呢，答案是肯定的。

以下是一个 http 请求的简单封装：

import { request } from "@/utils/request";

const { vite_host } = import.meta.env;

// #region 操作密码校验接口
export interface icheckpwdresult {
  /**
   * 0:成功，其他：失败
   */
  code: string;
  message: string;
}

export interface icheckpwddata {
  /**
   * 类型：lock_screen:锁屏
   */
  type: string;
  /**
   * 密码
   */
  password: string;
}

/**
 * 操作密码校验接口
 * /project/2205/interface/api/378926
 * @author
 *
 * @param {icheckpwddata} data
 * @returns
 */
export function checkpwd(data: icheckpwddata) {
  return request<icheckpwdresult>({
    url: `${vite_host}/user/operation/pwd/check`,
    method: "post",
    data,
  });
}
// #endregion

下面是 electron 中渲染进程向主进程发送请求的封装：

export const setmaximize = () => {
  return request({
    cmd: "setmaximize",
  });
};

export const setminimize = () => {
  return request({
    cmd: "setminimize",
  });
};

export const closewindow = () => {
  return request({
    cmd: "closewindow",
  });
};

/**
 * @description 获取 mac 地址
 * @returns
 */
export const getmac = () => {
  return request<string>({
    cmd: "getmac",
  });
};

下面细说如何封装：

electron 进程间通讯有四种模式：

渲染器进程到主进程（单向）
渲染器进程到主进程（双向）
主进程到渲染器进程（单向）
渲染器进程到渲染器进程

更多细节可以查看进程间通信 | electron

单向和双向的区别就是：单向的消息发出去之后是没有消息返回的，或者说拿不到返回的消息；双向就是请求发出后可以拿到响应信息，就跟 http 请求一样。

举个例子，页面向主进程发起请求，希望拿到计算机的 mac 地址，主进程通过调用相应的 nodejs api 拿到 mac 地址返回，页面拿到消息结果，这就是双向的。

我并没有用到原生就支持双向的 2 模式，而是使用都是单向的 1、3 模式，通过封装后实现双向的效果。主要是因为 electron 并不支持主进程到渲染器进程的双向模式，也就是主进程给页面主动发送消息后是无法拿到响应的。为了保持封装后代码的统一性，都使用了单向的模式进行封装。

结合下图以及实际代码调用，说说是如何基于单向的消息模式实现双向通讯的。

/**
 * @description 获取 mac 地址
 * @returns
 */
export const getmac = () => {
  return request<string>({
    cmd: "getmac",
  });
};

const handlegetmac = () => {
    getmac().then((mac) => {
      model.mac.value = mac;
    });
};

页面中通过调用getmac方法获取计算机 mac 地址。

getmac方法是一个异步方法，渲染进程在调用这个方法发送消息的时候，会生成一个 uuid，然后将 uuid 、cmd 字段、data 数据（这里没有）放到消息体里再发送给主进程。同时会在回调队列里增加两条回调，一条成功回调，一条失败回调，并且使用 uuid 标识，成功回调就是 then 里面的函数，失败回调就是 catch 里的函数。

主进程接收到消息后，根据cmd 字段做相应的处理，处理完后将结果和渲染进程发送的消息体里的 uuid 放到响应消息体里，响应消息体里也有 cmd 字段，并且是固定（我使用postmessagecallback标识），这样渲染进程在接收到消息的时候就知道这是一条之前发送出去的消息的响应。响应消息体里还有一个code 字段标识是成功还是失败。

渲染进程接收到消息后，根据消息体里的 cmd 字段判断消息是响应消息（cmd为postmessagecallback）还是普通消息（主进程主动发送的消息）。如果是响应消息，根据 uuid 在回调队列里找到相应的回调，再根据 code 判断是执行成功回调还是失败回调。

以上就是渲染进程到主进程的单向消息模式实现双向通讯的整个通讯过程。把消息的发送、处理、返回响应的对象逆过来就是主进程到渲染进程的双向通讯了。

原理说清楚了，下面就是代码实现了。

渲染进程需要有发送消息、监听消息的功能：

contextbridge.exposeinmainworld("ipcrenderer", {
  addeventlistener(
    key: "message",
    listener: (data: { cmd: string; cbid: string; data: unknown }) => void,
  ) {
    return ipcrenderer.on(key, (...args) => {
      const message = args[1] as { cmd: string; cbid: string; data: unknown };
      listener(message);
    });
  },
  postmessage(data: {
    cmd: string;
    data: unknown;
    cdid?: string;
    code?: number;
  }) {
    return ipcrenderer.send("message", data);
  },

这样页面中 window 对象里就有了 ipcrenderer 对象，ipcrenderer 对象提供了 addeventlistener、postmessage 方法，分别用来监听消息和发送消息。

把 addeventlistener、postmessage 再做一下封装，就可以像调用 http 请求一样向主进程发起请求了。

/* eslint-disable no-shadow */
import handle from "./handle";

const callbacks: { [propname: string]: (data: unknown) => void } = {};
const errorcallbacks: { [propname: string]: (data: unknown) => void } = {};

function postmessage(
  data: { cmd: string; data?: unknown },
  cb?: (data: unknown) => void,
  errorcb?: (data: unknown) => void,
) {
  if (cb) {
    const cbid = date.now().tostring();
    callbacks[cbid] = cb;
    window.ipcrenderer?.postmessage({
      cmd: data.cmd,
      data: data.data,
      cbid: cbid,
    });
    if (errorcb) {
      errorcallbacks[cbid] = errorcb;
    }
  } else {
    window.ipcrenderer?.postmessage({
      cmd: data.cmd,
      data: data.data,
    });
  }
}

function request<t = unknown>(params: { cmd: string; data?: unknown }) {
  return new promise<t>((resolve, reject) => {
    postmessage(
      { cmd: params.cmd, data: params.data },
      (res) => {
        resolve(res as t);
      },
      (error) => {
        reject(error);
      },
    );
  });
}

function invokecallback<t = unknown>(cbid: string, res: t) {
  window.ipcrenderer?.postmessage({
    cmd: "postmessagecallback",
    cbid,
    data: res,
    code: 200,
  });
}

function invokeerrorcallback(cbid: string, res: unknown) {
  window.ipcrenderer?.postmessage({
    cmd: "postmessagecallback",
    cbid,
    data: res,
    code: 400,
  });
}

export const addipcrenderereventlistener = () => {
  window.ipcrenderer?.addeventlistener("message", async (message) => {
    console.log("ipcrenderer get message", message);
    // 处理主进程主动发的消息
    if (message.cmd !== "postmessagecallback") {
      if (handle[message.cmd]) {
        try {
          const res = await handle[message.cmd](message.data);
          invokecallback(message.cbid, res);
        } catch (ex: unknown) {
          invokeerrorcallback(message.cbid, ex);
        }
      } else {
        invokeerrorcallback(message.cbid, `方法不存在：${message.cmd}`);
      }
    }
    // 处理回调
    else {
      if (message.code === 200) {
        (callbacks[message.cbid] || function () {})(message.data);
      } else {
        (errorcallbacks[message.cbid] || function () {})(message.data);
      }
      delete callbacks[message.cbid]; // 执行完回调删除
      delete errorcallbacks[message.cbid]; // 执行完回调删除
    }
  });
};

/**
 * @description 获取 mac 地址
 * @returns
 */
export const getmac = () => {
  return request<string>({
    cmd: "getmac",
  });
};

下面是主进程的代码封装：

import { ipcmain } from "electron";
import handle from "./handle";

/* eslint-disable no-shadow */
const callbacks: { [propname: string]: (data: unknown) => void } = {};
const errorcallbacks: { [propname: string]: (data: unknown) => void } = {};
function postmessage(
  webcontents: electron.webcontents,
  data: { cmd: string; data?: unknown },
  cb?: (data: unknown) => void,
  errorcb?: (data: unknown) => void,
) {
  if (cb) {
    const cbid = date.now().tostring();
    callbacks[cbid] = cb;
    webcontents.send("message", {
      cmd: data.cmd,
      data: data.data,
      cbid: cbid,
    });
    if (errorcb) {
      errorcallbacks[cbid] = errorcb;
    }
  } else {
    webcontents.send("message", {
      cmd: data.cmd,
      data: data.data,
    });
  }
}

function request<t = unknown>(
  webcontents: electron.webcontents,
  params: { cmd: string; data?: unknown },
) {
  return new promise<t>((resolve, reject) => {
    postmessage(
      webcontents,
      { cmd: params.cmd, data: params.data },
      (res) => {
        resolve(res as t);
      },
      (error) => {
        reject(error);
      },
    );
  });
}

function invokecallback<t = unknown>(
  webcontents: electron.webcontents,
  cbid: string,
  res: t,
) {
  webcontents.send("message", {
    cmd: "postmessagecallback",
    cbid,
    data: res,
    code: 200,
  });
}

function invokeerrorcallback(
  webcontents: electron.webcontents,
  cbid: string,
  res: unknown,
) {
  webcontents.send("message", {
    cmd: "postmessagecallback",
    cbid,
    data: res,
    code: 400,
  });
}

export const addipcmaineventlistener = () => {
  ipcmain.on(
    "message",
    async (
      event,
      message: { cmd: string; cbid: string; data: unknown; code?: number },
    ) => {
      // 处理渲染进程主动发的消息
      if (message.cmd !== "postmessagecallback") {
        if (handle[message.cmd]) {
          try {
            const res = await handle[message.cmd](event, message.data);
            invokecallback(event.sender, message.cbid, res);
          } catch (ex: unknown) {
            invokeerrorcallback(event.sender, message.cbid, ex);
          }
        } else {
          invokeerrorcallback(
            event.sender,
            message.cbid,
            `方法不存在：${message.cmd}`,
          );
        }
      }
      // 处理发出去的请求的回调
      else {
        if (message.code === 200) {
          (callbacks[message.cbid] || function () {})(message.data);
        } else {
          (errorcallbacks[message.cbid] || function () {})(message.data);
        }
        delete callbacks[message.cbid]; // 执行完回调删除
        delete errorcallbacks[message.cbid]; // 执行完回调删除
      }
    },
  );
};

// 主进程向 ipcrenderer 发起关闭请求，ipcrenderer 弹框确认，ipcrenderer 再通知主进程关闭窗口
export const closewindow = (webcontents: electron.webcontents) => {
  return request(webcontents, {
    cmd: "closewindow",
  });
};

主进程处理消息：

import getmac from "../getmac";

const handle: record<
  string,
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  (event: electron.ipcmainevent, data: any) => void
> = {
  getmac: () => {
    let mac = "";
    try {
      mac = getmac();
    } catch (ex) {
      console.log(ex);
    }
    return mac;
  },
};

export default handle;

封装完之后，进程间的通讯就像发起 http 请求一样简单

const handlegetmac = () => {
    getmac().then((mac) => {
      model.mac.value = mac;
    });
  };

到此这篇关于一文带你搞懂electron如何优雅的进行进程间通讯的文章就介绍到这了,更多相关electron进程间通讯内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！

一文带你搞懂Electron如何优雅的进行进程间通讯

2024年11月25日 • Javascript •我要评论

相关文章:

发表评论


验证码：