nodejs legt den domänenübergreifenden Dienst-Proxy fest

Mit der rasanten Entwicklung der Internettechnologie werden die Möglichkeiten der Datenübertragung immer vielfältiger. Allerdings stellt die domänenübergreifende Datenübertragung aufgrund diverser Sicherheitseinschränkungen ein Problem dar. In diesem Artikel wird erläutert, wie Sie mit Node.js einen domänenübergreifenden Dienst-Proxy einrichten.

1. Was ist domänenübergreifend?

Domänenübergreifend bedeutet, dass der Browser die Same-Origin-Richtlinie einhält und feststellt, dass es sich bei der Anfrage um eine domänenübergreifende Anfrage handelt und blockiert diese Nicht-Domain-Anfrage. Daher schlagen ursprungsübergreifende Anfragen aufgrund von Sicherheitsrichtlinien häufig fehl.

2. Warum ist eine domänenübergreifende Anforderung erforderlich?

Die Entstehung domänenübergreifender Anforderungen dient hauptsächlich dazu, die Dateninteraktion zwischen verschiedenen Websites zu erleichtern. Wenn wir beispielsweise auf eine Webanwendung zugreifen, müssen wir möglicherweise Daten von verschiedenen Websites abrufen. In diesem Fall sind domänenübergreifende Anfragen erforderlich.

3. Domänenübergreifende Lösung

1. JSONP (JSON mit Padding) zur Erzielung einer domänenübergreifenden Lösung

JSONP ist eine domänenübergreifende Standardlösung, die dynamisch Skript-Tags erstellt und Daten in Rückruffunktionen einschließt.

2. CORS (Cross-Origin Resource Sharing) realisiert die domänenübergreifende

CORS-Spezifikation ist ein vom W3C entwickelter Standard für die domänenübergreifende gemeinsame Nutzung von Ressourcen. Sie löst domänenübergreifende Probleme durch Festlegen der Access-Control-Allow-Origin-Antwort Header auf der Serverfrage. CORS wird jedoch nur in erweiterten Browsern unterstützt und wird von Browsern niedrigerer Versionen nicht unterstützt.

4. Verwenden Sie Node.js, um einen domänenübergreifenden Service-Proxy zu implementieren.

Der domänenübergreifende Service-Proxy bezieht sich auf die Möglichkeit, domänenübergreifende Anforderungen zu implementieren, indem Anforderungen mit demselben Ursprung an den Server gesendet werden und der Server-Proxy dann Daten anfordert vom Zielserver. Im Folgenden finden Sie Beispielcode für die Verwendung von Node.js zur domänenübergreifenden Implementierung eines Service-Proxys.

//导入所需的模块
const http = require('http');
const https = require('https');
const url = require('url');
const querystring = require('querystring');

//创建HTTP服务器
http.createServer(function(req,res) {
  //获取请求URL
  let aimUrl = req.url;

  //解析请求地址
  let urlObj = url.parse(aimUrl,true);

  //获取目标地址
  let targetUrl = urlObj.query.url;

  //解析参数
  let paramsObj = urlObj.query;

  //删除URL中的url参数
  delete paramsObj.url;

  //将JSON格式的querystring参数转化为querystring
  let params = querystring.stringify(paramsObj);

  //设置目标URL
  let options = {
    protocol: url.parse(targetUrl).protocol,
    hostname: url.parse(targetUrl).hostname,
    port: url.parse(targetUrl).port,
    path: url.parse(targetUrl).pathname + '?' + params,
    method: 'GET',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded'
    }
  };

  //发起请求
  let request = https.request(options, function(response) {
    //设置响应数据类型
    res.writeHead(response.statusCode, {'Content-Type': 'application/json'});

    //监听data事件
    response.on('data', function(chunk) {
      res.write(chunk);
    });

    //监听end事件
    response.on('end', function() {
      res.end();
    });
  });

  //设置请求超时时间
  request.setTimeout(3000, function() {
    res.writeHead(500, {'Content-Type': 'application/json'});
    res.write(JSON.stringify({error: 'timeout'}));
    res.end()
  });

  //监听错误事件
  request.on('error', function(error) {
    res.writeHead(500, {'Content-Type': 'application/json'});
    res.write(JSON.stringify({error: error}));
    res.end();
  });

  //设置请求方式
  request.method = req.method;

  //发起请求
  if (req.method == 'POST' || req.method == 'PUT') {
    req.on('data', (data) => {
      request.write(data);
    });
    req.on('end', () => {
      request.end();
    });
  } else {
    request.end();
  }
}).listen(8080, 'localhost');

5. Zusammenfassung

In diesem Artikel werden das Prinzip domänenübergreifender Anforderungen und zwei gängige domänenübergreifende Lösungen (JSONP und CORS) vorgestellt. Gleichzeitig wird Node.js verwendet, um den domänenübergreifenden Service-Proxy zu implementieren und zu verarbeiten Daten über den Server. Die Anforderungsmethode löst das Problem domänenübergreifender Anforderungen. Die serverseitige Cross-Request ist eine sichere und stabile Methode, die domänenübergreifende Requests sicherer und für verschiedene komplexe Szenarien geeignet machen kann.

Das obige ist der detaillierte Inhalt vonnodejs legt den domänenübergreifenden Dienst-Proxy fest. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!