So schreiben Sie APIs wie ein Profi in Go mit GopherLight

Dokumente

GopherLIght

Hey Leute, zunächst möchte ich euch dafür danken, dass ihr euch für die Nutzung unseres Projekts entschieden habt. Auch wenn er noch klein ist, haben wir es mit großer Begeisterung gemacht! Um es verwenden zu können, muss go zunächst installiert sein. Gehen wir davon aus, dass Sie es bereits haben. Installieren Sie dann die Hauptmodule des Frameworks, nämlich req und router

go get github.com/BrunoCiccarino/GopherLight/router
go get github.com/BrunoCiccarino/GopherLight/req

Bereits heruntergeladen? Puh! Jetzt können wir unsere erste Hallo-Welt erschaffen.

package main

import (
    "fmt"
    "github.com/BrunoCiccarino/GopherLight/router"
    "github.com/BrunoCiccarino/GopherLight/req"
)


func main() {
    app := router.NewApp()

    // Define a route that responds to a GET request at "/hello".
    app.Get("/hello", func(r *req.Request, w *req.Response) {
        w.Send("Hello, World!")
    })

    fmt.Println("Server listening on port 3333")
    app.Listen(":3333")
}

Ganz einfach, oder? Und mit GopherLight können wir noch viel mehr tun. Lesen Sie weiter, um eine vollständige Aufschlüsselung der HTTP-Methoden und unserer Anfrage- und Antworttools zu erhalten.

Unterstützte HTTP-Methoden
Hier ist die Liste der HTTP-Methoden, die Sie mit router.App verwenden können. Mit jedem davon können Sie Routen einrichten, um verschiedene Arten von Anfragen zu bearbeiten. Lasst uns eintauchen!

ERHALTEN

• Verwendung: app.Get(Pfad, Handler)

Ruft Daten ab, ohne etwas zu ändern.
Beispiel: Abrufen einer Artikelliste oder Lesen von Benutzerdetails.

POST

• Verwendung: app.Post(Pfad, Handler)

Sendet Daten, um eine neue Ressource zu erstellen.
Beispiel: Senden eines Formulars oder Hinzufügen eines neuen Elements zu einer Liste.

SETZEN

Verwendung: app.Put(path, handler)

Aktualisiert oder ersetzt eine Ressource. Es handelt sich um eine „Überschreiben“-Aktion.
Beispiel: Aktualisieren eines vollständigen Benutzerprofils.

LÖSCHEN

Verwendung: app.Delete(path, handler)

Löscht eine Ressource.
Beispiel: Entfernen eines Benutzers oder Löschen eines Beitrags.

PATCH

Verwendung: app.Patch(path, handler)

Aktualisiert eine Ressource teilweise, ohne alles zu ersetzen.
Beispiel: Nur die E-Mail in einem Benutzerprofil aktualisieren.

OPTIONEN

Verwendung: app.Options(path, handler)

Gibt zulässige HTTP-Methoden für eine URL zurück, hauptsächlich für CORS-Preflight-Anfragen.

KOPF

Verwendung: app.Head(path, handler)

Wie GET, aber kein Antworttext. Verwenden Sie es, um zu überprüfen, ob eine Ressource vorhanden ist.

VERBINDEN und VERFOLGEN

Verwendung: app.Connect(path, handler), app.Trace(path, handler)

Erweiterte Methoden: CONNECT richtet einen Tunnel ein (für SSL) und TRACE dient zum Debuggen und gibt die Anfrage zurück.

Arbeiten mit req.Request und req.Response

Nachdem Sie nun die Routen gesehen haben, sprechen wir über die Request- und Response-Objekte, Ihre bevorzugten Helfer für die Bearbeitung eingehender Anfragen und das Senden von Antworten.

Anfrage

Jeder Anforderungshandler erhält ein Anforderungsobjekt, das mit Informationen zur eingehenden Anforderung geladen wird. Folgendes können Sie damit machen:

• Abfrageparameter: Abfrageparameter mit .QueryParam("key") abrufen.
• Header: Greifen Sie mit .Header("key") auf Header zu.
• Body as String: Erfassen Sie den Anfragetext mit .BodyAsString().

Beispiel:

go get github.com/BrunoCiccarino/GopherLight/router
go get github.com/BrunoCiccarino/GopherLight/req

Antwort

