So verwenden Sie CORS des Koa2-Frameworks, um domänenübergreifende Ajax-Anfragen abzuschließen

Dieses Mal zeige ich Ihnen, wie Sie das CORS des Koa2-Frameworks verwenden, um domänenübergreifende Ajax-Anfragen abzuschließen. Welche Vorsichtsmaßnahmen gibt es für die Verwendung des CORS des Koa2-Frameworks, um domänenübergreifende Ajax-Anfragen abzuschließen? Das Folgende ist ein praktischer Fall, schauen wir uns ihn gemeinsam an.

Es gibt viele Möglichkeiten, domänenübergreifende Ajax-Anfragen zu implementieren. Eine davon ist die Verwendung von CORS. Der Schlüssel zu dieser Methode besteht darin, sie auf der Serverseite zu konfigurieren.

In diesem Artikel wird nur die grundlegendste Konfiguration erläutert, die eine normale domänenübergreifende Ajax-Antwort durchführen kann (ich weiß nicht, wie man eine detaillierte Konfiguration durchführt).

CORS unterteilt Anfragen in einfache Anfragen und nicht einfache Anfragen. Man kann sich einfach vorstellen, dass einfache Anfragen Get- und Post-Anfragen ohne zusätzliche Anfrage-Header sind, und wenn es sich um eine Post-Anfrage handelt, Das Anforderungsformat kann nicht application/json sein (da ich kein tiefes Verständnis in diesem Bereich habe. Wenn ein Fehler auftritt, hoffe ich, dass jemand auf den Fehler hinweisen und Änderungen vorschlagen kann). Der Rest, Put- und Post-Anfragen, Anfragen mit Content-Type application/json und Anfragen mit benutzerdefinierten Anfrage-Headern sind nicht einfache Anfragen.

Die Konfiguration einer einfachen Anfrage ist sehr einfach. Wenn Sie nur die Antwort vervollständigen müssen, um das Ziel zu erreichen, müssen Sie nur den Access-Control-Allow-Origin im Antwortheader konfigurieren.

Wenn wir auf den Domänennamen http://127.0.0.1:3001 unter dem Domänennamen http://localhost:3000 zugreifen möchten. Sie können die folgende Konfiguration vornehmen:

app.use(async (ctx, next) => {
 ctx.set('Access-Control-Allow-Origin', 'http://localhost:3000');
 await next();
});

Dann verwenden Sie Ajax, um eine einfache Anfrage zu initiieren, z. B. eine Post-Anfrage, und Sie können problemlos die richtige Antwort vom Server erhalten.

Der experimentelle Code lautet wie folgt:

$.ajax({
  type: 'post',
  url: 'http://127.0.0.1:3001/async-post'
 }).done(data => {
  console.log(data);
})

Serverseitiger Code:

router.post('/async-post',async ctx => {
 ctx.body = {
 code: "1",
 msg: "succ"
 }
});

Dann können Sie die richtigen Antwortinformationen erhalten.

Wenn Sie sich zu diesem Zeitpunkt die Header-Informationen der Anfrage und Antwort ansehen, werden Sie feststellen, dass der Anfrage-Header einen zusätzlichen Ursprung hat (es gibt auch einen Verweis auf die URL-Adresse der Anfrage) und die Der Antwortheader verfügt über einen zusätzlichen Access-Control-Allow-Origin.

Sie können jetzt einfache Anfragen senden, aber Sie benötigen noch andere Konfigurationen, um nicht einfache Anfragen zu senden.

Wenn eine nicht einfache Anfrage zum ersten Mal gestellt wird, werden tatsächlich zwei Anfragen ausgegeben. Die erste ist eine Preflight-Anfrage. Die Anfragemethode dieser Anfrage Anfrage Ob sie erfolgreich ist oder nicht, bestimmt, ob auf diese Art von nicht einfacher Anfrage erfolgreich geantwortet werden kann.

Um diese Anfrage vom Typ OPTIONS auf dem Server abzugleichen, müssen Sie eine passende Middleware erstellen und eine Antwort geben, damit diese Vorprüfung erfolgreich sein kann.

app.use(async (ctx, next) => {
 if (ctx.method === 'OPTIONS') {
 ctx.body = '';
 }
 await next();
});

Auf diese Weise kann die OPTIONS-Anfrage weitergeleitet werden.

Wenn Sie den Anforderungsheader der Preflight-Anfrage überprüfen, werden Sie feststellen, dass es zwei weitere Anforderungsheader gibt.

Access-Control-Request-Method: PUT
Origin: http://localhost:3000

Verhandeln Sie mit dem Server über diese beiden Header-Informationen, um festzustellen, ob die Antwortbedingungen des Servers erfüllt sind.

Da der Anforderungsheader zwei weitere Informationen enthält, sollte der Antwortheader natürlich zwei entsprechende Informationen enthalten:

Access-Control-Allow-Origin: http://localhost:3000
Access-Control-Allow-Methods: PUT,DELETE,POST,GET

Die erste Information Gleich wie Herkunft und daher bestanden. Die zweite Information entspricht der Access-Controll-Request-Method. Wenn die Anfragemethode in der vom Server zugelassenen Antwortmethode enthalten ist, wird diese Information ebenfalls übergeben. Beide Einschränkungen sind erfüllt, sodass die Anfrage erfolgreich initiiert werden kann.

Bis zu diesem Zeitpunkt ist es gleichbedeutend damit, nur die Vorprüfung durchzuführen und nicht die eigentliche Anfrage zu senden.

Natürlich hat die eigentliche Anfrage auch erfolgreich eine Antwort erhalten, und der Antwortheader lautet wie folgt (ohne unwichtige Teile)

