Zend Framework - Administrador de eventos

Todas las aplicaciones modernas necesitan componentes de eventos sólidos y flexibles. Zend Framework proporciona uno de esos componentes,zend-eventmanager. El zend-eventmanager ayuda a diseñar una arquitectura de alto nivel y admite el patrón sujeto / observador y la programación orientada a aspectos.

Instalar Event Manager

El administrador de eventos se puede instalar usando el Composer como se especifica a continuación -

composer require zendframework/zend-eventmanager

Conceptos del administrador de eventos

Los conceptos centrales del administrador de eventos son los siguientes:

Event - El evento se denomina acción arbitrariamente, digamos greet.
Listener- Cualquier devolución de llamada de PHP. Se adjuntan a los eventos y se llaman cuando se activa el evento. La firma predeterminada de Listener es:

function(EventInterface $e)

EventInterface Class- Se utiliza para especificar el evento en sí. Tiene métodos para configurar y obtener información de eventos como nombre (set / getName), target (get / setTarget) y parámetro (get / setParams).
EventManager class- La instancia de EventManager rastrea todos los eventos definidos en una aplicación y sus correspondientes oyentes. EventManager proporciona un método,attach para adjuntar un oyente a un evento y proporciona un método, triggerpara activar cualquier evento predefinido. Una vez que se llama al disparador, EventManager llama al oyente adjunto.
EventManagerAwareInterface- Para que una clase admita la programación basada en eventos, debe implementar EventManagerAwareInterface. Proporciona dos métodos,setEventManager y getEventManager para obtener y configurar el administrador de eventos.

Ejemplo

Escribamos una aplicación de consola PHP simple para comprender el concepto de administrador de eventos. Siga los pasos que se indican a continuación.

Cree una carpeta "eventapp".
Instalar en pc zend-eventmanager usando el compositor.
Crea un archivo PHP Greeter.php dentro de la carpeta "eventapp".
Crear clase Greeter e implementar el EventManagerAwareInterface.

require __DIR__ . '/vendor/autoload.php'; 
class Greeter implements EventManagerAwareInterface { 
   // code 
}

Aquí, require se utiliza para cargar automáticamente todos los componentes instalados en Composer.

Escribe el setEventManager método en clase Greeter como se muestra a continuación -

public function setEventManager(EventManagerInterface $events) { 
   $events->setIdentifiers([ __CLASS__, get_called_class(),]); 
   $this->events = $events; 
   return $this; 
}

Este método establece la clase actual en el administrador de eventos dado (argumento $ events) y luego establece el administrador de eventos en la variable local $events.

El siguiente paso es escribir el getEventManager método en clase Greeter como se muestra a continuación -

public function getEventManager() { 
   if (null === $this->events) { 
      $this->setEventManager(new EventManager()); 
   } 
   return $this->events; 
}

El método obtiene el administrador de eventos de una variable local. si no está disponible, crea una instancia de administrador de eventos y la devuelve.

Escribe un método greet, en la clase Greeter.

public function greet($message) { 
   printf("\"%s\" from class\n", $message); 
   $this->getEventManager()->trigger(__FUNCTION__, $this, $message ]); 
}

Este método obtiene el administrador de eventos y activa / activa eventos adjuntos a él.

El siguiente paso es crear una instancia del Greeter class y adjuntar un oyente a su método, greet.

$greeter = new Greeter();  
$greeter->getEventManager()->attach('greet', function($e) { 
   $event_name = $e->getName(); 
   $target_name = get_class($e->getTarget()); 
   $params_json = json_encode($e->getParams());  
   printf("\"%s\" event of class \"%s\" is called." . 
      " The parameter supplied is %s\n",  
      $event_name,  
      $target_name,  
      $params_json); 
});

La devolución de llamada del oyente simplemente imprime el nombre del evento, el objetivo y los parámetros proporcionados.

La lista completa de Greeter.php es como sigue -

<?php  
require __DIR__ . '/vendor/autoload.php';  

use Zend\EventManager\EventManagerInterface; 
use Zend\EventManager\EventManager; 
use Zend\EventManager\EventManagerAwareInterface; 

class Greeter implements EventManagerAwareInterface { 
   protected $events;
   public function setEventManager(EventManagerInterface $events) { 
      $events->setIdentifiers([__CLASS__, get_called_class(), ]); 
      $this->events = $events; 
      return $this; 
   }  
   public function getEventManager() { 
      if (null === $this->events) { 
         $this->setEventManager(new EventManager()); 
      } 
      return $this->events; 
   } 
   public function greet($message) { 
      printf("\"%s\" from class\n", $message); 
      $this->getEventManager()->trigger(__FUNCTION__, $this, [$message ]); 
   } 
} 

$greeter = new Greeter(); 
$greeter->greet("Hello");  
$greeter->getEventManager()->attach('greet', function($e) { 
   $event_name = $e->getName(); 
   $target_name = get_class($e->getTarget()); 
   $params_json = json_encode($e->getParams()); 
   printf("\"%s\" event of class \"%s\" is called." . " The parameter supplied is %s\n",
      $event_name,
      $target_name,  
      $params_json); 
});  
$greeter->greet("Hello");

Ahora, ejecute la aplicación en el símbolo del sistema php Greeter.php y el resultado será el siguiente:

"Hello" from class 
"Hello" from class 
"greet" event of class "Greeter" is called. The parameter supplied is ["Hello"]

La aplicación de muestra anterior explica solo los conceptos básicos de un administrador de eventos. El administrador de eventos ofrece muchas opciones más avanzadas, comoListener Priority, Custom Callback Prototype / Signature, Short Circuiting, etc. El administrador de eventos se utiliza ampliamente en el marco Zend MVC.