Réseau et communication externe d'Electron

Les applications Electron peuvent non seulement exploiter des ressources locales, mais aussi interagir avec des services réseau externes.
Que vous lanciez des requêtes HTTP, établissiez des connexions WebSocket en temps réel, ou utilisiez des modules natifs Node.js,netvous pouvez effectuer des communications réseau comme dans un navigateur ou sur un serveur.


Requête HTTP

Electron prend également en chargel'API de navigateur (fetch)etla bibliothèque tierce (axios)et peut gérer les problèmes de cross-origin et d'authentification.


Utilisation de l'API fetch

fetchest l'interface de requête réseau intégrée aux navigateurs modernes et à Node.js (18+).
Elle prend en charge Promise, possède une syntaxe claire et convient aux requêtes de données courantes.

Exemple

// Exemple de requête GET
fetch('https://jsonplaceholder.typicode.com/posts/1')
  .then(response => {
    if (!response.ok) throw new Error('Erreur de réponse réseau');
    return response.json();
  })
  .then(data => {
    console.log('Données retournées:', data);
  })
  .catch(error => {
    console.error('Échec de la requête:', error);
  });

Description du paramètre :

  • fetch(url, options): Initier la requête;
  • options.method: Méthode de requête (GET, POST, PUT, DELETE);
  • options.headers: Définir les en-têtes de requête;
  • options.bodyCorps de requête, souvent utilisé dans les requêtes POST.

Exemple POST:

fetch('https://api.example.com/login', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ username: 'admin', password: '123456' })
});

intégration d'axios

axiosest un puissant client HTTP qui prend en charge les intercepteurs, les délais d’attente, la concurrence et d’autres fonctionnalités, couramment utilisé dans les applications Electron pour communiquer avec des API backend.

Installation :

npm install axios

Exemple d'utilisation :

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));

Description du paramètre :

  • axios.get(url, config)Effectuer une requête GET ;
  • axios.post(url, data, config)Effectuer une requête POST ;
  • config.timeoutDéfinir le délai d’attente ;
  • config.headersEn-têtes de requête personnalisés.

Gérer les problèmes d’origine croisée

Dans Electron, parce qu’il s’exécute dans un environnement de bureau, par défautIl n’y a aucune restriction CORS du navigateur.。
Mais si la page front-end passe parBrowserWindowLe chargement de contenu web et l’envoi de requêtes peuvent encore déclencher des problèmes d’origine croisée.

Solution :

UtilisationnodeIntegration:
Effectuer les requêtes dans le processus principal plutôt que dans le processus de rendu.

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;
});

Viasession.webRequestModifier les en-têtes de requête :

const { session } = require('electron');
session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
  details.requestHeaders['Origin'] = '*';
  callback({ requestHeaders: details.requestHeaders });
});

Communication WebSocket

WebSocket fournit un canal de communication en temps réel persistant et full-duplex, idéal pour des applications telles que le chat, la diffusion de données et les cotations boursières.

Implémentation du client WebSocket

Electron peut directement utiliser l'API native du navigateurWebSocket API:

Exemple

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

socket.onopen = () => {
  console.log('Connexion WebSocket établie');
  socket.send('Bonjour Serveur !');
};

socket.onmessage = (event) => {
  console.log('Message reçu :', event.data);
};

socket.onclose = () => {
  console.log('Connexion fermée');
};

Description du paramètre :

  • new WebSocket(url): Créer une connexion;
  • socket.send(data): Envoyer un message;
  • onmessageÉcouter la réponse du serveur;
  • oncloseÉcouter la fermeture de la connexion.

Exemple d'application de communication en temps réel

Supposons que nous construisions une interface de salon de discussion en temps réel :

Exemple

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 du processus de rendu :

Exemple

<input id="input" placeholder="Message d'entrée">
<button onclick="sendMessage()">Envoyer</button>
<div id="messages"></div>

Ce modèle peut facilement mettre en œuvre un chat en temps réel, la synchronisation d'état, l'édition collaborative et d'autres fonctionnalités.


Module réseau natif

Le processus principal d'Electron fournit Node.jsnetles modules peuvent créer directement des connexions TCP ou IPC à un niveau inférieur, adaptées aux protocoles personnalisés ou à l'interaction avec des services locaux.

Utilisation du module net

netLe module vous permet de créer des clients ou des serveurs TCP.

Créer un serveur TCP :

Exemple

const net = require('net');

const server = net.createServer(socket => {
  console.log('Client connecté');
  socket.write(Bienvenue sur le serveur TCP Electron);
 
  socket.on('data', data => {
    console.log('Données reçues :', data.toString());
  });
});

server.listen(8080, () => {
  console.log('Serveur TCP démarré, port 8080');
});

