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

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

const socket = new WebSocket('wss://echo.websocket.org');

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

const socket = new WebSocket('wss://chat.example.com');

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

<input id="input" placeholder="Nachricht eingeben">
<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 net = require('net');

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

const client = net.createConnection({ port: 8080 }, () => {
  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 { session } = require('electron');

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 { session } = require('electron');
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 { app, BrowserWindow, ipcMain, session } = require('electron')
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

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

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

<!DOCTYPE html>
<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: erstellentoken Cookie.
  • Klicken Sie aufCookie lesen: Lesen und anzeigentokenWert.
Weitere Erweiterungen