Implémentez facilement le traitement des transactions distribuées avec go-zero

Avec le développement d'Internet et de la numérisation, il existe de plus en plus de demandes d'applications distribuées, et le traitement des transactions distribuées est devenu un problème inévitable. De nombreux développeurs s'appuient sur leur propre expérience et écrivent manuellement du code lorsqu'ils traitent des transactions distribuées. Cependant, cette approche implique de grands risques et une grande complexité, et est difficile à maintenir et à développer. Le framework go-zero centré sur les transactions peut fournir aux développeurs une solution simple et facile à utiliser.

go-zero est un framework de développement d'applications distribué écrit en langage golang, qui représente le plus haut niveau de technologie actuelle du langage go. En termes d'architecture sous-jacente, il utilise grpc comme cadre d'interaction de protocoles et de données pour le développement, et au niveau de la logique métier, il utilise un modèle de microservice unifié pour créer des applications. Parce que le concept de conception de go-zero est léger et facile à utiliser, et qu'il fonctionne bien dans une variété de scénarios, il a un taux d'utilisation élevé dans les domaines industriels.

En termes de traitement distribué des transactions, go-zero utilise un mécanisme de compensation pour assurer la cohérence et la fiabilité des transactions. Le mécanisme dit de compensation signifie que si un service ne s'exécute pas pendant une opération, certaines opérations de compensation correspondantes doivent être effectuées pour garantir la cohérence et la récupérabilité de l'opération. Par exemple, une fois le paiement de la commande réussi, l'opération de déduction des stocks est impliquée. Si la déduction des stocks échoue, l'opération de paiement de la commande doit être annulée et le stock est compensé en même temps.

Lors de la mise en œuvre de transactions distribuées, il existe deux méthodes principales de mécanismes de compensation impliquées dans le go-zero, à savoir la compensation TCC et la compensation SAGA. Parmi eux, la compensation TCC est la mise en œuvre du protocole de soumission en trois étapes, c'est-à-dire le mode « Essayer-Confirmer-Annuler ». Le principe est d'effectuer des opérations actives de confirmation et d'annulation lors de la mise en œuvre des opérations commerciales. La compensation SAGA est un modèle de rémunération basé sur les événements, c'est-à-dire que les opérations ultérieures sont effectuées en envoyant des événements pendant l'exécution de l'entreprise.

Prenons l'exemple de la compensation TCC. Son processus général de mise en œuvre est le suivant :

1. L'entreprise lance une opération Try, c'est-à-dire effectue l'opération commerciale correspondante.

2. Une fois l'opération Try exécutée avec succès, l'entreprise lance l'opération Confirm, c'est-à-dire que le résultat de l'opération est soumis.

3. Si l'opération de confirmation réussit, le processus métier se termine.

4. Si l'opération de confirmation échoue, l'entreprise lance l'opération d'annulation, c'est-à-dire que l'opération est révoquée.

Grâce à ce modèle de soumission en trois phases, la cohérence des données entre les différents services dans un système distribué peut être assurée, résolvant ainsi le problème des transactions distribuées.

La mise en œuvre du mécanisme de compensation TCC en go-zero nécessite l'utilisation d'un cadre centralisé, c'est-à-dire les composants du cadre fournis avec go-zero. Dans le composant du cadre go-zero, la transaction TCC se compose de trois parties : les méthodes standard Try, Confirm et Cancel, et ces méthodes sont gérées uniformément via le centre d'enregistrement. La méthode spécifique d'implémentation est la suivante :

1. Définir l'interface métier et hériter de l'interface "go-zero/gateway/pkg/tcc.Tcc".

type DemoTcc interface {

tcc.Tcc
Try(ctx context.Context, req *logic.OrderLogic) error
Confirm(ctx context.Context, req *logic.OrderLogic) error
Cancel(ctx context.Context, req *logic.OrderLogic) error

}

2. Le framework génère automatiquement le code de service Tcc

$ goctl tcc demo

3. Écrivez le code de logique métier dans le répertoire servicehandler et implémentez les méthodes Try, Confirm et Cancel du. Interface Tcc.

func (s Service) Try(ctx context.Context, req logic.OrderLogic) erreur {

//执行业务逻辑

}

func (s Service) Confirm(ctx context.Context, req logic.OrderLogic) erreur {

//确认操作

}

func (s Service) Cancel(ctx context.Context, req logic.OrderLogic) erreur {

//取消操作

}

4. Enregistrez le service Tcc dans le framework.

//Register Tcc service demo
service.RegisterTccCompensateDemo(zrpc.MustNewClient(zrpc.RpcClientConf{

Name:       conf.ReorderService.Service.Name(),
Balancer:   conf.ReorderService.Service.Balancer,
Direct:     true,
Timeout:    time.Second,
Mode:       zrpc.BROADCAST,

}))

Grâce aux étapes ci-dessus, la mise en œuvre du mécanisme de compensation Tcc pour les transactions distribuées peut être complétée.

L'utilisation de go-zero pour mettre en œuvre facilement le traitement des transactions distribuées peut non seulement améliorer la maintenabilité et l'évolutivité du programme, mais également réduire considérablement les coûts de développement des développeurs et les difficultés de maintenance du système. En tant que l'un des frameworks de développement d'applications distribuées en langage Go les plus populaires, go-zero peut fournir un cadre de développement stable et un environnement de développement riche, et est devenu le premier choix de plus en plus de développeurs et d'entreprises.

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!