Verwenden Sie das Gin-Framework, um Such- und Filterfunktionen zu implementieren

WBOY
Freigeben: 2023-06-22 17:16:37
Original
1642 Leute haben es durchsucht

Gin ist ein leichtes, skalierbares Web-Framework, das aufgrund der Geschwindigkeit und Leistung der Go-Sprache sowie ihrer unübertroffenen Parallelität und Wartbarkeit immer beliebter wird. In diesem Artikel erfahren Sie, wie Sie das Gin-Framework verwenden, um Such- und Filterfunktionen zu implementieren.

Zuerst müssen wir eine grundlegende Gin-Anwendung einrichten. Dazu müssen wir die erforderlichen Abhängigkeiten in der Datei go.mod hinzufügen und installieren. Hier verwenden wir das Gin-Framework und die ORM-Bibliothek GORM von Go. Wir werden MySQL als unsere relationale Datenbank verwenden.

Unsere go.mod-Datei sollte so aussehen:

module github.com/mygithubaccount/myginapp

require (
    github.com/gin-gonic/gin v1.7.2
    gorm.io/driver/mysql v1.2.1
    gorm.io/gorm v1.21.9
)
Nach dem Login kopieren

Für die Datenbankverbindung verwenden wir den folgenden Formatstil:

username:password@tcp(hostname:port)/database_name?charset=utf8mb4&parseTime=True&loc=Local
Nach dem Login kopieren

Als nächstes müssen wir Gin und Net/http aus dem Gin-Paket importieren.

import (
    "net/http"

    "github.com/gin-gonic/gin"
)
Nach dem Login kopieren

In unserer Hauptfunktion müssen wir eine Verbindung zur Datenbank herstellen und eine Variable namens db erstellen und gleichzeitig Gins Standard-Middleware aktivieren.

func main() {
    dsn := "username:password@tcp(hostname:port)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    
    if err != nil {
        panic("failed to connect to database")
    }

    r := gin.Default()
    r.Use(cors.Default())

    // Routes
    r.GET("/healthcheck", healthCheckHandler)

    // Port binding
    port := os.Getenv("PORT")

    if port == "" {
        port = "8080"
    }

    r.Run(":" + port)
}
Nach dem Login kopieren

Das ist unser Grundsetup. Betrachten wir nun die Implementierung von Such- und Filterfunktionen.

Wir werden Such- und Filterfunktionen für das folgende Datenmodell implementieren.

type User struct {
    ID        uint   `json:"id" gorm:"primarykey"`
    FirstName string `json:"firstName"`
    LastName  string `json:"lastName"`
    Age       int    `json:"age"`
    Gender    string `json:"gender"`
    Email     string `json:"email" gorm:"uniqueIndex"`
}
Nach dem Login kopieren

Wir werden den folgenden Anfragehandler definieren, um unsere POST-Anfragen zu bearbeiten.

func searchUsersHandler(c *gin.Context) {
    var filter User
    var users []User

    if err := c.ShouldBindJSON(&filter); err != nil {
        c.AbortWithStatus(http.StatusBadRequest)
        return
    }

    db.Where(&filter).Find(&users)
    c.JSON(http.StatusOK, users)
}
Nach dem Login kopieren

Mit diesem Handler können wir die Parameter der POST-Anfrage an die Benutzerstruktur übergeben und eine Abfrage in der Datenbanktabelle ausführen. Wir können Abfragen auch auf andere Weise bearbeiten:

  • LIKE
  • IN
  • NOT
  • OR

Hier werden wir Laufzeitabfragen in der Anwendung durchführen. Dies ist für kleine Anwendungen in Ordnung, kann jedoch bei größeren Anwendungen zu einer übermäßigen Serverlast führen. Ein besserer Ansatz wäre, die Suchabfrage in das Front-End zu verschieben und die Browserressourcen des Clients zum Suchen/Filtern zu nutzen.

Jetzt müssen wir die Anfrage und den Handler miteinander verknüpfen. Dies kann über Gin-Routing erfolgen.

r.POST("/search", searchUsersHandler)
Nach dem Login kopieren

Über diesen Weg können wir eine POST-Anfrage stellen und eine Benutzerstruktur an die Anwendung senden, die zum Abfragen von Benutzerdatensätzen verwendet wird.

So implementieren Sie Such- und Filterfunktionen mithilfe des Gin-Frameworks. Zusammenfassend haben wir in diesem Artikel gelernt, wie man eine Verbindung zur Datenbank herstellt, Gins Standard-Middleware verwendet, das Datenmodell definiert, Anforderungshandler schreibt und Routen an Handler bindet. Mit der Anwendung können nun grundlegende Vorgänge zum Suchen und Filtern von Datensätzen in einer relationalen Datenbank ausgeführt werden.

Das obige ist der detaillierte Inhalt vonVerwenden Sie das Gin-Framework, um Such- und Filterfunktionen zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage