Electron-Architektur
Man kann sich Electron vorstellen als:
Ein Multi-Prozess-Anwendungscontainer mit integrierter Browser-Engine (Chromium) und einer Node.js-Laufzeit,
Desktop-Anwendungen, die "Webseiten + Systemfunktionen" durch Koordination über Interprozesskommunikation (IPC) kombinieren.
Seine Kernkomponenten sind:
| Rolle | Beschreibung | Analogie |
|---|---|---|
| Hauptprozess (Main Process) | Das Gehirn von Electron, das den Anwendungslebenszyklus steuert, Fenster erstellt und System-APIs aufruft | OS-Prozessmanager |
| Renderer-Prozess | Die Webseitenumgebung (HTML, CSS, JS), die von jedem Fenster ausgeführt wird | Browser-Tab |
| Preload-Skript | Läuft vor dem Rendern und kann APIs des Hauptprozesses für die Verwendung durch Webseiten überbrücken | Sicherheits-"Zwischenschicht" |
| IPC (Interprozesskommunikation) | Kommunikationskanal zwischen dem Hauptprozess und den Renderer-Prozessen | Telefonleitung |
| BrowserWindow-Objekt | Der vom Hauptprozess erstellte "Fenstercontainer", der Webseiten darin lädt | Browserfenster |
| App-Modul | Steuert den Anwendungslebenszyklus (Start, Beenden) | Hauptsteuerung |
Hauptprozess
Der Hauptprozess ist das "Gehirn" einer Electron-Anwendung; jede Electron-App hat genau einen Hauptprozess. Er ist verantwortlich für:
- Anwendungsfenster erstellen und verwalten(Renderer-Prozess)
- Anwendungslebenszyklus verwalten(Start, Beenden, Vordergrund-/Hintergrundwechsel)
- Mit nativen Betriebssystem-APIs interagieren
- Systemkomponenten wie Menüs und Dialoge verwalten
Beispiel
const { app, BrowserWindow } = require('electron');
function createWindow() {
// Browserfenster erstellen
const mainWindow = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
nodeIntegration: true,
contextIsolation: false
}
});
// Lädt die index.html der App
mainWindow.loadFile('index.html');
}
// Wird aufgerufen, wenn Electron die Initialisierung abgeschlossen hat
app.whenReady().then(createWindow);
Renderer-Prozess
Der Renderer-Prozess ist für die Anzeige der Benutzeroberfläche verantwortlich; jedes Electron-Fenster ist ein unabhängiger Renderer-Prozess:
- Läuft in der Chromium-Browserumgebung
- Verwenden Sie HTML, CSS und JavaScript, um Oberflächen zu erstellen
- Jedes Fenster ist ein unabhängiger Prozess, und sie beeinflussen sich nicht gegenseitig
- Kommuniziert über IPC mit dem Hauptprozess
Beispiel
<!DOCTYPE html>
<html>
<head>
<title>Meine Electron-App</title>
</head>
<body>
<h1>Hallo Electron!</h1>
<button id="btn">Klick mich</button>
<script>
// JavaScript im Renderer-Prozess
document.getElementById('btn').addEventListener('click', () => {
alert('Der Button wurde angeklickt!');
});
</script>
</body>
</html>
Preload-Skripte
Das Preload-Skript ist die "Brücke", die den Hauptprozess und den Renderer-Prozess verbindet:
- Wird ausgeführt, bevor die Webseite im Renderer-Prozess geladen wird
- Hat Zugriff auf Node.js-APIs und das DOM
- APIs sicher über contextBridge für den Renderer-Prozess verfügbar machen
Beispiel
const { contextBridge, ipcRenderer } = require('electron');
// Eine sichere API für den Renderer-Prozess bereitstellen
contextBridge.exposeInMainWorld('electronAPI', {
showDialog: (message) => ipcRenderer.invoke('show-dialog', message)
});
Interprozesskommunikation (IPC)
IPC-Kommunikationsmuster
IPC(Inter-Process Communication)Ist der Kommunikationskern von Electron.
Da der Hauptprozess und der Renderer-Prozess unabhängig voneinander sind, müssen Daten über IPC übergeben werden.

