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

// main.js - Beispiel für den Hauptprozess
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

<!-- index.html - Beispiel für Renderer-Prozess -->
<!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

// preload.js - Beispiel für ein Preload-Skript
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

const { ipcMain, dialog } = require('electron');

// 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

// Über die vom Preload-Skript bereitgestellte API kommunizieren
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

  1. Plattformübergreifende Konsistenz: Die Anwendung sieht auf allen Betriebssystemen konsistent aus und verhält sich konsistent
  2. Nutzung des Web-Ökosystems: Kann npm-Pakete und Web-Frameworks direkt verwenden
  3. Schnelles Prototyping: Basierend auf vertrauten Web-Technologien, kurzer Entwicklungszyklus
  4. 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 { app, BrowserWindow, ipcMain, dialog } = require('electron');
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

const { contextBridge, ipcRenderer } = require('electron');

contextBridge.exposeInMainWorld('fileAPI', {
  readFile: (filePath) => ipcRenderer.invoke('read-file', filePath),
  selectFile: () => ipcRenderer.invoke('select-file')
});

Renderer-Prozess (index.html):

Beispiel

<!DOCTYPE html>
<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 oderipcMain.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)

Ihr JS-Code läuft in der von Electron gekapselten Node-Umgebung, während die Rendering-Oberfläche in der Chromium WebView läuft.

Weitere Erweiterungen