Electron Netzwerk und externe Kommunikation
Electron-Anwendungen können nicht nur auf lokale Ressourcen zugreifen, sondern auch mit externen Netzwerkdiensten interagieren.
Ob Sie HTTP-Anfragen initiieren, Echtzeit-WebSocket-Verbindungen herstellen oder Node.js-nativenetModule verwenden, können Sie Netzwerkkommunikation genau wie in einem Browser oder auf einem Server durchführen.
HTTP-Anfrage
Electron unterstützt außerdemBrowser-API (fetch)undDrittanbieter-Bibliothek (axios)und kann Cross-Origin- und Authentifizierungsprobleme behandeln.
Verwendung der fetch-API
fetchist die in moderne Browser und Node.js (18+) integrierte Schnittstelle für Netzwerkanfragen.
Sie unterstützt Promise, hat eine saubere Syntax und eignet sich für routinemäßige Datenanfragen.
Beispiel
fetch('https://jsonplaceholder.typicode.com/posts/1')
.then(response => {
if (!response.ok) throw new Error('Netzwerkantwortfehler');
return response.json();
})
.then(data => {
console.log('Rückgabedaten:', data);
})
.catch(error => {
console.error('Anfrage fehlgeschlagen:', error);
});
Parameter description:
fetch(url, options): Anfrage initiieren;options.method: Anfragemethode (GET, POST, PUT, DELETE);options.headers: Anfrage-Header setzen;options.bodyAnfrage-Body, wird häufig in POST-Anfragen verwendet.
POST-Beispiel:
fetch('https://api.example.com/login', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ username: 'admin', password: '123456' })
});
axios-Integration
axiosist eine GET-Anfrage;
Installation:
npm install axios
Anwendungsbeispiel:
const axios = require('axios');
// GET 请求
axios.get('https://jsonplaceholder.typicode.com/users')
.then(res => console.log(res.data))
.catch(err => console.error(err));
// POST 请求
axios.post('https://api.example.com/data', { name: 'Tom' })
.then(res => console.log('上传成功', res.data))
.catch(err => console.error('上传失败', err));
Parameter description:
axios.get(url, config)Sende eine GET-Anfrage;axios.post(url, data, config)Sende eine POST-Anfrage;config.timeoutSetze das Timeout;config.headersBenutzerdefinierte Request-Header.
Cross-Origin-Probleme behandeln
In Electron gibt es, da es in einer Desktop-Umgebung läuft, standardmäßigkeine Browser-CORS-Einschränkungen.。
Wenn die Frontend-Seite durchläuftBrowserWindowDas Laden von Webinhalten und das Senden von Anfragen kann weiterhin Cross-Origin-Probleme auslösen.
Lösung:
NutzungnodeIntegration:
Sende Anfragen im Hauptprozess statt im Renderer-Prozess.
const { ipcMain } = require('electron');
const axios = require('axios');
ipcMain.handle('getData', async () => {
const res = await axios.get('https://api.example.com/data');
return res.data;
});
Durchsession.webRequestÄndere Request-Header:
const { session } = require('electron');
session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
details.requestHeaders['Origin'] = '*';
callback({ requestHeaders: details.requestHeaders });
});
WebSocket-Kommunikation
WebSocket bietet einen persistenten, Vollduplex-Echtzeitkommunikationskanal, ideal für Anwendungen wie Chat, Daten-Push und Aktienkurse.
WebSocket-Client-Implementierung
Electron kann direkt die native Browser-WebSocket API:
Beispiel
socket.onopen = () => {
console.log('WebSocket connection established');
socket.send('Hello Server!');
};
socket.onmessage = (event) => {
console.log('Received message:', event.data);
};
socket.onclose = () => {
console.log('Verbindung geschlossen');
};
Parameter description:
new WebSocket(url): Verbindung herstellen;socket.send(data): Nachricht senden;onmessageAuf Serverantwort warten;oncloseAuf das Schließen der Verbindung warten.
Beispiel für eine Echtzeitkommunikationsanwendung
Angenommen, wir erstellen eine Echtzeit-Chatraum-Oberfläche:
Beispiel
socket.onmessage = (e) => {
const messageBox = document.getElementById('messages');
messageBox.innerHTML += `<div>${e.data}</div>`;
};
function sendMessage() {
const input = document.getElementById('input');
socket.send(input.value);
input.value = '';
}
HTML des Renderer-Prozesses:
Beispiel
<button onclick="sendMessage()">Senden</button>
<div id="messages"></div>
Mit diesem Muster lassen sich ganz einfach Echtzeit-Chat, Zustandssynchronisierung, kollaboratives Bearbeiten und andere Funktionen implementieren.
Natives Netzwerkmodul
Der Hauptprozess von Electron stellt Node.js bereit.netModule können direkt TCP- oder IPC-Verbindungen auf einer niedrigeren Ebene erstellen, geeignet für benutzerdefinierte Protokolle oder die Interaktion mit lokalen Diensten.
Verwendung des net-Moduls
netDas Modul ermöglicht es Ihnen, TCP-Clients oder TCP-Server zu erstellen.
TCP-Server erstellen:
Beispiel
const server = net.createServer(socket => {
console.log('Client verbunden');
socket.write(Willkommen beim Electron TCP-Server);
socket.on('data', data => {
console.log('Empfangene Daten:', data.toString());
});
});
server.listen(8080, () => {
console.log('TCP-Server gestartet, Port 8080');
});
TCP-Client-Verbindung:
Beispiel
console.log('Mit Server verbunden');
client.write('Hallo Server!');
});
client.on('data', data => {
console.log('Serverantwort:', data.toString());
});
Parameter description:
net.createServer(callback): Server erstellen;socket.write(data): Daten senden;socket.on('data'): Daten empfangen;server.listen(port): Auf Port lauschen.
Sitzungsverwaltung
In ElectronsessionDas Modul kann Netzwerk-Sitzungsinformationen wie Cache, Cookies, Proxy und mehr steuern.
Beispiel
const ses = session.defaultSession;
// Cache leeren
ses.clearCache().dann(() => console.log('Cache geleert'));
// Proxy setzen
ses.setProxy({ proxyRules: 'http=127.0.0.1:8080' });
Umgang mit Cookies
Beispiel
const cookies = session.defaultSession.cookies;
// Cookie setzen
cookies.set({
url: 'https://example.com',
name: 'token',
value: 'abc123',
expirationDate: Date.now() / 1000 + 3600
});
// Cookie abrufen
cookies.get({ url: 'https://example.com' })
.then(cookies => {
console.log('Aktuelles Cookie:', cookies);
});
Zusammenfassung
Wenn Sie in Electron Netzwerk- und externe Kommunikation durchführen, können Sie flexibel wählen:
| Szenarien | Empfohlene Lösung |
|---|---|
| Gewöhnliche HTTP-Anfragen | fetch oder axios |
| Echtzeitdaten | WebSocket |
| Lokale oder Low-Level-Kommunikation | net-Modul |
| Anmeldestatus / Cache verwalten | Session + Cookies |
Diese mehrschichtige Netzwerkfähigkeit ermöglicht es Electron-Anwendungen, sowohl auf Cloud-APIs zuzugreifen als auch mit lokalen Diensten koordiniert zusammenzuarbeiten.
Beispiel
Das folgende Beispiel ist ein kompaktes "Echtzeit-Daten-Dashboard", das im Renderer-Prozess von der API abgerufene Daten anzeigen, WebSocket-Nachrichten in Echtzeit empfangen und Cookies für den Anmeldestatus verwalten kann.
I. Projektstruktur
my-electron-network-demo/ ├── package.json ├── main.js # 主进程逻辑 ├── preload.js # 预加载脚本 └── index.html # 前端界面
2. package.json
{
"name": "my-electron-network-demo",
"version": "1.0.0",
"description": "Electron 网络通信综合示例",
"main": "main.js",
"scripts": {
"start": "electron ."
},
"devDependencies": {
"electron": "latest",
"axios": "^1.5.0"
}
}
Abhängigkeiten installieren:
npm install
3. main.js (Hauptprozess)
Beispiel
const path = require('path')
const axios = require('axios')
const WebSocket = require('ws')
let mainWindow
function createWindow() {
mainWindow = new BrowserWindow({
width: 900,
height: 600,
webPreferences: {
preload: path.join(__dirname, 'preload.js')
}
})
mainWindow.loadFile('index.html')
}
// HTTP-Anfrage-Beispiel
ipcMain.handle('fetch-data', async () => {
try {
const res = await axios.get('https://jsonplaceholder.typicode.com/posts/1')
return res.data
} catch (err) {
return { error: err.message }
}
})
// WebSocket-Server-Beispiel
const wss = new WebSocket.Server({ port: 8081 })
wss.on('connection', ws => {
console.log('Client ist mit WebSocket verbunden')
ws.send('Willkommen zum Verbinden mit WebSocket-Echtzeitdaten')
// Geplanter Daten-Push
const interval = setInterval(() => {
ws.send(`Echtzeitnachricht: ${new Date().toLocaleTimeString`()}`)
}, 3000)
ws.on('close', () => clearInterval(interval))
})
// WebSocket-Nachrichten an den Renderer-Prozess weiterleiten
ipcMain.handle('connect-ws', async () => {
return new Promise(resolve => {
const ws = new WebSocket('ws://localhost:8081')
ws.on('open', () => console.log('Mit WebSocket-Server verbunden'))
ws.on('message', msg => {
mainWindow.webContents.send('ws-message', msg.toString())
})
resolve('WebSocket-Verbindung hergestellt')
})
})
// Beispiel für Cookie-Verwaltung
ipcMain.handle('set-cookie', async (event, name, value) => {
const cookies = session.defaultSession.cookies
await cookies.set({
url: 'http://localhost',
name,
value,
expirationDate: Date.now() / 1000 + 3600
})
return 'Cookie erfolgreich gesetzt'
})
ipcMain.handle('get-cookie', async (event, name) => {
const cookies = session.defaultSession.cookies
const result = await cookies.get({ url: 'http://localhost', name })
return result.length ? result[0].value : null
})
app.whenReady().then(() => {
createWindow()
})
4. preload.js (Sichere Kommunikation)
Beispiel
contextBridge.exposeInMainWorld('electronAPI', {
fetchData: () => ipcRenderer.invoke('fetch-data'),
connectWS: () => ipcRenderer.invoke('connect-ws'),
onWSMessage: (callback) => ipcRenderer.on('ws-message', (event, msg) => callback(msg)),
setCookie: (name, value) => ipcRenderer.invoke('set-cookie', name, value),
getCookie: (name) => ipcRenderer.invoke('get-cookie', name)
})
5. index.html (Renderer-Prozess-Schnittstelle)
Beispiel
<html lang="zh">
<head>
<meta charset="UTF-8">
<title>Beispiel für Electron-Netzwerkkommunikation</title>
<style>
body { font-family: sans-serif; padding: 20px; }
button { margin: 5px; padding: 10px 20px; cursor: pointer; }
#output { margin-top: 20px; }
</style>
</head>
<body>
<h1>Beispiel für Electron-Netzwerkkommunikation</h1>
<button id="fetchBtn">HTTP-Daten abrufen</button>
<button id="wsBtn">WebSocket verbinden</button>
<button id="setCookieBtn">Cookie setzen</button>
<button id="getCookieBtn">Cookie auslesen</button>
<div id="output"></div>
<script>
const output = document.getElementById('output')
document.getElementById('fetchBtn').addEventListener('click', async () => {
const data = await window.electronAPI.fetchData()
output.innerHTML += `<p>HTTP zurückgegebene Daten: ${JSON.stringify(data)}</p>`
})
document.getElementById('wsBtn').addEventListener('click', async () => {
await window.electronAPI.connectWS()
output.innerHTML += `<p>WebSocket-Verbindung hergestellt</p>`
})
window.electronAPI.onWSMessage(msg => {
output.innerHTML += `<p>WebSocket-Nachricht: ${msg}</p>`
})
document.getElementById('setCookieBtn').addEventListener('click', async () => {
const res = await window.electronAPI.setCookie('token', 'abc123')
output.innerHTML += `<p>${res}</p>`
})
document.getElementById('getCookieBtn').addEventListener('click', async () => {
const value = await window.electronAPI.getCookie('token')
output.innerHTML += `<p>Cookie-Token-Wert: ${value}</p>`
})
</script>
</body>
</html>
VI. Ausführen und Effekte
npm start
- Klicken Sie aufHTTP-Daten abrufen: API-Daten über axios abrufen und auf der Seite anzeigen.
- Klicken Sie aufWebSocket verbinden: Stellen Sie eine Echtzeitverbindung her und empfangen Sie alle 3 Sekunden eine Nachricht.
- Klicken Sie aufCookie setzen: erstellen
tokenCookie. - Klicken Sie aufCookie lesen: Lesen und anzeigen
tokenWert.