Maison > développement back-end > Golang > le corps du texte

Comment implémenter la diffusion serveur-client dans gRPC ?

Barbara Streisand
Libérer: 2024-11-02 02:45:30
original
800 Les gens l'ont consulté

How to Implement Server to Client Broadcasting in gRPC?

Diffusion dans gRPC : communication serveur-client

Lors de l'établissement d'une connexion gRPC, il est souvent nécessaire de diffuser des événements ou des mises à jour depuis le serveur vers clients connectés. Pour y parvenir, diverses approches peuvent être utilisées.

Stream Observables

Une approche courante consiste à utiliser des flux côté serveur. Chaque client connecté établit son propre flux avec le serveur. Cependant, il n'est pas possible de s'abonner directement à d'autres flux serveur-client.

Polling long

Une option alternative consiste à mettre en œuvre une approche d'interrogation longue. Cela implique que les clients interrogent continuellement le serveur à intervalles réguliers, recherchant de nouvelles mises à jour. Dès réception d'une mise à jour, le client recevra une réponse et attendra le prochain intervalle d'interrogation.

Exemple de mise en œuvre

Voici un exemple de la façon dont vous pourriez mettre en œuvre une interrogation longue en utilisant gRPC :

Code côté serveur

<code class="python">import threading

class UpdaterServer:
    def __init__(self):
        self.condition = threading.Condition()
        self.updates = []

    def post_update(self, update):
        with self.condition:
            self.updates.append(updates)
            self.condition.notify_all()

    def GetUpdates(self, req, context):
        with self.condition:
            while self.updates[req.last_received_update + 1:] == []:
                self.condition.wait()
            new_updates = self.updates[req.last_received_update + 1:]
            return GetUpdatesResponse(
                updates=new_updates,
                update_index=req.last_received_update + len(new_updates),
            )</code>
Copier après la connexion

Code côté client (thème séparé)

<code class="python">from threading import Event

def handle_updates(updates):
    pass

event = Event()
request = GetUpdatesRequest(last_received_update=-1)

while not event.is_set():
    try:
        stub = UpdaterStub(channel)
        response = stub.GetUpdates(request, timeout=60*10)
        handle_updates(response.updates)
        request.last_received_update = response.update_index
    except grpc.FutureTimeoutError:
        pass</code>
Copier après la connexion

En mettant en œuvre cette approche, les clients connectés peuvent récupérer les mises à jour du serveur de manière continue.

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!