The Registry Pattern

Written by Lucas, on Thu 08 November 2007, 17:16:19

I often use several design patterns in my scripts, and this is one of my favorites: The registry pattern.

If you use a lot of classes, I bet you came around the problem you want to share an object with another class.

One solution is, to use the Singleton design pattern. But if you have a lot of classes, this is not really efficient. This is were the registry comes in. It's a class where you can store and retrieve variables.

To view an example, click the 'Read more' link.

The class I use for this site is the following:

Toggle highlightingCode
  1.  
  2. /**
  3.  * Registry Class
  4.  *
  5.  * Holds all objects, so the objects are accesible everywhere
  6.  */
  7. class Registry
  8. {
  9.     protected $values;
  10.     private static $instance;
  11.    
  12.     /**
  13.      * Singleton, returns the instance of this class
  14.      * @return Registry
  15.      */
  16.     public static function GetInstance()
  17.     {
  18.         if(self::$instance == null)
  19.         {
  20.             self::$instance = new Registry();
  21.         }
  22.        
  23.         return self::$instance;
  24.     }
  25.    
  26.     /**
  27.      * Private constructor for Singleton, inits some vars
  28.      */
  29.     private function __construct()
  30.     {
  31.         $this -> values = array();
  32.     }
  33.    
  34.     /**#@+
  35.      * Operator overloading functions
  36.      * */
  37.     public function __get($name)
  38.     {
  39.         if($this -> Exists($name))
  40.         {
  41.             return $this -> values[strtolower($name)];
  42.         }
  43.     }
  44.    
  45.     public function __set($name, $value)
  46.     {
  47.         $this -> Register($value, $name);
  48.     }
  49.    
  50.     public function __unset($name)
  51.     {
  52.         $this -> unregister($name);
  53.     }
  54.    
  55.     public function __isset($name)
  56.     {
  57.         return $this -> exists($name);
  58.     }
  59.     /**#@-*/
  60.    
  61.     /**
  62.      * Get a loaded class
  63.      * @param string $name The name from the class loaded, or a name you gave
  64.      * @return object
  65.      */
  66.     public function Retrieve($name)
  67.     {
  68.         if($this -> exists($name))
  69.         {
  70.             return $this -> values[strtolower($name)];
  71.         }
  72.         else
  73.         {
  74.             throw new Exception('Class '.$name.' does not exists');
  75.         }
  76.     }
  77.    
  78.     /**
  79.      * Register an object
  80.      * @param mixed $object The object to register
  81.      * @param string $name Optional, a custom name (default the class name)
  82.      */
  83.     public function Register($object, $name = '')
  84.     {
  85.         if(is_object($object))
  86.         {
  87.             if($name == '')
  88.             {
  89.                 $name = get_class($object);
  90.             }          
  91.         }
  92.        
  93.         $this -> values[strtolower($name)] = $object;
  94.     }
  95.    
  96.     /**
  97.      * Unregister an object
  98.      * @param string $name the class name
  99.      */
  100.     public function Unregister($name)
  101.     {
  102.         if(array_key_exists($name, $this -> values))
  103.         {
  104.             unset($this -> values[strtolower($name)]);
  105.         }
  106.     }
  107.    
  108.     /**
  109.      * Checks if a certain class is loaded
  110.      * @param string $name The class name
  111.      * @return bool
  112.      */
  113.     public function Exists($name)
  114.     {
  115.         return array_key_exists(strtolower($name), $this -> values);
  116.     }
  117. }   
  118.  


It's very simple: The class has one protected member, an array where all objects will be stored in.

The function Register is used for storing an object in the registry, the Unregister function is used for deleting an object.

And to retrieve an object, you can use the function Retrieve.

I also added some of the PHP operator overloading functions, so you can use:

Toggle highlightingCode
  1.  
  2. $registry -> member -> Call();
  3.  


instead of
Toggle highlightingCode
  1.  
  2. $object = $registry -> Retrieve('member');
  3. $object -> Call();
  4.  


Well, that's it for today.

Tag Tags: oop registry php design patterns
Comments (1)