Verwendung von CORS im Beego-Framework zur Lösung domänenübergreifender Probleme

Mit der Entwicklung von Webanwendungen und der Globalisierung des Internets müssen immer mehr Anwendungen domänenübergreifende Anfragen stellen. Domainübergreifende Anfragen sind ein häufiges Problem für Frontend-Entwickler und können dazu führen, dass Anwendungen nicht ordnungsgemäß funktionieren. In diesem Fall ist die Verwendung von CORS eine der besten Möglichkeiten, das Problem ursprungsübergreifender Anforderungen zu lösen.

In diesem Artikel konzentrieren wir uns auf die Verwendung von CORS zur Lösung domänenübergreifender Probleme im Beego-Framework.

Was ist eine domänenübergreifende Anfrage?

In Webanwendungen beziehen sich domänenübergreifende Anfragen auf das Senden von Anfragen von einer Webseite eines Domänennamens an einen Server eines anderen Domänennamens. Normalerweise befinden sich Anforderungs- und Antwortdaten in derselben Domäne, was bedeutet, dass sie dasselbe Protokoll, denselben Port und denselben Protokolltyp verwenden. Aus Sicherheitsgründen verbieten Browser jedoch in der Regel domänenübergreifende Anfragen.

Bei Projekten mit separatem Front-End und Back-End treten häufig Probleme mit domänenübergreifenden Anfragen auf. Wenn Sie beispielsweise eine Anwendung mit Vue im Front-End schreiben, müssen Sie möglicherweise eine Ajax-Anfrage an einen bestimmten Backend-Server senden, um Daten abzurufen. Wenn der Front-End-Server und der Back-End-Server nicht denselben Domänennamen haben, lehnt der Browser die Anfrage ab und zeigt eine Fehlermeldung an, selbst wenn die Anfrage auf Codeebene korrekt geschrieben ist. Hierbei handelt es sich um ein domänenübergreifendes Anforderungsproblem.

Was ist CORS?

CORS ist die Abkürzung für Cross-Origin Resource Sharing. Dabei handelt es sich um einen auf dem HTTP-Protokoll basierenden Mechanismus, der Webanwendungen den Zugriff auf domänenübergreifende Ressourcen ermöglicht. Die Entstehung des CORS-Mechanismus dient hauptsächlich der Lösung der oben genannten domänenübergreifenden Anforderungsprobleme.

Der CORS-Mechanismus wird vom Browser implementiert, der mithilfe zusätzlicher HTTP-Header dem Browser mitteilt, welche Quellen auf Cross-Origin-Ressourcen zugreifen dürfen. Bei der Anfrage überprüft der Browser die Antwort-Header-Informationen. Wenn das Feld „Access-Control-Allow-Origin“ in den Antwort-Header-Informationen vorhanden ist und der Wert dieses Felds mit dem angeforderten Domänennamen und der Portnummer übereinstimmt, lässt der Browser die Querverbindung zu. Domain-Anfrage.

Verwendung von CORS in Beego

In Beego können wir die beego-cors-Bibliothek verwenden, um den CORS-Mechanismus zu implementieren. So installieren Sie die beego-cors-Bibliothek:

go get github.com/astaxie/beego/plugins/cors

Nach der Installation müssen wir die beego-cors-Bibliothek in die Anwendung importieren.

import "github.com/astaxie/beego/plugins/cors"

CORS im Router konfigurieren

Als nächstes stellen wir vor, wie man CORS mit Beego verwendet. Wenn es sich bei Ihrer Anwendung um ein neues Projekt handelt, können Sie es beim Initialisieren der Anwendung wie folgt festlegen:

package main

import (
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/plugins/cors"
)

