Français
Français
L'architecture axée sur les événements est une méthode de découplage commune lors de la construction d'applications PHP modernes. Vous pouvez définir des événements pour certaines opérations du système, puis l'auditeur répond à ces événements. Dans un scénario où plusieurs types d'événements partagent les auditeurs, comment déterminez-vous élégamment si un auditeur devrait gérer un événement? C'est exactement là que la fonction is_a () peut montrer ses compétences.
Cet article montrera comment implémenter un mécanisme de distribution basé sur des événements à l'aide de la fonction IS_A () afin que l'auditeur ne gère que le type d'événements qu'il "se soucie".
Tout d'abord, nous définissons une interface d'événements de base et plusieurs événements spécifiques:
interface EventInterface {}
class UserRegisteredEvent implements EventInterface {
public string $username;
public function __construct(string $username) {
$this->username = $username;
}
}
class OrderPlacedEvent implements EventInterface {
public int $orderId;
public function __construct(int $orderId) {
$this->orderId = $orderId;
}
}
Ensuite, nous définissons l'interface de l'écoute et un auditeur spécifique:
interface EventListenerInterface {
public function handle(EventInterface $event): void;
public function isInterestedIn(EventInterface $event): bool;
}
class SendWelcomeEmailListener implements EventListenerInterface {
public function handle(EventInterface $event): void {
if (!$event instanceof UserRegisteredEvent) return;
// Supposons que voici la logique de l'envoi de courriels
echo "Envoyez un e-mail de bienvenue à l'utilisateur：{$event->username}\n";
}
public function isInterestedIn(EventInterface $event): bool {
return is_a($event, UserRegisteredEvent::class);
}
}
La méthode IserteredIn () est l'endroit que nous utilisons pour porter des jugements de type. Il utilise IS_A () pour déterminer si l'événement entrant est le type d'intérêt pour l'auditeur.
Ensuite, nous mettons en œuvre un distributeur d'événements simples qui itère via tous les auditeurs et appelle l'auditeur qui répond aux critères.
class EventDispatcher {
/**
* @var EventListenerInterface[]
*/
private array $listeners = [];
public function addListener(EventListenerInterface $listener): void {
$this->listeners[] = $listener;
}
public function dispatch(EventInterface $event): void {
foreach ($this->listeners as $listener) {
if ($listener->isInterestedIn($event)) {
$listener->handle($event);
}
}
}
}
Maintenant, nous pouvons utiliser ce distributeur comme ceci:
$dispatcher = new EventDispatcher();
$dispatcher->addListener(new SendWelcomeEmailListener());
$userEvent = new UserRegisteredEvent('Alice');
$orderEvent = new OrderPlacedEvent(1001);
$dispatcher->dispatch($userEvent);
// Sortir：Envoyez un e-mail de bienvenue à l'utilisateur：Alice
$dispatcher->dispatch($orderEvent);
// 没有Sortir，Parce que l'auditeur est OrderPlacedEvent Pas intéressé
L'utilisation de la fonction is_a () présente les avantages suivants:
Sémantique claire : il illustre directement que vous jugez le type.
Soutenir l'héritage : vous pouvez déterminer si un objet est une instance d'une classe ou de sa sous-classe, qui est très adapté à la gestion des structures d'événements polymorphes.
Flexibilité élevée : il peut facilement prendre en charge plusieurs auditeurs pour écouter différents types d'événements, il suffit de modifier la méthode iSinteredIn () .
Dans les projets réels, vous voudrez peut-être que l'auditeur déclare le type d'événement qui vous intéresse par la configuration. À l'heure actuelle, vous pouvez enregistrer le nom de classe d'événements en tant que chaîne dans l'auditeur, puis le comparer avec IS_A () :
class DynamicListener implements EventListenerInterface {
private string $interestedClass;
public function __construct(string $interestedClass) {
$this->interestedClass = $interestedClass;
}
public function handle(EventInterface $event): void {
echo "Gérer les événements：" . get_class($event) . "\n";
}
public function isInterestedIn(EventInterface $event): bool {
return is_a($event, $this->interestedClass);
}
}
Vous pouvez maintenant enregistrer les auditeurs dynamiquement, par exemple:
$dispatcher->addListener(new DynamicListener(UserRegisteredEvent::class));
$dispatcher->addListener(new DynamicListener(OrderPlacedEvent::class));
Grâce à la fonction is_a () , nous pouvons implémenter gracieusement la logique de jugement de type de l'auditeur d'événements. Il fournit un mécanisme de filtrage d'événements clair et flexible pour les systèmes pilotés par des événements, en particulier adaptés aux scénarios de distribution de type multi-événements. Lors de la construction de systèmes complexes, ce modèle peut efficacement découpler la logique commerciale et améliorer la maintenabilité et l'évolutivité du système.