Das Response-Objekt hilft Ihnen, eine Antwort an den Client zurückzusenden. Folgendes können Sie tun:

• Text senden: .Send(Datenzeichenfolge) schreibt einfachen Text zurück.
• Status festlegen: .Status(code) legt den HTTP-Status fest.
• JSON senden: .JSON(data) serialisiert ein Go-Objekt in JSON und sendet es.
• Fehler behandeln: .JSONError(message) sendet eine JSON-formatierte Fehlerantwort.

Beispiel:

package main

import (
    "fmt"
    "github.com/BrunoCiccarino/GopherLight/router"
    "github.com/BrunoCiccarino/GopherLight/req"
)


func main() {
    app := router.NewApp()

    // Define a route that responds to a GET request at "/hello".
    app.Get("/hello", func(r *req.Request, w *req.Response) {
        w.Send("Hello, World!")
    })

    fmt.Println("Server listening on port 3333")
    app.Listen(":3333")
}

Middleware

Wir halten eine Reihe von Middlewares für Sie bereit, mit denen Sie Ihrer Go-Web-App einige wichtige Funktionen hinzufügen können. Jede dieser Middlewares bringt ihre eigene Magie mit sich – Sicherheit, Protokollierung, Zeitüberschreitungen und mehr! Lassen Sie uns sie einzeln aufschlüsseln. ?

Authentifizierungs-Middleware (JWT)

Unsere AuthMiddleware hilft, Ihre Routen mit JSON Web Tokens (JWT) zu schützen. Es ist flexibel und ermöglicht Ihnen die individuelle Anpassung des geheimen Schlüssels, der Fehlerbehandlung und der Token-Extraktionsmethode.

Einrichtung
Konfigurieren Sie zunächst Ihre JWT-Einstellungen mit JWTConfig:

• SecretKey: Der geheime Schlüssel zum Signieren von JWTs.
• SigningMethod: Der JWT-Signaturalgorithmus.
• ErrorHandler: Benutzerdefinierter Fehlerhandler zur Behandlung von Authentifizierungsfehlern (optional).
• TokenExtractor: Extrahiert das Token aus dem Anforderungsheader (optional).

Beispiel

app.Get("/greet", func(r *req.Request, w *req.Response) {
    name := r.QueryParam("name")
    if name == "" {
        name = "stranger"
    }
    w.Send("Hello, " + name + "!")
})

CORS-Middleware

Müssen Cross-Origin-Anfragen zugelassen werden? Kein Problem! Unsere CORSMiddleware konfiguriert die Cross-Origin Resource Sharing (CORS)-Einstellungen, um Ihre API von anderen Domänen aus zugänglich zu machen.

Konfigurationsoptionen