func main() {
    beego.BConfig.Listen.HTTPAddr = "0.0.0.0"
    beego.BConfig.Listen.HTTPPort = 8080

    beego.InsertFilter("*", beego.BeforeRouter, cors.Allow(&cors.Options{
        AllowOrigins: []string{"*"},
        AllowMethods: []string{"PUT", "PATCH", "GET", "POST", "DELETE", "OPTIONS"},
        AllowHeaders: []string{"Origin", "Content-Type", "Authorization"},
        ExposeHeaders: []string{"Content-Length", "Access-Control-Allow-Origin"},
        AllowCredentials: true,
    }))

    beego.Run()
}

Im obigen Code haben wir mithilfe der InsertFilter-Methode einen Filter namens cors hinzugefügt. Dieser Filter funktioniert bei allen Anfragen, daher verwenden wir den Platzhalter *, um den Router anzugeben.

In der Allow-Methode konfigurieren wir die Quellen, Methoden und Header, die zugelassen werden sollen. Hier verwenden wir *, um alle Ursprünge zuzulassen. Natürlich können Sie auch bestimmte Domänennamen oder IP-Adressen verwenden, um die zulässigen Quellen einzuschränken. Inhaltstyp, Autorisierung und Quellheader werden ebenfalls entsprechend der tatsächlichen Situation festgelegt.

Im Feld AllowCredentials setzen wir es auf true, was bedeutet, dass domänenübergreifende Anfragen das Senden von Anmeldeinformationen wie Cookies erlauben dürfen.

CORS im Controller konfigurieren

Zusätzlich zur Konfiguration von CORS im Router können wir CORS auch im Controller konfigurieren. Diese Methode kann für jeden Controller konfiguriert werden und bietet eine höhere Flexibilität. Die Details lauten wie folgt:

package controllers

import (
    "github.com/astaxie/beego"
    "github.com/astaxie/beego/plugins/cors"
)

type TestController struct {
    beego.Controller
}

func (c *TestController) Get() {
    origin := c.Ctx.Request.Header.Get("Origin")
    c.Ctx.Output.Header("Access-Control-Allow-Origin", origin)
    c.Ctx.Output.Header("Access-Control-Allow-Credentials", "true")
    c.Ctx.Output.Header("Access-Control-Allow-Methods", "POST, GET, PUT, DELETE, OPTIONS")
    c.Ctx.Output.Header("Access-Control-Allow-Headers", "Content-Type,Authorization")
    c.Ctx.Output.Header("Content-Type", "application/json; charset=utf-8")

    c.Ctx.Output.Body([]byte("Hello, world!"))
}

Im obigen Code rufen wir zuerst das Origin-Feld des Anforderungsheaders ab und legen es dann als Access-Control-Allow-Origin-Antwortheader fest. Dies ist ein wichtiger Schritt im CORS-Mechanismus, da er dem Browser mitteilt, welchen Quellen wir den Zugriff auf Ressourcen erlauben.

Wir legen außerdem die Antwortheader „Access-Control-Allow-Credentials“, „Access-Control-Allow-Methods“ und „Access-Control-Allow-Headers“ fest. Ihre Funktion besteht darin, das Senden von Anmeldeinformationen, zulässigen Anforderungsmethoden und zulässigen Anforderungsheaderfeldern zu ermöglichen.

Schließlich verwenden wir die Methode Output.Body, um die Antwortdaten an den Client zu senden.

Zusammenfassung

In diesem Artikel haben wir vorgestellt, was domänenübergreifende Anfragen sind, den CORS-Mechanismus und wie man CORS zur Lösung domänenübergreifender Probleme im Beego-Framework verwendet. Bei Projekten mit separatem Front-End und Back-End sind domänenübergreifende Anfragen ein häufiges Problem. Dieses Problem lässt sich gut mit dem CORS-Mechanismus lösen. Der CORS-Mechanismus kann mithilfe der beego-cors-Bibliothek einfach in Beego implementiert werden. Ich hoffe, dieser Artikel ist hilfreich für Sie.

Das obige ist der detaillierte Inhalt vonVerwendung von CORS im Beego-Framework zur Lösung domänenübergreifender Probleme. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!