mécanisme de signal de signaux dans le framework Flask de Python

Flask fournit la fonction de signal, qui est un mécanisme de distribution de messages. Semblable aux crochets. L'utilisation de fonctions de signal peut réduire le couplage de programmes et décomposer des modèles commerciaux complexes. Par exemple, après la mise à jour des données produit, un signal peut être envoyé. Lorsqu'une fonction doit traiter les données du produit, le signal peut être capturé pour le traitement. Par exemple, vous devez créer un cache produit, ou mettre à jour l'index de recherche, etc.

Définir les signaux

La fonction de signal Flask utilise le module Blinker, vous devez donc d'abord installer le module Blinker

pip install blinker

Définir un signal :

from blinker import Namespace
product_saved = Namespace()

Vous pouvez également utiliser l'objet singles packagé par Flask :

from flask.singles import Namespace

Envoyer un signal

L'envoi d'un signal nécessite la méthode d'instance d'application, l'exemple est le suivant :

product_saved.send(app, product=product)

Les paramètres à transmettre peuvent être ajoutés ultérieurement dans l'application, mais ils doivent être au format nom=valeur. n’est pas pris en charge.

Recevoir le signal

Pour recevoir le signal, vous pouvez utiliser la fonction décorateur connect_via :

@product_saved.connect_via(app)
def updateCache(app, product):
  print(product)

Il y a les signaux de base suivants dans Flask :

1.flask.template_rended

Ce signal est envoyé une fois qu'un modèle est réussi rendu. Le modèle transmis par le signal est une instance du modèle et le contexte est un objet d'environnement qui est un dictionnaire.

Exemple d'abonnement :

def log_template_renders(sender, template, context, **extra):
  sender.logger.debug('Rendering template "%s" with context %s',
            template.name or 'string template',
            context)
from flask import template_rendered
template_rendered.connect(log_template_renders, app)

2.flask.request_started

Ce signal est envoyé Avant le début de la requête et après la configuration de l'environnement de requête. Le contexte de la demande étant déjà lié, les abonnés peuvent utiliser des proxys globaux standard tels que request pour traiter les demandes.

Exemple d'abonnement :

def log_request(sender, **extra):
  sender.logger.debug('Request context is set up')
from flask import request_started
request_started.connect(log_request, app)
flask.request_finished

Ce signal est envoyé avant l'envoi d'une réponse au client. La réponse transmise par le signal est la réponse à envoyer.

Exemple d'abonnement :

def log_response(sender, response, **extra):
  sender.logger.debug('Request context is about to close down. '
            'Response: %s', response)
from flask import request_finished
request_finished.connect(log_response, app)
flask.got_request_exception

Ce signal est envoyé lorsqu'une exception se produit lors de la requête. Il est envoyé plus tôt que la gestion standard des exceptions. En mode débogage, bien qu'il n'y ait pas de gestion des exceptions, ce signal est également envoyé lorsqu'une exception se produit. L'exception transmise par le signal est l'objet exception.

Exemple d'abonnement :

def log_exception(sender, exception, **extra):
  sender.logger.debug('Got exception during processing: %s', exception)
from flask import got_request_exception
got_request_exception.connect(log_exception, app)
flask.request_tearing_down

Ce signal est envoyé lorsque la requête plante, qu'une exception soit déclenchée ou non. Actuellement, la fonction qui écoute ce signal est appelée après le gestionnaire de crash général, mais rien n'est disponible.

Exemple d'abonnement :

def close_db_connection(sender, **extra):
  session.close()from flask import appcontext_tearing_down
request_tearing_down.connect(close_db_connection, app)

Dans la version Flask 0.9, cela transmettra également un argument de mot-clé exc s'il existe des mots. Ce paramètre est une référence à l'exception qui a provoqué le crash.

3.flask.appcontext_tearing_down

Envoyer ce signal lorsque l'environnement de l'application plante. Ce signal est toujours envoyé, même en cas de crash provoqué par une exception. Les fonctions écoutant ce signal seront appelées après le gestionnaire de crash habituel, mais vous ne pouvez pas répondre à ce signal.

Exemple d'abonnement :

def close_db_connection(sender, **extra):
  session.close()from flask import request_tearing_down
appcontext_tearing_down.connect(close_db_connection, app)

Cela transmettra également un argument de mot-clé exc, s'il en existe un. Ce paramètre est une référence à l'exception qui a provoqué le crash.

4.flask.appcontext_pushed

Lorsque le contexte d'une application est poussé, l'application envoie ce signal. Ce signal est généralement utilisé dans les tests unitaires pour capter temporairement des informations. Par exemple, il peut être utilisé pour modifier les ressources existantes dans l'objet g.

Exemple d'utilisation :

from contextlib import contextmanagerfrom
flask import appcontext_pushed
@contextmanagerdef user_set(app, user):
  def handler(sender, **kwargs):
    g.user = user
  with appcontext_pushed.connected_to(handler, app):
    yield

Écrivez comme ceci dans le code de test :

def test_user_me(self):
  with user_set(app, 'john'):
    c = app.test_client()
    resp = c.get('/users/me')
    assert resp.data == 'username=john'
New in version 0.10.

5.appcontext_popped

Lorsque le contexte d'une application est affiché, l'application envoie ce signal. Ce signal est généralement écrit sous la forme de signal appcontext_teearing_down.

6.flask.message_flashed

Ce signal est émis lorsque l'application fait clignoter un message. Le paramètre message` est le contenu du message et le paramètrecategory est la catégorie du message.

Exemple d'abonnement :

recorded = []def record(sender, message, category, **extra):
  recorded.append((message, category))
from flask import message_flashed
message_flashed.connect(record, app)

Résumé

Les signaux peuvent vous y amener dans un flash Abonnez-vous en toute sécurité. Ces abonnements temporaires sont utiles pour tester par exemple. Lorsque vous utilisez des signaux, ne laissez pas d'exceptions se produire chez les abonnés au signal (récepteurs), car les exceptions entraîneraient une interruption du programme.

Pour plus d'articles liés au mécanisme de signal dans le framework Python Flask, veuillez faire attention au site Web PHP chinois !