Comment implémenter la feinte dans Golang

Ces dernières années, avec la popularité de l'architecture des microservices, de plus en plus d'entreprises ont commencé à utiliser des microservices pour créer des systèmes logiciels. Dans les microservices, la communication entre les services est cruciale, il faut donc un moyen efficace et fiable d'appeler les services. Dans l'écosystème Java, Feign, en tant que framework d'appel de microservices couramment utilisé, a été largement utilisé. Cependant, il n'existe pas encore de framework Feign décent pour Golang, les développeurs de Golang doivent donc utiliser d'autres méthodes pour établir la communication entre les microservices. Cet article expliquera comment utiliser Golang pour implémenter un cadre d'appel de microservices similaire à Feign.

Voici les étapes pour implémenter Feign dans Golang :

Étape 1 : Installer et introduire les bibliothèques nécessaires

Dans Golang, nous devons utiliser la bibliothèque HTTP pour la communication HTTP En même temps, nous avons également besoin de quelques éléments supplémentaires. bibliothèques pour gérer la communication HTTP. Vous pouvez utiliser les modules Go pour gérer les dépendances et vous pouvez également utiliser la commande go get pour installer ces bibliothèques. Dans cet article, nous utiliserons la commande go get pour installer http, la bibliothèque fmt et d'autres bibliothèques nécessaires.

Étape 2 : Définir l'interface

Dans Golang, nous pouvons définir une interface pour définir tous les appels dans le microservice. L'interface doit contenir toutes les méthodes qui doivent être appelées, et chaque méthode doit avoir des paramètres tels que l'URL de la demande, la méthode de la demande, l'en-tête de la demande et le corps de la demande. Par exemple :

type UserService interface {
    GetUserByID(ctx context.Context, id int64) (*User, error)
    CreateUser(ctx context.Context, user *User) error
    UpdateUser(ctx context.Context, user *User) error
    DeleteUserByID(ctx context.Context, id int64) error
}

Dans le code ci-dessus, nous définissons une interface UserService, qui contient 4 méthodes : GetUserByID, CreateUser, UpdateUser et DeleteUserByID. Ces méthodes seront utilisées pour appeler les services des utilisateurs distants.

Étape 3 : Implémenter l'interface

Tout d'abord, vous devez créer une nouvelle structure Client pour implémenter l'interface UserService et définir certains attributs nécessaires dans la structure (par exemple, l'URL de base du service distant, le client HTTP, etc. .). Ensuite, chaque méthode d’interface doit être implémentée séparément. Chaque méthode doit créer une requête HTTP correspondante basée sur la méthode de requête (telle que GET ou POST) et transmettre tous les paramètres nécessaires à la requête. Nous pouvons utiliser les bibliothèques HTTP couramment utilisées dans Golang pour créer la requête et désérialiser la réponse de la requête dans l'objet requis. Par exemple :

type UserClient struct {
    BaseURL    string
    HTTPClient http.Client
}

func (c *UserClient) GetUserByID(ctx context.Context, id int64) (*User, error) {
    req, _ := http.NewRequestWithContext(ctx, http.MethodGet, c.BaseURL+"/users/"+strconv.FormatInt(id, 10), nil)
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("unexpected status code: %v", resp.StatusCode)
    }
    var user User
    if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
        return nil, err
    }
    return &user, nil
}

func (c *UserClient) CreateUser(ctx context.Context, user *User) error {
    reqBody, _ := json.Marshal(user)
    req, _ := http.NewRequestWithContext(ctx, http.MethodPost, c.BaseURL+"/users", bytes.NewBuffer(reqBody))
    req.Header.Set("Content-Type", "application/json")
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return err
    }
    defer resp.Body.Close()
    if resp.StatusCode != http.StatusCreated {
        return fmt.Errorf("unexpected status code: %v", resp.StatusCode)
    }
    return nil
}

...

Dans le code ci-dessus, nous avons implémenté les méthodes GetUserByID et CreateUser. Par exemple, la méthode GetUserByID génère une requête HTTP basée sur la méthode de requête, l'URL de la requête et les paramètres de la requête, et utilise un client HTTP pour envoyer la requête au service distant. Ensuite, désérialisez la réponse dans un objet User et renvoyez-la. La méthode CreateUser est similaire, mais ajoute User comme corps de la requête à la requête HTTP.

Étape 4 : Utiliser l'interface implémentée

Maintenant, nous pouvons utiliser la structure Client dans l'application principale pour appeler les méthodes définies dans l'interface UserService. Par exemple :

func main() {
    client := &UserClient{
        BaseURL:    "http://localhost:8080",
        HTTPClient: http.Client{},
    }
    user, _ := client.GetUserByID(context.Background(), 1)
    fmt.Println(user.Name)
    newUser := &User{Name: "Bob"}
    client.CreateUser(context.Background(), newUser)
}

Dans le code ci-dessus, nous créons d'abord une instance UserClient, puis utilisons l'instance pour appeler les méthodes GetUserByID et CreateUser. Dans la méthode GetUserByID, nous transmettons un contexte afin de garantir que les délais d'attente et l'annulation du contexte sont gérés correctement.

Résumé

Grâce à cet article, nous avons appris à utiliser Golang pour implémenter un framework d'appel de microservices similaire à Feign. Grâce à ce framework, nous pouvons facilement appeler d'autres microservices dans les applications Golang sans construire manuellement de requêtes HTTP. De plus, nous avons également appris à définir et à mettre en œuvre la communication entre les microservices dans Golang à l'aide d'interfaces et de structures. Les utilisateurs peuvent étendre le framework en implémentant des interfaces dans la structure client pour prendre en charge davantage d'appels de microservices.

Enfin, il est important de noter que cet article n’est qu’un exemple. En utilisation réelle, davantage de facteurs doivent être pris en compte, tels que la sécurité, les performances et la maintenabilité.

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!