Comment configurer la couche intermédiaire de nodejs

Avec le développement rapide d'Internet, les applications Web deviennent de plus en plus complexes et volumineuses. Par conséquent, afin d'améliorer la maintenabilité et l'évolutivité des applications Web, de nombreux développeurs Web adoptent le modèle architectural de niveau intermédiaire. La couche intermédiaire Node.js est une méthode d'implémentation de couche intermédiaire courante, car Node.js offre non seulement des performances d'opération d'E/S efficaces, mais peut également facilement implémenter une programmation basée sur les événements.

Cet article expliquera comment créer une couche intermédiaire simple dans Node.js et implémenter certaines fonctions courantes.

1. Qu'est-ce que la couche intermédiaire ?

La couche intermédiaire fait référence à la couche entre le client et le serveur. Sa fonction principale est de traiter les requêtes des clients et d'envoyer les requêtes au serveur. Dans les applications Web, le niveau intermédiaire est souvent utilisé pour intégrer différents services dans une seule application afin de mieux gérer une logique métier complexe. De plus, la couche intermédiaire peut également être utilisée pour implémenter des fonctions telles que la mise en cache, l'authentification et l'autorisation.

2. Implémentation de la couche intermédiaire Node.js

Dans Node.js, il existe deux manières principales d'implémenter la couche intermédiaire : la couche intermédiaire Socket basée sur le protocole WebSocket et la couche intermédiaire HTTP basée sur le protocole HTTP. Parmi elles, la couche intermédiaire HTTP est la méthode la plus couramment utilisée car elle est compatible avec les standards du Web et facile à mettre en œuvre et à maintenir.

Ce qui suit est un exemple simple de couche intermédiaire Node.js, qui implémente des fonctions telles que le transfert de requêtes, la mise en cache des requêtes et la journalisation des requêtes :

const http = require('http');
const request = require('request');
const url = require('url');

http.createServer((req, res) => {
  // 解析前端请求的url
  const urlObject = url.parse(req.url);
  
  // 配置中间层请求的选项参数
  const options = {
    url: 'http://backend-service' + urlObject.path,
    headers: req.headers
  };
  
  // 处理GET请求的缓存功能
  if (req.method === 'GET') {
    // 检查缓存中是否有数据
    const cacheData = cache.get(options.url);
    if (cacheData) {
      res.writeHead(200, cacheData.headers);
      res.end(cacheData.body);
      console.log('cache hit: ' + options.url);
      return;
    }
  }
  
  // 请求发送到后端服务
  console.log('forwarding request: ' + options.url);
  const proxyRequest = request(options);
  
  // 处理GET请求的缓存功能
  if (req.method === 'GET') {
    // 将响应数据缓存到cache中
    proxyRequest.on('response', (response) => {
      cache.set(options.url, response, response.headers['cache-control']);
    });
  }
  
  // 将请求响应返回给前端
  req.pipe(proxyRequest).pipe(res);
  
  // 请求日志记录
  console.log(req.method + ' ' + req.url + ' ' + res.statusCode);
}).listen(8080);

Dans le code ci-dessus, nous utilisons le module http intégré de Node.js pour créer un serveur HTTP. Une fois que la requête atteint le serveur, nous analysons d'abord l'URL demandée par le front-end et transmettons la requête au service back-end (la valeur par défaut ici est backend-service) en fonction de l'adresse URL. Avant de transmettre la requête au service back-end, nous avons également effectué certains traitements sur la requête :

1. Fonction cache pour le traitement des requêtes GET : Pendant la période de validité, s'il y a des données de réponse pour la requête dans le cache, les données dans le cache sera directement renvoyé au front-end pour éviter les demandes répétées de services back-end.
2. Enregistrer le journal des demandes : affichez la méthode de demande, l'URL et le code d'état de la réponse sur la console Node.js.

De plus, la couche intermédiaire Node.js peut également implémenter de nombreuses autres fonctions, telles que l'authentification des demandes, l'autorisation, la limitation de courant, le disjoncteur, etc.

3. Résumé

En tant que type de modèle d'architecture d'application Web, la fonction principale de la couche intermédiaire est d'intégrer différents services dans une seule application pour mieux gérer une logique métier complexe. Dans Node.js, nous pouvons implémenter la couche intermédiaire via les protocoles HTTP ou WebSocket. Le protocole HTTP est compatible avec les normes Web et est facile à mettre en œuvre et à maintenir. Il s'agit donc de la méthode de mise en œuvre de niveau intermédiaire la plus courante.

Lors de la création de la couche intermédiaire Node.js, nous pouvons tirer parti des performances efficaces des opérations d'E/S et des fonctionnalités de programmation basées sur les événements de Node.js pour implémenter certaines fonctions courantes, telles que le transfert de requêtes, la mise en cache des requêtes et la journalisation des requêtes. . De plus, la couche intermédiaire Node.js peut également implémenter de nombreuses autres fonctions, telles que l'authentification des demandes, l'autorisation, la limitation et la fusion de courant, etc., pour améliorer la maintenabilité et l'évolutivité des applications Web.

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!