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
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
width: 1024,
height: 768,
resizable: true,
webPreferences: {
preload: './preload.js',
nodeIntegration: false
}
});
width,height: Fenstergrößeresizable: Ob die Größe geändert werden kann-
webPreferences: Wird verwendet, um das Verhalten des Renderer-Prozesses zu konfigurierenpreload: Preload-SkriptnodeIntegration: 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 Beispiel
fs、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
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 verwenden
invoke/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
- In
contextIsolation: 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 |
Weitere ErweiterungenVerstä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".