Kommunikationsrichtung
| Type | Hauptprozess lauscht | Vom Renderer-Prozess gesendet |
|---|---|---|
| Renderer → Main | ipcMain.on(channel, handler) |
ipcRenderer.send(channel, data) |
| Main → Renderer | event.sender.send(channel, data) |
ipcRenderer.on(channel, callback) |
Einfaches Kommunikationsbeispiel
Main-Prozess-Code:
Beispiel
// Auf Nachrichten vom Renderer-Prozess lauschen
ipcMain.handle('show-dialog', async (event, message) => {
const result = await dialog.showMessageBox({
type: 'info',
message: message,
buttons: ['OK', 'Cancel']
});
return result;
});
Renderer-Prozess-Code:
Beispiel
document.getElementById('btn').addEventListener('click', async () => {
const result = await window.electronAPI.showDialog('Hello, Electron!');
console.log('Benutzer hat geklickt:', result.response);
});
Architektur-Vorteile & Funktionen
Vorteilsvergleich
| Funktionen | Electron | Traditionelle Desktop-Entwicklung |
|---|---|---|
| Entwicklungstechnologie | Web-Technologien (HTML/CSS/JS) | Native Sprachen (C++/C#/Java) |
| Plattformübergreifende Unterstützung | Einmal entwickeln, auf mehreren Plattformen ausführen | Erfordert separate Entwicklung für jede Plattform |
| Entwicklungseffizienz | Hoch, nutzt das bestehende Web-Ökosystem | Geringer, erfordert das Erlernen plattformspezifischer Technologien |
| Leistung | Relativ gering, verbraucht mehr Ressourcen | Hoch, native Leistung |
| Größe des Installers | Groß (enthält Chromium) | die kleinere |
Kernfunktionen
- Plattformübergreifende Konsistenz: Die Anwendung sieht auf allen Betriebssystemen konsistent aus und verhält sich konsistent
- Nutzung des Web-Ökosystems: Kann npm-Pakete und Web-Frameworks direkt verwenden
- Schnelles Prototyping: Basierend auf vertrauten Web-Technologien, kurzer Entwicklungszyklus
- Umfangreiche APIs: Bietet einen vollständigen API-Satz für den Zugriff auf systemeigene Funktionen
Praktische Anwendungsbeispiele
Erstellen wir eine einfache Dateimanager-Anwendung, um die Electron-Architektur zu demonstrieren:
Hauptprozess (main.js):
Beispiel
const fs = require('fs').promises;
const path = require('path');
let mainWindow;
function createWindow() {
mainWindow = new BrowserWindow({
width: 1000,
height: 700,
webPreferences: {
preload: path.join(__dirname, 'preload.js'),
contextIsolation: true
}
});
mainWindow.loadFile('index.html');
}
// Datei-Lesevorgang verarbeiten
ipcMain.handle('read-file', async (event, filePath) => {
try {
const content = await fs.readFile(filePath, 'utf-8');
return { success: true, content };
} catch (error) {
return { success: false, error: error.message };
}
});
// Dateiauswahl verarbeiten
ipcMain.handle('select-file', async () => {
const result = await dialog.showOpenDialog(mainWindow, {
properties: ['openFile'],
filters: [
{ name: 'Textdatei', extensions: ['txt', 'md', 'js', 'html', 'css'] }
]
});
return result;
});
app.whenReady().then(createWindow);
Preload-Skript (preload.js):
Beispiel
contextBridge.exposeInMainWorld('fileAPI', {
readFile: (filePath) => ipcRenderer.invoke('read-file', filePath),
selectFile: () => ipcRenderer.invoke('select-file')
});
Renderer-Prozess (index.html):
Beispiel
<html>
<head>
<title>Einfacher Dateimanager</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
.container { max-width: 800px; margin: 0 auto; }
button { padding: 10px 15px; margin: 5px; cursor: pointer; }
#content { border: 1px solid #ccc; padding: 15px; margin-top: 10px;
min-height: 300px; white-space: pre-wrap; }
</style>
</head>
<body>
<div class="container">
<h1>Einfacher Dateimanager</h1>
<button id="selectBtn">Datei auswählen</button>
<button id="clearBtn">Inhalt löschen</button>
<div>
<h3>Dateiinhalt:</h3>
<div id="content">Bitte wählen Sie eine Datei aus...</div>
</div>
</div>
<script>
const selectBtn = document.getElementById('selectBtn');
const clearBtn = document.getElementById('clearBtn');
const contentDiv = document.getElementById('content');
selectBtn.addEventListener('click', async () => {
const result = await window.fileAPI.selectFile();
if (!result.canceled && result.filePaths.length > 0) {
const filePath = result.filePaths[0];
const fileResult = await window.fileAPI.readFile(filePath);
if (fileResult.success) {
contentDiv.textContent = `Dateipfad: ${filePath}\n\n${fileResult.content}`;
} else {
contentDiv.textContent = `Fehler beim Lesen der Datei: ${fileResult.error}`;
}
}
});
clearBtn.addEventListener('click', () => {
contentDiv.textContent = 'Bitte wählen Sie eine Datei aus...';
});
</script>
</body>
</html>
Weitere wichtige Module (im Hauptprozess verfügbar)
| Modulname | Funktion |
|---|---|
app |
Steuert den Anwendungslebenszyklus (Start/Beenden) |
Menu / MenuItem |
Erstellen der Anwendungsmenüleiste |
Tray |
Systemtray-Symbol |
Notification |
Systembenachrichtigung |
dialog |
Dialog zum Öffnen/Speichern von Dateien |
shell |
Das Standardprogramm des Systems aufrufen, um Dateien oder URLs zu öffnen |
nativeImage |
Bilder (Symbole) manipulieren |
clipboard |
Manipulieren von Zwischenablageinhalten |
powerMonitor |
System-Energieereignisse abhören |
screen |
Bildschirminformationen abrufen (Unterstützung mehrerer Monitore) |
Sicherheitsarchitektur und Sandbox-Isolierung
Da Renderer-Prozesse Webseiten ausführen können, implementiert Electron die folgenden Sicherheitsdesigns, um zu verhindern, dass bösartiger Code das System angreift:
| Policy | Beschreibung |
|---|---|
| NodeIntegration deaktivieren | Standardfalse, sodass Webseiten keine System-APIs direkt aufrufen können. |
| ContextIsolation aktivieren | Seitenskripte und Preload-APIs in einem isolierten Kontext ausführen lassen. |
| Preload + contextBridge | Die sicheren, dem Frontend bereitgestellten APIs klar kontrollieren. |
| Content-Security-Policy (CSP) | Skriptquellen einschränken, um XSS zu verhindern. |
| Sandbox-Modus | Sandboxing kann aktiviert werden, um den Renderer-Prozess vollständig zu isolieren. |
| Remote-URLs validieren | Nicht vertrauenswürdige Remote-Inhalte müssen einer Whitelist-Validierung unterzogen werden. |
Ausführungsablauf (Vom Start bis zum Rendern)
1、启动应用 (electron .)
↓
2、执行 main.js(主进程启动)
↓
3、app.whenReady() 触发,创建 BrowserWindow
↓
4、BrowserWindow 启动新的渲染进程(Chromium 实例)
↓
5、preload.js 先执行(在隔离上下文中)
↓
6、index.html 加载并显示(运行前端框架)
↓
7、渲染进程通过 IPC 调用主进程逻辑
↓
8、主进程处理请求、返回结果
↓
9、用户关闭窗口 → 主进程监听 → app.quit()
Haupt-/Untergeordnetes Mehrfenstermodell (Multiprozess-parallel)
- Eine Electron-Anwendung hat immer nureinen Hauptprozess;
- Kann abermehrere Renderer-Prozesse haben (jedes Fenster ist unabhängig);
- Die Kommunikation zwischen ihnen muss über die Weiterleitung des Hauptprozesses erfolgen oder
ipcMain.handleAsynchrone Überbrückung durchführen.
Schematische Darstellung:
主进程 (Main) ├── 窗口1 → 渲染进程A (index.html) ├── 窗口2 → 渲染进程B (settings.html) └── 窗口3 → 渲染进程C (dashboard.html)
Interne Kernkomponenten von Electron (zugrunde liegende Abhängigkeiten)
| Stufe | Technologie |
|---|---|
| UI-Rendering-Schicht | Chromium(Blink + V8) |
| System-Schnittstellen-Schicht | Node.js(libuv + C++-Bindings) |
| Prozessverwaltungsschicht | Electron Core (C++ + JavaScript) |
| Anwendungslogikschicht | Ihr JS/TS-Code (Main + Renderer) |
Weitere ErweiterungenIhr JS-Code läuft in der von Electron gekapselten Node-Umgebung, während die Rendering-Oberfläche in der Chromium WebView läuft.