Comment effectuer un transfert de couche intermédiaire dans nodejs

Node.js, en tant qu'environnement d'exécution JavaScript, permet aux développeurs d'écrire du code côté serveur à l'aide du langage JavaScript. Pendant le processus de développement, Node.js est souvent utilisé comme couche intermédiaire pour réaliser la transmission de données ou transmettre des requêtes entre le front-end et le back-end. Dans cet article, je présenterai en détail comment utiliser Node.js pour le transfert de niveau intermédiaire.

1. Avantages de Node.js

En tant qu'environnement d'exécution JavaScript basé sur des E/S événementielles et asynchrones, Node.js présente les avantages suivants dans le développement d'applications réseau :

1. Modèle d'E/S asynchrone : Node. js utilise un modèle basé sur les événements pour asynchroniser les opérations d'E/S, ce qui ne bloquera pas l'exécution ultérieure du code et améliorera le débit et les performances de concurrence du système.
2. Modèle monothread : Node.js adopte un modèle monothread, ce qui évite la surcharge de commutation entre plusieurs threads et réduit la complexité des développeurs qui écrivent du code simultané.
3. Léger : le code principal de Node.js ne contient que quelques centaines de fichiers et très peu de fichiers de bibliothèque, il démarre donc et s'exécute rapidement.
4. Convient au traitement d'un grand nombre de petites requêtes de données : Node.js est adapté au traitement d'un grand nombre de petites requêtes de données, telles que les WebSockets, les connexions longues, les sondages HTTP, etc.

2. Transfert de couche intermédiaire de Node.js

1. Transmission de la demande du client

Entre le front-end et le back-end, la demande du client doit être transmise via une couche intermédiaire. Les utilisateurs accèdent à la page frontale à l'aide d'un navigateur, la page frontale envoie une demande au niveau intermédiaire et le niveau intermédiaire transmet la demande au back-end.

2. Implémentation du code de la couche intermédiaire

La couche intermédiaire peut être écrite à l'aide de Node.js. Voici les étapes d'implémentation du code :

(1) Créez un serveur HTTP Node.js.

const http = require('http');
const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  // 处理请求
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

(2) Définissez le port ouvert du serveur et écoutez les requêtes HTTP sur le port spécifié sur la machine locale.

(3) La couche intermédiaire reçoit la requête front-end et transmet les informations de la requête au serveur back-end.

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  const options = {
    hostname: 'www.example.com',
    port: 80,
    path: req.url,
    method: req.method,
    headers: req.headers
  };

  const proxyReq = http.request(options, (proxyRes) => {
    proxyRes.on('data', (chunk) => {
      res.write(chunk);
    });

    proxyRes.on('end', () => {
      res.end();
    });

    res.writeHead(proxyRes.statusCode, proxyRes.headers);
  });

  req.on('data', (chunk) => {
    proxyReq.write(chunk);
  });

  req.on('end', () => {
    proxyReq.end();
  });
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

(4) Dans le processus de traitement de la demande par la couche intermédiaire, copiez les informations de la demande dans un objet de demande proxy, ajoutez l'adresse, le port, la méthode de demande et les informations d'en-tête de demande du serveur principal à la demande proxy. objet, puis utilisez http. La fonction .request() demande au serveur backend.

(5) Dans l'objet de requête proxy, ajoutez une fonction d'écoute pour traiter les données et les événements de fin répondus par le serveur back-end, et envoyez les données de réponse au front-end.

(6) Définissez la surveillance des événements dans la couche intermédiaire en même temps. Lorsque la transmission des données de la demande frontale est terminée, les données de la demande sont écrites dans l'objet de demande proxy. Une fois l'écriture des données terminée, la fonction de fin est terminée. utilisé.

(7) Une fois le traitement terminé, libérez l'objet de demande de proxy.

3. Résumé

Dans cet article, nous avons présenté la méthode de Node.js comme couche intermédiaire pour implémenter le transfert de requêtes. Grâce à l'excellent modèle d'E/S asynchrone et au modèle monothread, Node.js devient le meilleur choix pour. traiter un grand nombre de petites demandes de données. Bon outil. Dans la pratique, l'implémentation de transfert de couche intermédiaire de Node.js est largement utilisée dans les domaines d'application. Par exemple, dans l'architecture des microservices, Node.js est utilisé pour réaliser la communication entre les services, ce qui améliore la fiabilité et l'évolutivité du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!