Comment Golang résoudra votre première tâche de travail

Golang, ou simplement Go, est devenu connu sous le nom de langage Go Gopher. Si vous ne comprenez toujours pas pourquoi le gopher, vous pouvez découvrir une surprenante histoire de mascotte dans cet article. Eh bien, commençons depuis le début, Golang est devenu connu comme l'un des langages de programmation les plus productifs du marché. Contrairement aux langages traditionnels comme Java ou Python, Go établit un équilibre unique entre un code facile à écrire et une exécution rapide, accélérant le développement et réduisant le temps de débogage et de test. Cet article examinera un exemple concret d'utilisation de goroutines et de contexte dans un projet qui interagit avec un microservice d'API REST lent et instable.

La tâche
Imaginons que vous venez de rejoindre l'équipe et que votre chef d'équipe vous demande de lier un nouveau microservice écrit en Golang (par exemple le gestionnaire de risques) au microservice utilisateur exposé via l'API REST.

Le problème
Le gestionnaire de risques doit interagir avec une API REST qui peut être lente et instable, ce qui nous oblige à traiter ces demandes avec précaution. J'utiliserai des goroutines pour les requêtes HTTP asynchrones et le contexte afin de gérer les délais d'attente des requêtes et la gestion des erreurs.

La solution

L'utilisation de goroutines et de contexte dans Golang permet une gestion efficace des tâches simultanées et la gestion des API externes lentes ou instables.

La première étape pour l'interpréter dans un code est de créer l'API, j'ai utilisé le service shareware https://mockapi.io/ Il est pratique de générer un REST API avec un ensemble d'entités de base, telles que les utilisateurs.

Disons que quelqu'un a fait de son mieux et que votre entreprise dispose d'un service interne qui répertorie les utilisateurs. Notre tâche est de réutiliser la liste des utilisateurs dans le nouveau gestionnaire de risques (la structure des données utilisateur satisfait au contrat décrit par mockapi.io). Le code ci-dessous effectue une requête, traite le corps et produit soit une liste d'utilisateurs, soit l'erreur correspondante.

type User struct {
    CreatedAt string
    Name      string
    Avatar    string
    Id        string
}

// Original slow request
func fetchUsers(ctx context.Context) (*[]User, error) {
    resp, err := http.Get("https://<use your id after sign up>.mockapi.io/api/v1/users")
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("failed to fetch users: %s", resp.Status)
    }

    var users []User
    if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
        return nil, err
    }

    return &users, nil
}

Pour contrôler l'opération, j'utiliserai le contexte parent le plus élevé pour tous les autres contextes - context.Background. Je compléterai ce contexte avec de nouvelles données, en l'occurrence le timeout - context.WithTimeout, que je définirai comme 2 secondes. Vous pouvez en savoir plus sur l'utilisation des contextes dans Go dans cet article.

ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()

usersChan := make(chan *[]User)
errChan := make(chan error)

go func() {
    users, err := fetchUsers(ctx)
    if err != nil {
        errChan <- err
        return
    }
    usersChan <- user
}()

select {
case users := <-usersChan:
    fmt.Printf("Fetched users: %+v\n", users)
case err := <-errChan:
    fmt.Printf("Error fetching users: %v\n", err)
case <-ctx.Done():
    fmt.Println("Request timed out")
}

Dans l'exemple, j'utilise deux canaux - usersChan pour enregistrer le résultat reçu de notre service interne, et le deuxième canal errChan - pour enregistrer l'erreur.
Si la réponse d'une API lente n'arrive pas dans les 2 secondes, nous détectons une erreur et donnons la possibilité de la traiter correctement sur une couche externe.

Dans cet exemple pratique avec le gestionnaire de risques, les goroutines ont activé les requêtes HTTP asynchrones, tandis que le contexte a assuré la gestion des délais d'attente, ce qui est essentiel pour créer des microservices fiables et résilients.

P.S.

Cet article est destiné aux développeurs débutants qui ont des connaissances de base, mais peu d'idées sur l'endroit où ils peuvent appliquer leurs connaissances. Je serai heureux de recevoir vos commentaires et je me ferai un plaisir de répondre à vos questions.
Un exemple fonctionnel et plusieurs autres implémentations des éléments les plus basiques du langage Go peuvent être trouvés sur mon GitHub, sur le lien

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!