Pourquoi ai-je choisi le framework « golly » pour créer ma prochaine API REST basée sur Golang ?

Pourquoi choisir Go (Golang) pour le développement côté serveur ?

Le choix de Go (Golang) pour le développement côté serveur est souvent motivé par ses principaux atouts :

• Performance : Le modèle de concurrence de Go, basé sur des goroutines et des canaux, permet une gestion efficace de plusieurs tâches simultanément, ce qui le rend idéal pour les applications serveur hautes performances.

• Simplicité : Le langage est conçu pour être simple et facile à lire, avec une syntaxe minimaliste. Cela facilite la maintenance, même pour les grands projets.

• Compilation et exécution rapides : Go compile directement dans le code machine, ce qui entraîne des temps d'exécution rapides par rapport aux langages interprétés comme Python ou Node.js.

• Évolutivité : La concurrence intégrée et la légèreté de Go en font un bon choix pour créer des services évolutifs capables de gérer un grand nombre de requêtes.

• Bibliothèque standard puissante : Go est livré avec une bibliothèque standard puissante, en particulier pour la création de services en réseau, la gestion de HTTP et la gestion de la concurrence, réduisant ainsi le besoin de dépendances externes.

Ces facteurs font de Go un choix idéal pour les applications côté serveur modernes, en particulier lorsque les performances et l'évolutivité sont importantes.

Comment créer un serveur API REST dans Golang ?

Il existe de nombreux frameworks présents pour créer vos serveurs API REST dans Golang comme Gin, Gorrilla-Mux et bien d'autres.

Nous utiliserions un nouveau framework qui fournit un ensemble complet d'outils pour créer vos applications Golang.

Plongeons-nous en profondeur dans la mise en œuvre

API souhaitées que nous souhaitons créer

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

Une fois que nous avons défini nos API nécessaires, nous commençons par lancer le projet. Utilisez les commandes suivantes :-

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

go get oss.nandlabs.io/golly

Une fois que vous avez effectué l'action ci-dessus, vous devriez pouvoir voir une structure de dossiers comme ci-dessous

Nous pouvons maintenant commencer à créer la structure de serveur souhaitée

Créez un fichier main.go qui contient le main() c'est à dire le point d'entrée de votre application golang

package main

import "rest_server/server"

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

Créez un fichier /server/server.go qui contient la configuration de votre serveur

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()
}

La structure de candidature que vous souhaitez obtenir est comme ci-dessous

Créez un magasin en mémoire sous /store/store.go afin de tester vos opérations CRUD.

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)
}

Cela ferait référence aux modèles présents sous /models/item.go

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

Les gestionnaires contiendraient le gestionnaire de chaque point de terminaison défini sous /server/server.go.

Une telle implémentation d'un /handlers/AddUser.go est ci-dessous

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

go get oss.nandlabs.io/golly

De même, vous pouvez créer d'autres gestionnaires avec la logique souhaitée.

Un exemple complet peut être trouvé sur ce référentiel github

Une fois que vous avez créé votre serveur, vous pouvez démarrer votre serveur en utilisant la commande ci-dessous

package main

import "rest_server/server"

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

Le résultat devrait être comme ci-dessous

Vous pouvez voir les points de terminaison enregistrés et où le serveur est démarré.

Une fois le serveur démarré, vous pouvez utiliser la commande Postman ou Curl pour appeler vos API.

Vous pouvez voir à quelle vitesse nous avons pu démarrer un serveur REST en utilisant le framework Golly dans Golang.

Avantages de l'utilisation de Golly comme framework de prédilection pour créer une application Go

• Toutes les bibliothèques utilisées, qu'il s'agisse de la gestion du cycle de vie, de la génération d'UUID, de la journalisation, de la gestion des serveurs de repos et bien d'autres, sont fournies prêtes à l'emploi par Golly.
• Grand nombre de bibliothèques intégrées présentes, où je n'ai pas besoin d'importer plusieurs bibliothèques tierces, ce qui garde mon go.mod propre et gérable.
• Mise en œuvre simple et rapide des modules, courbe d'apprentissage facile.
• Bibliothèque open source

Pour plus de détails sur Golly, visitez le référentiel Golly. Vous pouvez consulter le code et n'hésitez pas à contribuer !

Merci d'avoir lu cet article !!
Si vous avez des questions, veuillez ajouter vos commentaires.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!