Création de microservices à l'aide du framework Web de Golang Echo Framework

Ces dernières années, avec le développement rapide de la technologie Internet, l'architecture des microservices est devenue un modèle d'architecture logicielle adopté par de plus en plus d'entreprises. Par rapport à une seule application à grande échelle, l'architecture de microservice divise une application à grande échelle en plusieurs petits services. Chaque service peut être déployé, étendu et entretenu indépendamment, améliorant ainsi l'efficacité du développement et la fiabilité des applications. Cet article explique comment créer un microservice simple à l'aide du framework Web Echo de Golang.

1. Qu'est-ce que le framework Echo ?

Echo est un framework web performant, léger, simple et élégant basé sur le langage Golang et adopte le modèle d'architecture MVC (Model-View-Controller), ce qui signifie que nous pouvons facilement Divisez l'application en trois couches : modèle, vue et contrôleur.

En raison de l'émergence du framework Echo, il n'est plus nécessaire d'utiliser la bibliothèque native net/http pour le développement. Echo fournit un routage élégant, un middleware puissant, un traitement rapide des requêtes et des réponses HTTP, etc.

2. Installez le framework Echo

Pour utiliser le framework Echo, vous devez d'abord l'installer. Nous pouvons utiliser la commande go get pour installer le framework Echo :

go get -u github.com/labstack/echo/v4

Cette commande téléchargera le framework Echo depuis Github et l'installera sous github.com/labstack/echo/v4 dans le répertoire src de GOPATH.

3. Utilisez le framework Echo pour créer des microservices

Après avoir installé le framework Echo, nous pouvons commencer à créer un microservice simple.

Créez un répertoire nommé echo-demo sous GOPATH, et créez un fichier nommé main.go dans ce répertoire :

package main

import (
    "net/http"

    "github.com/labstack/echo/v4"
)

func main() {
    // create echo instance
    e := echo.New()

    // define route
    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, World!")
    })

    // start server
    e.Logger.Fatal(e.Start(":8080"))
}

Dans le code, nous avons d'abord importé "net/http" et "github.com/labstack/echo/v4 " emballer. Ensuite, nous avons créé une instance Echo e et défini une route "/". Lors de l'accès au répertoire racine "/", "Hello, World!"

Enfin, nous utilisons "e.Logger.Fatal(e.Start(":8080"))" pour démarrer le serveur Echo et spécifier le numéro de port comme 8080. À ce stade, nous pouvons saisir « http://localhost:8080 » dans le navigateur pour accéder à notre microservice, et nous devrions voir « Hello, World !

4. Créez des microservices plus complexes

Ce qui précède n'est qu'un exemple simple de microservices. Dans des applications réelles, vous devrez peut-être créer des microservices plus complexes. Dans le framework Echo, nous pouvons créer des microservices plus complets grâce à des fonctions telles que le middleware, la liaison de paramètres et le rendu de modèles.

1. Middleware

Le Middleware est une fonction très puissante et pratique dans le framework Echo. Il peut ajouter une logique de traitement supplémentaire pendant tout le processus, du client envoyant une requête au serveur répondant à la requête. Dans le framework Echo, nous pouvons utiliser la méthode Use() pour enregistrer un middleware.

Exemple :

func main() {
    //create echo instance
    e := echo.New()

    //define middleware
    e.Use(middleware.Logger())

    //define route
    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, World!")
    })

    //start server
    e.Logger.Fatal(e.Start(":8080"))
}

Dans l'exemple ci-dessus, nous utilisons e.Use(middleware.Logger()) pour enregistrer un middleware. Ce middleware imprimera des informations telles que la méthode, l'URI, la taille du corps de la requête et le code de réponse de chaque requête avant que la requête n'atteigne la méthode de traitement de routage correspondante. Cela nous permet de comprendre plus clairement la situation de la demande lors du débogage, en particulier lorsque la demande est anormale, et nous pouvons bien comprendre le traitement de la demande et de la réponse, ce qui facilite grandement notre développement et notre dépannage.

2. Liaison de paramètres

Le framework Echo dispose d'une puissante fonction de liaison de paramètres qui peut nous aider à extraire les paramètres des requêtes HTTP, afin que les données puissent être facilement transmises au gestionnaire sans extraire manuellement les données. Les formats courants pour la liaison de paramètres sont JSON, XML, les paramètres de formulaire et de requête, etc.

Exemple :

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

func main() {
    // create echo instance
    e := echo.New()

    // define route for create user
    e.POST("/users/create", func(c echo.Context) error {
        // bind json data to struct instance
        u := new(User)
        if err := c.Bind(u); err != nil {
            return err
        }
        return c.JSON(http.StatusCreated, u)
    })

    // start server
    e.Logger.Fatal(e.Start(":8080"))
}

Dans l'exemple ci-dessus, nous avons défini une structure User puis créé une route "/users/create". Lorsque la requête appelle la route en mode POST, les données de la requête au format JSON seront automatiquement. se lie à l'instance de structure User u, puis renvoie la réponse au format JSON de l'instance.

3. Rendu de modèles

Le framework Echo prend également en charge plusieurs moteurs de modèles, tels que HTML, JSON, etc. Nous pouvons utiliser la méthode Render fournie par le framework pour le rendu des modèles.

Exemple :

func main() {
    // create echo instance
    e := echo.New()

    // use html renderer
    e.Renderer = &Template{
        templates: template.Must(template.ParseGlob("templates/*.html")),
    }

    // define route
    e.GET("/users/:id", func(c echo.Context) error {
        id := c.Param("id")
        u := User{Id: id, Name: "jack", Email: "jack@sample.com"}
        return c.Render(http.StatusOK, "user.html", u)
    })

    // start server
    e.Logger.Fatal(e.Start(":8080"))
}

Dans l'exemple ci-dessus, nous utilisons &Template{} pour créer le moteur de modèle et utilisons la méthode ParseGlob() pour spécifier le chemin d'accès au fichier modèle. Ensuite, dans l'implémentation du routage, nous utilisons la méthode c.Param() pour obtenir les paramètres de routage, utilisons la structure User pour construire les données et enfin utilisons la méthode c.Render() pour restituer le modèle et renvoyer la réponse.

5. Résumé

Le framework Echo est un framework Web Golang simple et élégant avec des performances élevées et des fonctionnalités légères. L'utilisation du framework Echo pour créer des microservices peut améliorer l'efficacité du développement et la fiabilité des applications. Vous pouvez apprendre l'utilisation de base d'Echo à travers les exemples ci-dessus, et vous pouvez également ajuster et améliorer l'architecture des microservices dans les applications réelles.

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!