So empfangen Sie über die POST-Methode gesendete Cross-Origin-Anfragen mit Node.js

Mit der rasanten Entwicklung der Front-End-Technologie ist auch die Webentwicklung komplex und veränderlich geworden. Insbesondere wenn wir Daten von verschiedenen Domänennamen anfordern müssen, treten domänenübergreifende Probleme auf. In diesem Artikel wird erläutert, wie Sie mit Node.js domänenübergreifende Anforderungen empfangen, die über die POST-Methode gesendet werden.

Zuallererst wird das domänenübergreifende Problem durch die Same-Origin-Richtlinie des Browsers verursacht. Die Same-Origin-Richtlinie bedeutet, dass Skripte mit unterschiedlichen Domänennamen, unterschiedlichen Protokollen und unterschiedlichen Ports keine Daten voneinander erhalten können. Das bedeutet, dass ein Fehler gemeldet wird, wenn unsere Seite Daten von anderen Domainnamen abrufen muss. Um dieses Problem zu lösen, müssen wir Mittel einsetzen, um die Same-Origin-Richtlinie zu umgehen.

Eine Möglichkeit, das domänenübergreifende Problem zu lösen, ist die Verwendung der CORS-Technologie (Cross-Origin Resource Sharing). Mit CORS können wir in der Antwort explizit angeben, welche Domänennamen über Ajax auf unsere Ressourcen zugreifen können. Wenn unser API-Server CORS jedoch nicht implementiert oder wir die Konfiguration auf dem Server nicht ändern können, müssen wir andere Methoden ausprobieren, um das Problem zu lösen.

Eine gängige Methode ist die Verwendung der JSONP-Technologie. JSONP erstellt dynamisch ein Skript-Tag auf der Seite und fordert dann über das Tag domänenübergreifende Daten an. Das src-Attribut dieses Tags verweist auf eine JavaScript-Datei auf dem API-Server, die JSON-Daten zurückgibt. JSONP löst das domänenübergreifende Problem, kann jedoch nur GET-Anfragen senden, keine POST-Anfragen.

Wir brauchen also eine andere Möglichkeit, domänenübergreifende POST-Anfragen zu implementieren. Hier ist ein Beispiel für die Verwendung von Node.js zum Implementieren einer domänenübergreifenden POST-Anfrage:

Zunächst müssen wir das http-Modul von Node.js verwenden, um einen Webserver zu erstellen und auf POST-Anfragen vom Client zu warten:

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.method === 'POST') {
    let body = '';
    req.on('data', data => {
      body += data;
    });
    req.on('end', () => {
      console.log(body);
      res.end();
    });
  }
});
server.listen(8080);

Dieser einfache Web-Server wartet auf POST-Anfragen vom Client an Port 8080 und gibt den Hauptteil der Anfrage an die Konsole aus.

Als nächstes müssen wir das XMLHttpRequest-Objekt auf der Clientseite verwenden, um die POST-Anfrage zu senden. Aufgrund domänenübergreifender Probleme können wir die Anfrage jedoch nicht direkt an den API-Server senden. Daher müssen wir zunächst einen Proxyserver auf der Clientseite erstellen und dann den Proxyserver die Anforderung weiterleiten lassen.

Der Code des Proxyservers lautet wie folgt:

const http = require('http');

const clientReq = http.request({
  method: 'POST',
  hostname: 'yourapi.com',
  path: '/path/to/api',
  headers: {
    'Content-Type': 'application/json'
  }
}, (res) => {
  res.on('data', (data) => { /* do something */ });
});

clientReq.on('error', (error) => { /* handle error */ });

process.stdin.on('data', (chunk) => {
  clientReq.write(chunk);
});

process.stdin.on('end', () => {
  clientReq.end();
});

Dieser Proxyserver leitet die von der Standardeingabe gelesene Anforderung an den API-Server weiter.

Schließlich müssen wir domänenübergreifende POST-Anfragen implementieren, indem wir den Proxyserver auf dem Client starten und dann die POST-Anfrage an den Proxyserver senden. Der Beispielcode lautet wie folgt:

const http = require('http');
const querystring = require('querystring');

const postData = querystring.stringify({
  'msg': 'Hello World!'
});

const options = {
  hostname: 'localhost',
  port: 8080,
  path: '/proxy',
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const req = http.request(options, (res) => {
  res.setEncoding('utf8');
  res.on('data', (chunk) => {
    console.log(`BODY: ${chunk}`);
  });
  res.on('end', () => {
    console.log('No more data in response.')
  })
});

req.on('error', (e) => {
  console.error(`problem with request: ${e.message}`);
});

// 请求的数据
req.write(postData);
req.end();

Dieses Codefragment sendet eine POST-Anfrage an den Proxyserver und der Proxyserver leitet die Anfrage an den API-Server weiter. Die vom API-Server zurückgegebene Antwort wird vom Proxyserver an den Client zurückgeleitet.

Zusammenfassung: Domänenübergreifende Probleme sind ein wichtiges Problem in der Webentwicklung, und wir müssen einige technische Mittel ergreifen, um es zu lösen. In diesem Artikel stellen wir vor, wie Sie Node.js verwenden, um domänenübergreifende POST-Anfragen zu empfangen und einen Proxyserver zu verwenden, um die Same-Origin-Richtlinie zu umgehen. Ich hoffe, dieser Artikel ist hilfreich für Sie.

Das obige ist der detaillierte Inhalt vonSo empfangen Sie über die POST-Methode gesendete Cross-Origin-Anfragen mit Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!