Access-Control-Allow-Origin: http://localhost:3000
Access-Control-Allow-Methods: PUT,DELETE,POST,GET

Der Anfrageheader lautet wie folgt:

Origin: http://localhost:3000

Dies ist der Fall. Offensichtlich werden die Antwort-Header-Informationen von uns auf dem Server festgelegt, daher ist dies der Fall.

Der Client muss den Access-Control-Request-Method-Anfrageheader nicht senden, da er gerade vorab überprüft wurde.

Der Code für dieses Beispiel lautet wie folgt:

$.ajax({
   type: 'put',
   url: 'http://127.0.0.1:3001/put'
  }).done(data => {
   console.log(data);
});

Servercode:

app.use(async (ctx, next) => {
  ctx.set('Access-Control-Allow-Origin', 'http://localhost:3000');
  ctx.set('Access-Control-Allow-Methods', 'PUT,DELETE,POST,GET');
  await next();
});

An diesem Punkt haben wir die Grundkonfiguration für die korrekte domänenübergreifende Nutzung abgeschlossen Ajax-Antwort und etwas, das weiter konfiguriert werden kann.

Beispielsweise werden bisher bei jeder nicht einfachen Anfrage tatsächlich zwei Anfragen ausgegeben, eine für den Preflight und eine für eine echte Anfrage, was zu einem Leistungsverlust führt. Um keine Preflight-Anfrage zu senden, können Sie die folgenden Antwortheader konfigurieren.

Access-Control-Max-Age: 86400

这个响应头的意义在于，设置一个相对时间，在该非简单请求在服务器端通过检验的那一刻起，当流逝的时间的毫秒数不足Access-Control-Max-Age时，就不需要再进行预检，可以直接发送一次请求。

当然，简单请求时没有预检的，因此这条代码对简单请求没有意义。

目前代码如下：

app.use(async (ctx, next) => {
 ctx.set('Access-Control-Allow-Origin', 'http://localhost:3000');
 ctx.set('Access-Control-Allow-Methods', 'PUT,DELETE,POST,GET');
 ctx.set('Access-Control-Max-Age', 3600 * 24);
 await next();
});

到现在为止，可以对跨域ajax请求进行响应了，但是该域下的cookie不会被携带在请求头中。如果想要带着cookie到服务器，并且允许服务器对cookie进一步设置，还需要进行进一步的配置。

为了便于后续的检测，我们预先在http://127.0.0.1:3001这个域名下设置两个cookie。注意不要错误把cookie设置成中文（刚才我就设置成了中文，结果报错，半天没找到出错原因）

然后我们要做两步，第一步设置响应头Access-Control-Allow-Credentials为true，然后在客户端设置xhr对象的withCredentials属性为true。

客户端代码如下：

$.ajax({
   type: 'put',
   url: 'http://127.0.0.1:3001/put',
   data: {
    name: '黄天浩',
    age: 20
   },
   xhrFields: {
    withCredentials: true
   }
  }).done(data => {
   console.log(data);
  });

服务端如下：

app.use(async (ctx, next) => {
  ctx.set('Access-Control-Allow-Origin', 'http://localhost:3000');
  ctx.set('Access-Control-Allow-Methods', 'PUT,DELETE,POST,GET');
  ctx.set('Access-Control-Allow-Credentials', true);
  await next();
});

这时就可以带着cookie到服务器了，并且服务器也可以对cookie进行改动。但是cookie仍是http://127.0.0.1:3001域名下的cookie，无论怎么操作都在该域名下，无法访问其他域名下的cookie。

现在为止CORS的基本功能已经都提到过了。

一开始我不知道怎么给Access-Control-Allow-Origin，后来经人提醒，发现可以写一个白名单数组，然后每次接到请求时判断origin是否在白名单数组中，然后动态的设置Access-Control-Allow-Origin，代码如下：

app.use(async (ctx, next) => {
 if (ctx.request.header.origin !== ctx.origin && whiteList.includes(ctx.request.header.origin)) {
  ctx.set('Access-Control-Allow-Origin', ctx.request.header.origin);
  ctx.set('Access-Control-Allow-Methods', 'PUT,DELETE,POST,GET');
  ctx.set('Access-Control-Allow-Credentials', true);
  ctx.set('Access-Control-Max-Age', 3600 * 24);
 }
 await next();
});

这样就可以不用*通配符也可匹配多个origin了。

注意：ctx.origin与ctx.request.header.origin不同，ctx.origin是本服务器的域名，ctx.request.header.origin是发送请求的请求头部的origin，二者不要混淆。

最后，我们再稍微调整一下自定义的中间件的结构，防止每次请求都返回Access-Control-Allow-Methods以及Access-Control-Max-Age，这两个响应头其实是没有必要每次都返回的，只是第一次有预检的时候返回就可以了。

调整后顺序如下：

app.use(async (ctx, next) => {
 if (ctx.request.header.origin !== ctx.origin && whiteList.includes(ctx.request.header.origin)) {
  ctx.set('Access-Control-Allow-Origin', ctx.request.header.origin);
  ctx.set('Access-Control-Allow-Credentials', true);
 }
 await next();
});
app.use(async (ctx, next) => {
 if (ctx.method === 'OPTIONS') {
  ctx.set('Access-Control-Allow-Methods', 'PUT,DELETE,POST,GET');
  ctx.set('Access-Control-Max-Age', 3600 * 24);
  ctx.body = '';
 }
 await next();
});

这样就减少了多余的响应头。

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

在Vue2.0中http请求以及loading的展示

process和child_process使用详解

Das obige ist der detaillierte Inhalt vonSo verwenden Sie CORS des Koa2-Frameworks, um domänenübergreifende Ajax-Anfragen abzuschließen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!