Electron-Kernkonzepte

Electron ist im Wesentlichen ein Multi-Prozess-Desktop-Anwendungsframework, dasChromium (Rendering-Schicht)undNode.js (Systemschicht)kombiniert und durch ein unabhängiges Prozessmodell UI-Anzeige, Logiksteuerung und sichere Kommunikation ermöglicht.

Das Folgende ist die Electron-Kernarchitektur und zeigt die Beziehung zwischen Hauptprozess, Renderer-Prozess, IPC-Kommunikation und Preload.

Hauptprozess (A):

  • Läuft auf Node.js, steuert Fenster und interagiert mit dem System.
  • Verwenden Sie BrowserWindow, um den Renderer-Prozess zu erstellen.

Renderer-Prozess (B):

  • Jedes Fenster führt unabhängig HTML/CSS/JS aus, um die Benutzeroberfläche anzuzeigen.

Preload-Skript (B2):

  • Wird ausgeführt, bevor der Renderer-Prozess geladen wird, und verbindet den Hauptprozess mit der Webseiten-Schicht.
  • APIs sicher über contextBridge bereitstellen.

IPC-Kommunikation (gestrichelte Pfeile):

  • Der Hauptprozess und der Renderer-Prozess kommunizieren bidirektional über ipcMain und ipcRenderer.

Betriebssystem (C):

  • Der Hauptprozess kann auf Systemfunktionen zugreifen, wie Dateien, Tray, Benachrichtigungen usw.


Hauptprozess

Der Hauptprozess ist die "Kommandozentrale" der Electron-Anwendung und läuft in einer Node.js-Umgebung.
Er ist für das Erstellen von Fenstern, die Verwaltung des Anwendungslebenszyklus, den Aufruf von System-APIs und die Kommunikation mit dem Renderer-Prozess verantwortlich.
Nach dem Start der Anwendung führt das System zuerst das Skript des Hauptprozesses aus (normalerweisemain.js)。

Aufgaben des Hauptprozesses

  • Starten und Beenden der Anwendung
  • BrowserWindow erstellen und zerstören (Fenster)
  • Menüs, Tray und globale Tastenkürzel registrieren
  • Betriebssystemfunktionen aufrufen (Dateisystem, Benachrichtigungen, Dialoge)
  • Auf Ereignisse lauschen, die vom Renderer-Prozess gesendet werden

Lebenszyklus des Hauptprozesses

Der Lebenszyklus des Hauptprozesses entspricht dem Lebenszyklus der Anwendung, beginnend mitappModulstart:

Beispiel

const { app, BrowserWindow } = require('electron');

app.whenReady().then(() => {
  const win = new BrowserWindow({ width: 800, height: 600 });
  win.loadFile('index.html');
});

app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});
  • app.whenReady(): Wird ausgelöst, nachdem die Electron-Initialisierung abgeschlossen ist.
  • window-all-closed: Wird ausgelöst, wenn alle Fenster geschlossen sind.
  • app.quit(): Beendet die gesamte Anwendung.
  • Häufiger Sonderfall unter macOS: Wenn der Benutzer alle Fenster schließt, läuft das Programm im Hintergrund weiter.

app-Modul im Detail

appModul zur Steuerung des gesamten Lebenszyklus der Anwendung:

  • app.on('ready'): Wird ausgelöst, wenn die Electron-Initialisierung abgeschlossen ist.
  • app.quit(): Anwendung beenden.
  • app.getPath('userData'): Systempfade abrufen.
  • app.setAppUserModelId(id): Windows-Taskleisten-ID festlegen.
  • app.isPackaged: Ermitteln, ob der aktuelle Build paketiert ist.

BrowserWindow-Fensterverwaltung

Hauptprozess überBrowserWindowEin sichtbares Fenster erstellen:

Beispiel

const win = new BrowserWindow({
  width: 1024,
  height: 768,
  resizable: true,
  webPreferences: {
    preload: './preload.js',
    nodeIntegration: false
  }
});
  • width, height: Fenstergröße
  • resizable: Ob die Größe geändert werden kann
  • webPreferences: Wird verwendet, um das Verhalten des Renderer-Prozesses zu konfigurieren

    • preload: Preload-Skript
    • nodeIntegration: Ob der Renderer-Prozess Node.js verwenden darf

Native Funktionen wie Menüs, Tray, Dialoge usw.

Electron bietet mehrere Module für den Zugriff auf Systemfunktionen:

  • Menu / MenuItem: Benutzerdefinierte Menüleiste
  • Tray: Ein Systemtray-Symbol erstellen
  • Dialog: System-Dateiauswahl, Warndialog aufrufen
  • Notification: Native Benachrichtigungen
  • shell: Externe Links oder Dateien öffnen, zum Beispiel:

    const { dialog } = require('electron');
    dialog.showOpenDialog({ properties: ['openFile', 'multiSelections'] });

Renderer-Prozess

Der Renderer-Prozess ist für die Anzeige der Benutzeroberfläche verantwortlich und läuft in einer Chromium-Umgebung.
jedeBrowserWindowJeder hat einen unabhängigen Renderer-Prozess.

Merkmale des Renderer-Prozesses

  • Basiert auf Chromium, führt HTML/CSS/JS aus
  • StandardmäßigKann nicht direkt auf Node.js-APIs zugreifen(Aus Sicherheitsgründen)
  • Kann Webtechnologie-Stacks verwenden: Vue, React, Svelte usw.
  • Jedes Fenster entspricht einem unabhängigen Thread, und sie beeinflussen sich nicht gegenseitig.

Mehrere Fenster und mehrere Renderer-Prozesse

