Golang-Anwendung: Der Header „Access-Control-Allow-Origin' ist auf der angeforderten Ressource nicht vorhanden

Frageninhalt

Immer wenn ich versuche, eine HTTP-Anfrage von einer Angular-Anwendung an einen Go-Server zu senden, erhalte ich die folgende Antwort:

Antwort auf Preflight-Anfrage fehlgeschlagene Zugriffskontrollprüfung: Der Header „Access-Control-Allow-Origin“ ist auf der angeforderten Ressource nicht vorhanden.

Ich habe die in der Fehlerantwort aufgeführten Header hinzugefügt, aber der Fehler bleibt bestehen.

server.go

package rest

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "sync"
    "syscall"

    "github.com/gorilla/mux"
    "github.com/randyVerduguez/randy-verduguez_06122023-BE-challenge/configs"
    "github.com/randyVerduguez/randy-verduguez_06122023-BE-challenge/http/rest/handlers"
    "github.com/randyVerduguez/randy-verduguez_06122023-BE-challenge/pkg/db"
    "github.com/rs/cors"
    "github.com/sirupsen/logrus"
)

type Server struct {
    logger *logrus.Logger
    router *mux.Router
    config configs.Config
}

func NewServer() (*Server, error) {
    config, err := configs.NewParsedConfig()

    if err != nil {
        return nil, err
    }

    database, err := db.Connect(db.ConfigDB{
        Host:     config.Database.Host,
        Port:     config.Database.Port,
        User:     config.Database.User,
        Password: config.Database.Password,
        Name:     config.Database.Name,
    })

    if err != nil {
        return nil, err
    }

    log, err := NewLogger()

    if err != nil {
        return nil, err
    }

    router := mux.NewRouter()

    handlers.Register(router, log, database)

    server := Server{
        logger: log,
        config: config,
        router: router,
    }

    return &server, nil
}

func (s *Server) Run(ctx context.Context) error {
    cors := cors.New(cors.Options{
        AllowedMethods: []string{"GET, POST"},
        AllowedOrigins: []string{"http://localhost:4200"},
        AllowedHeaders: []string{"Content-Type", "Accept"},
    })

    server := http.Server{
        Addr:    fmt.Sprintf(":%d", s.config.ServerPort),
        Handler: cors.Handler(s.router),
    }

    stopServer := make(chan os.Signal, 1)

    signal.Notify(stopServer, syscall.SIGINT, syscall.SIGTERM)

    defer signal.Stop(stopServer)

    serverErrors := make(chan error, 1)

    var wg sync.WaitGroup
    wg.Add(1)

    go func(wg *sync.WaitGroup) {
        defer wg.Done()
        s.logger.Printf("REST API listening on  %d", s.config.ServerPort)
        serverErrors <- server.ListenAndServe()
    }(&wg)

    select {
    case err := <-serverErrors:
        return fmt.Errorf("error: starting REST API server %w", err)
    case <-stopServer:
        s.logger.Warn("server recieved STOP signal")

        err := server.Shutdown(ctx)

        if err != nil {
            return fmt.Errorf("graceful shutdown did not complete: %w", err)
        }

        wg.Wait()
        s.logger.Info("server was shutdown gracefully")
    }

    return nil
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Access-Control-Allow-Origin", "http://localhost:4200")
    w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
    w.Header().Set("Access-Control-Allow-Credentials", "true")
    w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, Accept, origin, Cache-Control, X-Requested-With")

    if r.Method == "OPTIONS" {
        return
    }

    s.router.ServeHTTP(w, r)
}

route.go

package handlers

import (
    "net/http"

    "github.com/gorilla/mux"
    "github.com/jmoiron/sqlx"
    "github.com/sirupsen/logrus"
)

func Register(r *mux.Router, lg *logrus.Logger, db *sqlx.DB) {
    handler := newHandler(lg, db)

    r.Use(handler.MiddlewareLogger())
    r.HandleFunc("/weather/current", handler.GetCurrentWeather()).Methods(http.MethodPost)
    r.HandleFunc("/weather/welcome", handler.Test()).Methods(http.MethodGet)
}

Richtige Antwort

Die erste Frage, die mir auffiel, war:

AllowedMethods: []string{"GET, POST"},

Das sollte sein:

AllowedMethods: []string{"GET", "POST"}, (或者稍微不易出错的 []string{http.MethodGet, http.MethodPost})

Laut Dokumentation ist dies der Standardwert (Sie können ihn also weglassen):

Meine nächste Frage ist „Was ist der Ursprung“; CORS ist „Cross-Origin Resource Sharing“ und zielt darauf ab, „Client-Webanwendungen, die von einem Ursprung ausgeführt werden, daran zu hindern, Daten von einem anderen Ursprung abzurufen“, also verstehen Sie den Ursprung des Es ist sehr wichtig, auf welcher Seite die Anfrage gestellt wird. Sie erlauben http://localhost:4200 (AllowedOrigins: []string{"http://localhost:4200"}) 所以我假设您有两个服务器在本地主机上运行（但如果这不是案件）。如果您希望允许所有来源，请使用 "*"; Zum Testen verwende ich test-cors.org – gehen Sie einfach auf die Website, geben Sie die URL ein, zum Beispiel „http://127.0.0.1:8080/weather/welcome“, geben Sie „Remote-URL“ ein „“ und klicken Sie zum Testen auf „Anfrage senden“.

Ihr Code ist etwas verwirrend (z. B. (s *Server) ServeHTTP nicht verwendet – bitte versuchen Sie, minimale, reproduzierbare Beispiele bereitzustellen, wenn Sie hier fragen), daher habe ich die Dinge ein wenig vereinfacht und hoffe, dass Ihnen das Folgende die richtige Richtung zeigt.

package main

import (
    "context"
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
    "github.com/rs/cors"
)

func main() {
    s, err := NewServer()
    if err != nil {
        panic(err)
    }
    s.Run(context.Background())
}

type Server struct {
    router *mux.Router
}

func NewServer() (*Server, error) {
    router := mux.NewRouter()
    Register(router)
    server := Server{
        router: router,
    }
    return &server, nil
}

func (s *Server) Run(ctx context.Context) {
    cors := cors.New(cors.Options{
        AllowedMethods: []string{http.MethodGet, http.MethodPost},
        AllowedOrigins: []string{"https://www.php.cn/link/9113c52c5f26af1782e6bf7c56973ef4"},
        // AllowedOrigins: []string{"*"},
        AllowedHeaders: []string{"Content-Type", "Accept"},
    })

    server := http.Server{
        Addr:    fmt.Sprintf(":%d", 8080),
        Handler: cors.Handler(s.router),
    }

    fmt.Println(server.ListenAndServe())
}

type handler struct{}

func Register(r *mux.Router) {
    handler := handler{}

    r.HandleFunc("/", handler.Index).Methods(http.MethodGet)
    r.HandleFunc("/weather/welcome", handler.Test).Methods(http.MethodGet)
}

// Index - Provide a simple page with a link to the other page to simplify testing
func (h *handler) Index(w http.ResponseWriter, _ *http.Request) {
    w.Write([]byte(`<a href="weather/welcome" >Test Link</a>`))
}

// The real page
func (h *handler) Test(w http.ResponseWriter, _ *http.Request) {
    fmt.Println("Test Called")
    w.Write([]byte("all OK"))
}

Das obige ist der detaillierte Inhalt vonGolang-Anwendung: Der Header „Access-Control-Allow-Origin' ist auf der angeforderten Ressource nicht vorhanden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!