Connexion client TCP :

Exemple

const client = net.createConnection({ port: 8080 }, () => {
  console.log('Connecté au serveur');
  client.write('Bonjour serveur !');
});

client.on('data', data => {
  console.log('Réponse du serveur :', data.toString());
});

Description du paramètre :

  • net.createServer(callback): Créer un serveur;
  • socket.write(data): Envoyer des données;
  • socket.on('data'): Recevoir des données;
  • server.listen(port): Écouter sur le port.

gestion de session

Dans ElectronsessionLe module peut contrôler les informations de session réseau telles que le cache, les cookies, le proxy, etc.

Exemple

const { session } = require('electron');

const ses = session.defaultSession;

// Vider le cache
ses.clearCache().puis(() => console.log('Cache vidé'));

// Définir le proxy
ses.setProxy({ proxyRules: 'http=127.0.0.1:8080' });

Gestion des cookies

Exemple

const { session } = require('electron');
const cookies = session.defaultSession.cookies;

// Définir le cookie
cookies.set({
  url: 'https://example.com',
  name: 'token',
  value: 'abc123',
  expirationDate: Date.now() / 1000 + 3600
});

// Obtenir le cookie
cookies.get({ url: 'https://example.com' })
  .then(cookies => {
    console.log('Cookie actuel :', cookies);
  });

Résumé

Lorsque vous effectuez des communications réseau et externes dans Electron, vous pouvez choisir de manière flexible :

Scénarios Solution recommandée
Requêtes HTTP ordinaires fetch ou axios
Données en temps réel WebSocket
Communication locale ou de bas niveau Module net
Gérer l'état de connexion / cache session + cookies

Cette capacité réseau multicouche permet aux applications Electron à la fois d'accéder aux API cloud et de fonctionner en coordination avec les services locaux.


Exemple

L'exemple suivant est un "tableau de bord de données en temps réel" concis qui peut afficher les données récupérées depuis l'API dans le processus de rendu, recevoir des messages WebSocket en temps réel et gérer les cookies d'état de connexion.

I. Structure du projet

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"
  }
}

Installer les dépendances :

npm install

3. main.js (processus principal)

Exemple

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')
}

// Exemple de requête HTTP
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 }
  }
})

// Exemple de serveur WebSocket
const wss = new WebSocket.Server({ port: 8081 })
wss.on('connection', ws => {
  console.log('Client connecté au WebSocket')
  ws.send('Bienvenue pour vous connecter aux données en temps réel WebSocket')
  // Envoi planifié de données
  const interval = setInterval(() => {
    ws.send(`Message en temps réel : ${new Date().toLocaleTimeString`()}`)
  }, 3000)

  ws.on('close', () => clearInterval(interval))
})

// Transférer les messages WebSocket au processus de rendu
ipcMain.handle('connect-ws', async () => {
  return new Promise(resolve => {
    const ws = new WebSocket('ws://localhost:8081')
    ws.on('open', () => console.log('Connecté au serveur WebSocket'))
    ws.on('message', msg => {
      mainWindow.webContents.send('ws-message', msg.toString())
    })
    resolve('Connexion WebSocket établie')
  })
})

// Exemple de gestion des cookies
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 défini avec succès'
})

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 (Communication sécurisée)

Exemple

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 (Interface du processus de rendu)

Exemple

<!DOCTYPE html>
<html lang="zh">
<head>
  <meta charset="UTF-8">
  <title>Exemple de communication réseau avec Electron</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>Exemple de communication réseau avec Electron</h1>

  <button id="fetchBtn">Récupérer les données HTTP</button>
  <button id="wsBtn">Se connecter à WebSocket</button>
  <button id="setCookieBtn">Définir le cookie</button>
  <button id="getCookieBtn">Lire le cookie</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>Données renvoyées par HTTP : ${JSON.stringify(data)}</p>`
    })

    document.getElementById('wsBtn').addEventListener('click', async () => {
      await window.electronAPI.connectWS()
      output.innerHTML += `<p>Connexion WebSocket établie</p>`
    })

    window.electronAPI.onWSMessage(msg => {
      output.innerHTML += `<p>Message WebSocket : ${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>Valeur du jeton cookie : ${value}</p>`
    })
  </script>
</body>
</html>

VI. Exécution et effets

npm start
  • CliquezRécupérer les données HTTP: Récupérer les données de l'API via axios et les afficher sur la page.
  • CliquezConnecter WebSocket: Établir une connexion en temps réel et recevoir un message toutes les 3 secondes.
  • CliquezDéfinir un cookie: créertoken Cookie.
  • CliquezLire le cookie: Lire et affichertokenvaleur.
autres extensions