Patrón Registry

Para esta entrada hablaremos un poco del Patrón de Diseño Registry,  y expondremos algunos de sus usos.

Primero veamos el código patrón:

/**
 * Registers objects and variables
 *
 * Makes objects and variables available to any level
 * of the application without having to keep track
 * of their existence.  Also useful for objects such
 * as database connectors that are used globaly and
 * not to be duplicated.
 *
 * PHP version 5
 */
 class registry
 {
     /**
      * Registry of variables and objects
      * @access private
      * @var array
      */
     static private $registry = array();
 
     /**
      * Adds an item to the registry
      * @access public
      * @param string item's unique name
      * @param mixed item
      * @return boolean
      */
     public function add($name, $item)
     {
         if (!self::exists($name)) {
             self::$registry[$name] = $item;
             return true;
         } else {
             return false;
         }
     }
 
     /**
      * Returns true if item is registered
      * @access public
      * @param string item's name
      * @return boolean
      */
     public function exists($name)
     {
         if (is_string($name)) {
             return array_key_exists($name, self::$registry);
         } else {
             throw new Exception('Registry item\'s name must be a string');
         }
     }
 
     /**
      * Returns registered item
      * @access public
      * @param string item's name
      * @return mixed (null if name is not in registry)
      */
     public function get($name)
     {
         if (self::exists($name)) {
             $return = self::$registry[$name];
         } else {
             $return = null;
         }
         return $return;
     }
 
     /**
      * Removes a registry entry
      * @access public
      * @param string item's name
      * @return boolean
      */
     public function remove($name)
     {
         if (self::exists($name)) {
             unset(self::$registry[$name]);
         }
         return true;
     }
 
     /**
      * Clears the entire registry
      * @access public
      * @return boolean
      */
     public function clear()
     {
         self::$registry = array();
     }
 }

Si nos fijamos es una clase estática  por lo que podemos acceder a sus métodos sin necesidad de instanciar la clase, dentro de sus métodos los principales son el método add()  y el método get(), mediante estos métodos vamos a llenar la instancia y a mostrar el resultado de la instancia, pero como lo hacemos?? Para crear un valor en el patrón registry usamos el método add este nos pide dos parámetros el primero es el nombre que va a llevar el valor y el segundo es el valor como tal de este veamoslo con un ejemplo:

registry::add('nombre','aca esta el valor que deseamos mostrar');

Sencillamente asignamos a nombre en  esta instancia el valor: aca esta el valor que deseamos mostrar, sencillo no y como utilizamos o se muestra el valor que acabamos de asignar?? Utilizando el método get(),  de esta manera:

echo registry::get('nombre');

El resultado nos mostraría por pantalla “aca esta el valor que deseamos mostrar”, fácil verdad?? Los demás métodos nos sirven para validación de que exista un índice, limpiar e incluso un quitar índice agregado mediante una llamada a este patrón, fácil verdad??

Que nos permite hacer el Patrón Registry??

Sencillamente nos permite mantener y modificar valores e instancias entre clases diferentes e incluso fuera de las mismas (es un concepto personal si alguien tiene objeción la puede realizar y así aprendemos más), a medida que veamos el código se entenderá mas este pequeño concepto,  un pequeño ejemplo:

a.php

class a
{
  public function llenar($valor)
 {
  registry::add('indice',$valor);
 }
}

b.php

class b
{  
 public function mostrar()
 {
  echo registry::get('indice');
 }
}

Index.php

require_once("registry.php");
require_once("a.php");
require_once("b.php");

 $a = new a();
 $b = new b();
 $a->llenar("hola");
 $b->mostrar(); 

Si se fijan en la primera clase asignamos a nuestro patrón registry un valor, en la segunda clase sencillamente mostramos el valor del índice que llenamos en la primera clase sencillo su uso no?? Veamos ahora los demás métodos en acción

b.php

class b
 {  
 public function mostrar($indice)
 {
  if(registry::exists($indice)){
   echo registry::get('indice');
  } 
  else{
   echo "El valor buscado no existe";
  }
 }
 }

re-declaramos la clase b para utilizar más métodos de nuestro patrón registry
index.php

$a = new a();
 $b = new b();
 $a->leer("hola");
 $b->mostrar('indice');
 registry::remove('indice');
 $b->mostrar('indice'); 

Si se fijan usamos el método exists para realizar una validación, y usamos el método remove para eliminar un índice que ya no necesitamos que pasaría si ejecutáramos el código expuesto??  El resultado seria “holaEl valor buscado no existe”, aunque las dos veces la función mostrar indico el mismo “índice“ no nos dio el mismo resultado, esto se debe a que utilizamos el método remove para eliminar un índice que no era más necesario, al volverlo a llamar este no existía y por eso en la validación nos mostró el mensaje de que no existe.

El patrón registry tiene muchos usos, uno de ellos puede ser una clase para conexión, en ese caso especial lo que hace el patrón registry es que solo obtengamos una instancia para un manejador de base de datos, pero a su vez podamos instanciar la clase con otro tipo de manejador.

Espero que el artículo sea de agrado y que haya logrado transmitir su funcionalidad, como siempre digo cualquier crítica o sugerencia es aceptada, hasta una próxima oportunidad saludos.