construction de l'API Golang

Golang est un langage de programmation spécialement conçu pour créer des services et des applications réseau à haute concurrence. Golang possède des capacités efficaces de simultanéité et de programmation réseau, ce qui en fait le premier choix de nombreux développeurs. Pour créer une API Golang, nous devons maîtriser de nombreux concepts et compétences de base, du traitement du routage à l'accès aux bases de données et bien plus encore. Cet article explique comment utiliser Golang pour créer des API.

1. Préparation de l'environnement

Avant de commencer à créer l'API Golang, vous devez installer Golang sur votre ordinateur. Vous pouvez télécharger la dernière version de Golang via le site officiel de Golang (https://golang.org/) ou l'installer via un gestionnaire de packages, tel que apt-get ou yum, etc. Une fois l'installation terminée, entrez « go version » dans le terminal pour vérifier si l'installation a réussi.

2. Installation des packages de dépendances

Utilisez la commande "go get" dans le terminal pour installer les packages de dépendances requis. Les packages dépendants sont certaines bibliothèques que nous utilisons souvent dans l'API, telles que "gorilla/mux" et "gorm". La méthode d'installation est la suivante :

go get github.com/gorilla/mux 
go get github.com/jinzhu/gorm 
go get github.com/go-sql-driver/mysql

3. Traitement du routage

Toutes les requêtes API doivent être complétées via le routage. L'un des packages de routage les plus populaires dans Golang est gorilla/mux, nous l'utiliserons donc également.

Pour utiliser gorilla/mux, nous devons importer le package et créer un nouvel objet mux. Dans cet exemple, nous allons créer deux routes, une pour afficher la page d'accueil de l'API et une autre pour gérer nos requêtes GET.

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

func main() {
    router := mux.NewRouter()

    router.HandleFunc("/", Index)
    router.HandleFunc("/tasks", getTasks).Methods("GET")

    http.ListenAndServe(":8000", router)
}

func Index(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Welcome to my API!")
}

func getTasks(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "You have requested all tasks")
}

Dans le code ci-dessus, nous avons créé deux fonctions de gestionnaire, Index et getTasks. La fonction Index est utilisée pour afficher la page d'accueil de l'API et getTasks gère toutes les requêtes GET.

4. Accès à la base de données

Nous allons maintenant ajouter la fonctionnalité de base de données à l'API. Dans cet exemple, nous utiliserons une base de données MySQL et utiliserons la bibliothèque gorm pour gérer les données.

Tout d’abord, nous devons créer une connexion à la base de données. Pour ce faire, nous devons créer une structure de base de données contenant les détails de connexion. Ensuite, nous allons créer une nouvelle fonction "openDB" pour ouvrir la connexion.

...

import (
    "database/sql"
    "log"

    _ "github.com/go-sql-driver/mysql"
    "github.com/jinzhu/gorm"
)

type Database struct {
    *gorm.DB
}

func (db *Database) openDB() {
    dsn := "username:password@tcp(127.0.0.1:3306)/godb?charset=utf8&parseTime=True"
    conn, err := sql.Open("mysql", dsn)
    if err != nil {
        log.Fatal(err)
    }

    db.DB = gorm.Open("mysql", conn)
}

Nous devons maintenant créer un nouvel objet Database dans la fonction principale et ouvrir la connexion à l'aide de la fonction openDB.

db := new(Database)
db.openDB()

Ensuite, nous créerons un modèle de tâche à associer à notre liste de tâches. Un modèle est simplement une structure Go standard qui sera mappée à une table de notre base de données MySQL.

type Task struct {
    Id      int    `gorm:"primary_key;auto_increment"`
    Name    string `gorm:"not null"`
    Content string `gorm:"not null"`
}

Pour créer une nouvelle tâche, nous allons créer une fonction de gestionnaire appelée "createTask". Cette fonction recevra les données JSON de la requête HTTP, les analysera et les insérera dans notre base de données.

func createTask(w http.ResponseWriter, r *http.Request) {
    db := new(Database)
    db.openDB()

    task := &Task{}
    task.Name = r.FormValue("name")
    task.Content = r.FormValue("content")

    db.Create(&task)
    fmt.Fprintln(w, "Task successfully created")
}

Nous voyons que la fonction "createTask" crée un nouvel objet Database et un nouvel objet Task au début. Il analyse ensuite les données JSON de la requête HTTP et les insère dans la base de données en appelant la méthode db.Create().

Enfin, nous mettrons à jour notre route "router.HandleFunc" pour inclure la nouvelle route.

router.HandleFunc("/tasks", createTask).Methods("POST")

5. Middleware

Le middleware est une technologie courante utilisée pour effectuer des opérations avant ou après le traitement d'une requête. Ils sont largement utilisés non seulement en Golang mais aussi dans d’autres langues. Voyons comment utiliser le middleware pour ajouter des fonctionnalités supplémentaires dans l'API Golang.

Dans Golang, le middleware est une fonction qui prend en paramètre une fonction de traitement HTTP. Ils permettent d'exécuter une certaine logique avant ou après le traitement de la demande. Dans l'exemple suivant, nous allons créer un middleware appelé « withLogging » qui enregistrera les détails de toutes les requêtes API.

func withLogging(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Println(r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

Nous voyons qu'une nouvelle fonction http.Handler est renvoyée dans la fonction, qui enregistre la méthode demandée et le chemin de l'URL. L'instruction next.ServeHTTP(w, r) appelle le gestionnaire suivant, garantissant que le gestionnaire continue de traiter les requêtes API.

Ensuite, nous mettrons à jour nos routes et nos gestionnaires pour inclure le nouveau middleware de journalisation.

router := mux.NewRouter()

router.Use(withLogging)

router.HandleFunc("/", Index)
router.HandleFunc("/tasks", createTask).Methods("POST")
router.HandleFunc("/tasks", getTasks).Methods("GET")

Maintenant, ajoutez l'instruction "router.Use(withLogging)" avant la route et nous exécuterons le middleware withLogging sur toutes les requêtes de route.

6. Résumé

Dans cet article, nous avons présenté comment utiliser gorilla/mux pour gérer le routage dans Golang, utiliser gorm pour gérer la base de données MySQL et comment utiliser le middleware pour améliorer notre API. En comprenant ces concepts et compétences de base, nous pouvons commencer à créer des API Golang plus complexes.

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!