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. Lass uns eintauchen!

ERHALTEN

• Verwendung: app.Get(Pfad, Handler)

Ruft Daten ab, ohne etwas zu ändern.
Beispiel: Eine Liste von Elementen abrufen oder Benutzerdetails lesen.

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(Pfad, 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 prü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 dem Debuggen und gibt die Anfrage zurück.

Arbeiten mit req.Request und req.Response

Da 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. Das 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:

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

Antwort

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

• Send Text: .Send(data string) schreibt Klartext 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:

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

Middleware

Wir halten eine Reihe von Middlewares für Sie bereit, mit denen Sie Ihrer Go-Webanwendung 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.

Aufstellen
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

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

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

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

• AllowOrigin: 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

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

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

app.Use(middleware.CSRFMiddleware(func(token string) bool {
    return token == "your_valid_token"
}))

Und vergessen Sie nicht, Token zu generieren mit:

csrfToken := middleware.GenerateCSRFToken()

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

app.Use(middleware.LoggingMiddleware)

Jede Anfrage wird wie folgt protokolliert:

• Gestartet: Protokolliert die Startzeit der Anfrage.
• 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 Anforderungsverarbeitung festlegen. Diese Middleware bricht die Anfrage ab, wenn sie nicht rechtzeitig abgeschlossen wird, und sendet einen 504-Gateway-Timeout-Status an den Client.

Beispiel

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

timeout := 2 * time.Second
app.Use(middleware.TimeoutMiddleware(timeout))

Die Plugin-Schnittstelle

Die Plugin-Schnittstelle ist super einfach, aber super leistungsstark. 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 Registermethode
Hier ist der magische Teil der Plugin-Schnittstelle:

type Plugin interface {
    Register(route func(method, path string, handler func(req *req.Request, res *req.Response)))
}

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.)
• path: 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:

package main

import (
    "github.com/BrunoCiccarino/GopherLight/plugins"
    "github.com/BrunoCiccarino/GopherLight/req"
)

type HelloPlugin struct{}

// Register adds a new route for the HelloPlugin.
func (p *HelloPlugin) Register(route func(method, path string, handler func(req *req.Request, res *req.Response))) {
    route("GET", "/hello-plugin", func(req *req.Request, res *req.Response) {
        res.Send("Hello from the HelloPlugin!")
    })
}

Hinzufügen des Plugins zu Ihrer App

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

package main

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

func main() {
    app := router.NewApp()
    helloPlugin := &HelloPlugin{}
    helloPlugin.Register(app.Route)

    app.Listen(":3333")
}

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.