Warum habe ich mich für das Framework „golly“ entschieden, um meine nächste Golang-basierte REST-API zu erstellen?

Warum Go (Golang) für die serverseitige Entwicklung wählen?

Die Wahl von Go (Golang) für die serverseitige Entwicklung wird oft durch seine Hauptstärken bestimmt:

• Leistung: Das auf Goroutinen und Kanälen basierende Parallelitätsmodell von Go ermöglicht die effiziente Bearbeitung mehrerer Aufgaben gleichzeitig und ist somit ideal für leistungsstarke Serveranwendungen.

• Einfachheit: Die Sprache ist so gestaltet, dass sie einfach und leicht lesbar ist, mit minimalistischer Syntax. Dies erleichtert die Wartung auch bei großen Projekten.

• Schnelle Kompilierung und Ausführung: Go kompiliert direkt in Maschinencode, was im Vergleich zu interpretierten Sprachen wie Python oder Node.js zu schnellen Ausführungszeiten führt.

• Skalierbarkeit: Gos integrierte Parallelität und Leichtgewichtigkeit machen es zu einer guten Wahl für den Aufbau skalierbarer Dienste, die eine große Anzahl von Anfragen verarbeiten können.

• Starke Standardbibliothek: Go verfügt über eine leistungsstarke Standardbibliothek, insbesondere für den Aufbau vernetzter Dienste, die Handhabung von HTTP und die Verwaltung der Parallelität, wodurch der Bedarf an externen Abhängigkeiten reduziert wird.

Diese Faktoren machen Go ideal für moderne serverseitige Anwendungen, insbesondere wenn Leistung und Skalierbarkeit wichtig sind.

Wie erstellt man einen REST-API-Server in Golang?

Es gibt viele Frameworks zum Erstellen Ihrer REST-API-Server in Golang, wie Gin, Gorrilla-Mux und viele andere.

Wir würden ein neues Framework verwenden, das einen umfassenden Satz an Tools zum Erstellen Ihrer Golang-Anwendungen bietet.

Lassen Sie uns tief in die Umsetzung eintauchen

Gewünschte APIs, die wir erstellen möchten

GET /api/v1/users
POST /api/v1/users
PUT /api/v1/users/:id
DELETE /api/v1/users/:id

Sobald wir unsere benötigten APIs definiert haben, beginnen wir mit der Initiierung des Out-Go-Projekts. Verwenden Sie die folgenden Befehle:-

mkdir my-go-server
cd my-go-server
go mod init rest_server

go get oss.nandlabs.io/golly

Sobald Sie die obige Aktion ausgeführt haben, sollten Sie eine Ordnerstruktur wie unten sehen können

Jetzt können wir mit der Erstellung unserer gewünschten Serverstruktur beginnen

Erstellen Sie eine main.go-Datei, die main() enthält, d. h. den Einstiegspunkt Ihrer Golang-Anwendung

package main

import "rest_server/server"

func main() {
        // create the instance of your server
    srv := server.NewServer()
        // start your server
    srv.Start()
}

Erstellen Sie eine /server/server.go-Datei, die Ihre Serverkonfiguration enthält

package server

import (
    "rest_server/handlers"
    "rest_server/store"

    "oss.nandlabs.io/golly/lifecycle"
    "oss.nandlabs.io/golly/rest/server"
)

type Server struct {
    store *store.Store
}

func NewServer() *Server {
    return &Server{
        store: store.NewStore(),
    }
}

func (s *Server) Start() {
    // register the router by creating the server object
    restServer, err := server.Default()
    if err != nil {
        panic(err)
    }

    // Add path prefix if you want
    restServer.Opts().PathPrefix = "/api/v1"

    // register routes
    restServer.Get("/users", handlers.GetUsers)
    restServer.Post("/users", handlers.AddUser)
    restServer.Put("/users/:id", handlers.UpdateUser)
    restServer.Delete("/users/:id", handlers.DeleteUser)

    // create the http.Server object and register the router as Handler
    // provide the necessary configurations such as PORT, ReadTimeout, WriteTimeout...
    manager := lifecycle.NewSimpleComponentManager()

    // Register the server
    manager.Register(restServer)

    // start the server
    manager.StartAndWait()
}

Die Anwendungsstruktur, die Sie erreichen möchten, ist wie folgt

Erstellen Sie einen In-Memory-Speicher unter /store/store.go, um Ihre CRUD-Vorgänge zu testen.

package store

import "rest_server/models"

type Store struct {
    data map[string]models.Item
}

var initStore *Store

func NewStore() *Store {
    initStore = &Store{data: make(map[string]models.Item)}
    return initStore
}

func GetStore() *Store {
    return initStore
}

func (s *Store) GetAll() []models.Item {
    items := []models.Item{}
    for _, item := range s.data {
        items = append(items, item)
    }
    return items
}

func (s *Store) GetById(id string) (item models.Item, exists bool) {
    item, exists = s.data[id]
    return
}

func (s *Store) Put(id string, item models.Item) {
    s.data[id] = item
}

func (s *Store) Delete(id string) {
    delete(s.data, id)
}

Dies würde sich auf die Modelle beziehen, die unter /models/item.go
vorhanden sind

GET /api/v1/users
POST /api/v1/users
PUT /api/v1/users/:id
DELETE /api/v1/users/:id

Die Handler würden den Handler für jeden Endpunkt enthalten, der unter /server/server.go definiert ist.

Eine solche Implementierung von /handlers/AddUser.go ist unten

mkdir my-go-server
cd my-go-server
go mod init rest_server

go get oss.nandlabs.io/golly

Ebenso können Sie auch andere Handler mit der gewünschten Logik erstellen.

Das vollständige Beispiel finden Sie in diesem Github-Repository

Sobald Sie Ihren Server erstellt haben, können Sie ihn mit dem folgenden Befehl starten

package main

import "rest_server/server"

func main() {
        // create the instance of your server
    srv := server.NewServer()
        // start your server
    srv.Start()
}

Die Ausgabe sollte wie folgt aussehen

Sie können die registrierten Endpunkte und den Startort des Servers sehen.

Sobald der Server gestartet ist, können Sie den Postman- oder Curl-Befehl verwenden, um Ihre APIs aufzurufen.

Sie können sehen, wie schnell wir mit dem Golly-Framework in Golang einen REST-Server hochfahren konnten.

Vorteile der Verwendung von Golly als mein bevorzugtes Framework zum Erstellen von Go-Anwendungen

• Alle verwendeten Bibliotheken, sei es Lebenszyklusverwaltung, UUID-Generierung, Protokollierung, Restserververwaltung und vieles mehr, werden von golly standardmäßig bereitgestellt.
• Eine große Anzahl integrierter Bibliotheken ist vorhanden, sodass ich nicht mehrere Bibliotheken von Drittanbietern importieren muss, wodurch mein go.mod sauber und verwaltbar bleibt.
• Einfache und schnelle Umsetzung der Module, einfache Lernkurve.
• Open-Source-Bibliothek

Weitere Informationen zu Golly finden Sie im Repository Golly. Sie können den Code auschecken und gerne einen Beitrag leisten!

Vielen Dank für das Lesen dieses Artikels!!
Wenn Sie Fragen haben, fügen Sie bitte Ihre Kommentare hinzu.

Das obige ist der detaillierte Inhalt vonWarum habe ich mich für das Framework „golly“ entschieden, um meine nächste Golang-basierte REST-API zu erstellen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!