Expliquer les principes fondamentaux et l'utilisation de la mise en œuvre de Thrift Golang

Thrift est un framework de service à distance de type multilingue et multiservice. Il prend en charge l'utilisation du langage de description d'interface défini par IDL pour définir des interfaces RPC multilingues. Parmi eux, l'implémentation golang de Thrift fournit un cadre RPC léger et efficace, largement utilisé dans les systèmes distribués. Cet article expliquera les principes fondamentaux et l'utilisation de l'implémentation de Thrift Golang.

1. Principe de fonctionnement de l'implémentation de Thrift Golang

Thrift utilise le langage IDL pour définir des interfaces et génère des codes d'interface dans différentes langues via un générateur de code, puis utilise le protocole RPC pour communiquer entre différentes langues. L'implémentation golang de Thrift adopte également cette idée, en utilisant l'outil gothrift pour générer le code d'interface du langage Go afin d'implémenter la communication RPC entre différents langages.

Plus précisément, l'utilisation de l'implémentation golang de Thrift nécessite les étapes suivantes :

1. Définir le fichier d'interface IDL

Tout d'abord, vous devez définir le fichier d'interface en utilisant le langage IDL. Pour la syntaxe spécifique, veuillez vous référer à la documentation officielle de Thrift. Voici un exemple IDL simple :

namespace go thrift.demo

struct Person {
    1: i32 Id
    2: string Name
    3: i32 Age
}

service DemoService {
    void SayHello()
    i32 Add(1:i32 a, 2:i32 b)
    Person GetPerson(1:i32 id)
}

Le fichier IDL ci-dessus définit un service nommé "DemoService", qui contient trois méthodes "SayHello", "Add" et "GetPerson". Parmi eux, les paramètres de la méthode "Add" incluent deux paramètres entiers a et b, et la valeur de retour est un entier. Le paramètre de la méthode "GetPerson" est un identifiant entier et renvoie une structure "Person".

2. Générer le code Go

Ensuite, vous devez utiliser l'outil gothrift pour générer le code d'interface golang correspondant. Les étapes spécifiques sont les suivantes :

• Installer gothrift

Utilisez l'outil de ligne de commande go pour installer gothrift :

go get github.com/apache/thrift/lib/go/thrift

• Exécuter gothrift

Utilisez le fichier IDL généré pour exécuter gothrift afin de générer du code Go :

gothrift --out=./gen --template=go thrift-demo.thrift

Après avoir exécuté la commande ci-dessus, génèrez les fichiers de code Golang.

3. Implémenter les services d'interface

Après avoir obtenu le code d'interface golang généré, vous devez implémenter ces services d'interface. Voici quelques exemples d'implémentation :

type demoServiceImpl struct{}

func (demoServiceImpl) SayHello(ctx context.Context) (err error) {
    fmt.Println("Hello World")
    return
}

func (demoServiceImpl) Add(ctx context.Context, a, b int32) (int32, error) {
    return a + b, nil
}

func (demoServiceImpl) GetPerson(ctx context.Context, id int32) (*Person, error) {
    person := &Person{
        Id: id,
        Name: "张三",
        Age: 25,
    }
    return person, nil
}

Dans le code ci-dessus, un type nommé "demoServiceImpl" est défini et trois méthodes "SayHello", "Add" et "GetPerson" sont implémentées.

4. Démarrez le service

Après avoir terminé la mise en œuvre du service d'interface, vous devez démarrer le service d'appel à distance. Voici un exemple de code :

transportFactory := thrift.NewTBufferedTransportFactory(8192)
protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
addr := "localhost:9091"
transport, err := thrift.NewTServerSocket(addr)
if err != nil {
    return
}
handler := &demoServiceImpl{}
processor := demo.NewDemoServiceProcessor(handler)
server := thrift.NewTSimpleServer4(processor, transport, transportFactory, protocolFactory)
server.Serve()

Dans le code ci-dessus, utilisez d'abord "NewTBufferedTransportFactory" et "NewTBinaryProtocolFactoryDefault" pour créer les objets transportFactory et protocolFactory. Utilisez ensuite "NewTServerSocket" pour ouvrir ServerSocket à l'adresse spécifiée. Transmettez ensuite l'objet "demoServiceImpl" qui implémente l'interface "DemoService", et créez le processeur "DemoServiceProcessor". Enfin, utilisez « NewTSimpleServer4 » pour activer la surveillance des services.

2. Comment utiliser l'implémentation de Thrift golang

Ce qui suit présente comment utiliser l'implémentation de Thrift golang :

1. Installez Thrift

Téléchargez le package binaire de Thrift et installez-le.

2. Créez un fichier IDL

Utilisez le langage IDL pour définir le fichier d'interface et définir les méthodes d'interface et les types de données.

3. Générer le code d'interface Golang

Utilisez l'outil gothrift pour générer le code d'interface Golang.

4. Implémentez le service d'interface

Écrivez le code d'implémentation du service d'interface en fonction de la définition d'interface générée.

5. Activez le service

Selon l'exemple de code, activez la surveillance du serveur Thrift.

6. Interface d'appel du client

Le client Thrift effectue des appels à distance via le code d'interface Golang généré. Voici un exemple de code simple :

transport, err := thrift.NewTSocket("localhost:9091")
if err != nil {
    panic(err)
}
if err := transport.Open(); err != nil {
    panic(err)
}
defer transport.Close()

protocolFactory := thrift.NewTBinaryProtocolFactoryDefault()
client := demo.NewDemoServiceClientFactory(transport, protocolFactory)
if err := client.SayHello(context.Background()); err != nil {
    panic(err)
}
res, _ := client.Add(context.Background(), 1, 2)
fmt.Println(res)
person, _ := client.GetPerson(context.Background(), 1)
fmt.Println(person)

Dans le code ci-dessus, créez d'abord l'objet de transport client et connectez-vous au serveur Thrift. Créez ensuite l'objet client "NewDemoServiceClientFactory" et utilisez les méthodes "SayHello", "Add" et "GetPerson" pour effectuer des appels à distance.

Résumé :

Cet article présente le principe de fonctionnement et l'utilisation de l'implémentation de Thrift Golang. L'utilisation de Thrift pour implémenter RPC peut réduire efficacement les coûts de développement et accélérer la progression du développement du système. L'implémentation golang de Thrift est un framework RPC léger et efficace qui est largement utilisé dans les systèmes distribués.

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!