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
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
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
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
<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 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
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 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 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 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
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
<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éer
tokenCookie. - CliquezLire le cookie: Lire et afficher
tokenvaleur.