• Ursprung zulassen: Auf „*“ setzen, um einen beliebigen Ursprung zuzulassen oder eine Domäne anzugeben (z. B. „http://example.com“).
• AllowMethods: Welche HTTP-Methoden sind erlaubt? Zu den gängigen Optionen gehören „GET“, „POST“ usw.
• AllowHeaders: Geben Sie an, welche Header Clients verwenden können.
• AllowCredentials: Auf „true“ setzen, wenn Cookies oder HTTP-Authentifizierung einbezogen werden sollen.
• ExposeHeaders: Lassen Sie den Client bestimmte Header aus der Antwort lesen.
• MaxAge: Cache-Zeit (in Sekunden) für Preflight-Anfragen.

Beispiel

app.Get("/user", func(r *req.Request, w *req.Response) {
    user := map[string]string{"name": "Gopher", "language": "Go"}
    w.JSON(user)
})

CSRF-Middleware

Unsere CSRFMiddleware schützt vor Cross-Site Request Forgery, indem sie ein CSRF-Token validiert, das mit jeder Anfrage gesendet wird. Verwenden Sie GenerateCSRFToken(), um ein sicheres Token zu erstellen, und validieren Sie es dann mit Ihrer eigenen isValidToken-Funktion.

Beispiel

import (
    "github.com/BrunoCiccarino/GopherLight/middleware"
)

config := middleware.JWTConfig{
    SecretKey: []byte("your_secret_key"),
}
app.Use(middleware.NewAuthMiddleware(config))

Und vergessen Sie nicht, Token zu generieren mit:

go get github.com/BrunoCiccarino/GopherLight/router
go get github.com/BrunoCiccarino/GopherLight/req

Protokollierungs-Middleware

Möchten Sie den Überblick behalten, was auf Ihrem Server passiert? LoggingMiddleware protokolliert jede Anfrage, einschließlich der Methode, des Pfads und der benötigten Zeit. Dies ist eine großartige Möglichkeit, über die App-Leistung und ungewöhnliche Aktivitäten auf dem Laufenden zu bleiben.

Beispiel

package main

import (
    "fmt"
    "github.com/BrunoCiccarino/GopherLight/router"
    "github.com/BrunoCiccarino/GopherLight/req"
)


func main() {
    app := router.NewApp()

    // Define a route that responds to a GET request at "/hello".
    app.Get("/hello", func(r *req.Request, w *req.Response) {
        w.Send("Hello, World!")
    })

    fmt.Println("Server listening on port 3333")
    app.Listen(":3333")
}

Jede Anfrage wird wie folgt protokolliert:

• Gestartet: Protokolliert die Startzeit der Anforderung.
• Abgeschlossen: Protokolliert, wann die Anfrage abgeschlossen ist, einschließlich der Dauer.

Timeout-Middleware

Vermeiden Sie diese endlosen Wartezeiten, indem Sie mit TimeoutMiddleware Zeitlimits für die Anfrageverarbeitung festlegen. Diese Middleware bricht die Anfrage ab, wenn sie nicht rechtzeitig abgeschlossen wird, und sendet einen 504-Gateway-Timeout-Status an den Client.

Beispiel

app.Get("/greet", func(r *req.Request, w *req.Response) {
    name := r.QueryParam("name")
    if name == "" {
        name = "stranger"
    }
    w.Send("Hello, " + name + "!")
})

Die Plugin-Schnittstelle

Die Plugin-Oberfläche ist supereinfach, aber superleistungsstark. Es gibt Ihnen eine einzige Methode: Registrieren. Dadurch können Sie sich in das Routing-System der App einklinken, um alle benötigten Routen hinzuzufügen – sei es ein neuer API-Endpunkt, ein Webhook oder alles andere, was Sie sich vorstellen können.

Die Registrierungsmethode
Hier ist der magische Teil der Plugin-Schnittstelle:

app.Get("/user", func(r *req.Request, w *req.Response) {
    user := map[string]string{"name": "Gopher", "language": "Go"}
    w.JSON(user)
})

Die Register-Methode akzeptiert eine Routenfunktion, mit der Sie neue Routen in Ihrem Plugin definieren können, indem Sie Folgendes angeben:

• Methode: HTTP-Methode (z. B. „GET“, „POST“ usw.)
• Pfad: Der Routenpfad (z. B. „/my-plugin-route“)
• Handler: Die Funktion, die ausgeführt werden soll, wenn die Route erreicht wird. Diese Funktion empfängt:
  • req: Das Anforderungsobjekt mit Zugriff auf Abfrageparameter, Header und Text.
  • res: Das Antwortobjekt zum Zurücksenden von Daten an den Client.

Beispiel-Plugin

Angenommen, Sie möchten ein Plugin erstellen, das einen einfachen Endpunkt unter /hello-plugin hinzufügt, um Benutzer zu begrüßen. So würde das Plugin aussehen:

import (
    "github.com/BrunoCiccarino/GopherLight/middleware"
)

config := middleware.JWTConfig{
    SecretKey: []byte("your_secret_key"),
}
app.Use(middleware.NewAuthMiddleware(config))

Hinzufügen des Plugins zu Ihrer App

Um ein Plugin zu laden, erstellen Sie einfach eine Instanz und rufen Sie Registrieren in Ihrem Haupt-App-Setup auf:

corsOptions := middleware.CORSOptions{
    AllowOrigin: "*",
    AllowMethods: []string{"GET", "POST"},
}
app.Use(middleware.CORSMiddleware(corsOptions))

Anpassen Ihrer Plugins

Jedes Plugin kann so viele Routen wie nötig hinzufügen. Rufen Sie route einfach mehrmals in Ihrer Register-Funktion auf, um zusätzliche Endpunkte zu definieren. Verwenden Sie verschiedene HTTP-Methoden, Pfade und Handler, um die Funktionalität Ihres Plugins nach Ihren Wünschen zu gestalten.

Das obige ist der detaillierte Inhalt vonSo schreiben Sie APIs wie ein Profi in Go mit GopherLight. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!