Jedes Electron-Fenster (BrowserWindow) startet einen unabhängigen Renderer-Prozess:
Das Schließen eines Fensters hat keine Auswirkungen auf andere Fenster, ähnlich wie beim Multi-Tab-Modell des Browsers.
Dies macht die Anwendung bei der Wiederherstellung nach einem Absturz sicherer und zuverlässiger.

Laden und Anzeigen von Webseiten

Der Inhalt des Renderer-Prozesses wird vom Hauptprozess geladen:

win.loadFile('index.html');    // 加载本地页面
// 或者
win.loadURL('https://example.com'); // 加载远程网页

Einschränkungen im Renderer-Prozess

  • Aus Sicherheitsgründen können Node.js-Module nicht direkt verwendet werden (wie zum Beispielfs、path)。
  • Es wird nicht empfohlen, rechenintensive Berechnungen im Renderer-Prozess durchzuführen (dies führt zum Einfrieren der UI).
  • Die Interaktion mit dem System erfordert IPC-Kommunikation oder über Preload bereitgestellte APIs.

Interprozesskommunikation (IPC)

Einer der Kernmechanismen von Electron istdie Kommunikation zwischen dem Hauptprozess und dem Renderer-Prozess, genanntIPC(Interprozesskommunikation)。

ipcMain und ipcRenderer

  • ipcMain: Wird im Hauptprozess zum Empfangen von Nachrichten verwendet.
  • ipcRenderer: Wird im Renderer-Prozess zum Senden von Nachrichten verwendet.

Beispiel für Einwegkommunikation:

Beispiel

// main.js
const { ipcMain } = require('electron');
ipcMain.on('ping', (event, arg) => {
  console.log(arg); // Ausgabe "hello from renderer"
});

// renderer.js
const { ipcRenderer } = require('electron');
ipcRenderer.send('ping', 'hello from renderer');

Beispiel für bidirektionale Kommunikation (Hauptprozess sendet Daten zurück):

ipcMain.on('getVersion', (event) => {
  event.reply('getVersionResponse', app.getVersion());
});

Rendererseite empfängt:

ipcRenderer.on('getVersionResponse', (event, version) => {
  console.log(version);
});

invoke/handle-Muster (empfohlener Ansatz)

Electron bietet eine prägnantere Möglichkeit für asynchrone Anfragen:

Hauptprozess:

ipcMain.handle('get-app-path', () => app.getPath('userData'));

Renderer-Prozess:

const result = await ipcRenderer.invoke('get-app-path');
console.log(result);

Dieser Ansatz ähneltfetchAnfragen, wobei mehrere Ebenen von Callbacks vermieden werden.

Bewährte Methoden für die Nachrichtenübermittlung

  • VerwendungExpliziter Kanalname(wie z. B."user:getData")。
  • Vermeiden Sie die Übergabe komplexer Objekte (JSON wird empfohlen).
  • Daten aus dem Renderer-Prozess sollten auf Quelle und Typ validiert werden.
  • Versuchen Sie zu verwendeninvoke/handleImplementieren Sie strukturierte Kommunikation.

Preload-Skripte (Preload Scripts)

Das Preload-Skript läuft vor der Erstellung des Renderer-Prozesses, zwischen dem Hauptprozess und der Webseite.
Seine Rolle besteht darin, Node.js-Funktionen sicher zur Renderer-Seite zu "überbrücken".

Die Rolle und Bedeutung von Preload

  • Kann auf Node.js-APIs zugreifen (aufgrund des isolierten Kontexts)
  • Kann sicher eine kleine Anzahl von APIs für die Renderer-Seite bereitstellen
  • Wird üblicherweise für Dateilesen/-schreiben, Abrufen von Systempfaden, Übermitteln von Anwendungsinformationen usw. verwendet.
// preload.js
const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('electronAPI', {
  getAppVersion: () => ipcRenderer.invoke('getVersion')
});

Der Renderer-Prozess verwendet:

// index.html
<script>
  window.electronAPI.getAppVersion().then(v => {
    console.log('App version:', v);
  });
</script>

contextBridge – Sichere Kommunikation

contextBridgeist eine von Electron bereitgestellte sichere API, die verwendet wird für:

  • Nur die erforderlichen Funktionen freigeben (Whitelist-Mechanismus)
  • Verhindern, dass bösartige Webseiten auf die Node.js-Umgebung zugreifen
  • IncontextIsolation: trueKann im Modus weiterhin sicher kommunizieren

Verwendung im Sandbox-Modus

Wenn Sandbox aktiviert ist (sandbox: true), kann der Renderer-Prozess Node.js überhaupt nicht verwenden.
An diesem Punkt ist Preload die einzige Brücke und verantwortlich für:

  • Aufrufe von der Renderer-Seite empfangen
  • Über IPC an den Hauptprozess weiterleiten
  • Ergebnisse an die Webseite zurückgeben

Zusammenfassung

Modul Funktion Laufzeitumgebung
Hauptprozess (Main) Steuerung des Anwendungslebenszyklus, der Fenster und Systemschnittstellen Node.js
Renderer-Prozess UI anzeigen, Frontend-Logik ausführen Chromium
IPC Kommunikation zwischen dem Hauptprozess und dem Renderer-Prozess implementieren Bidirektionale Pipe
Preload Sichere Überbrückung von Node und Web Zwischenschicht

Verständnis in einem Satz:
Der Hauptprozess ist wie der "Kontrollraum", der Renderer-Prozess ist wie "die Mitarbeiter jedes Fensters",
IPC ist das "Walkie-Talkie", und Preload ist der "gefilterte sichere Kanal".

Weitere Erweiterungen