• Mo
  • Di
  • Mi
  • Do
  • Fr
  • Sa
  • So
  •  
  •  
  •  
  •  
  •  
  •  
  • 01
  • 02
  • 03
  • 04
  • 05
  • 06
  • 07
  • 08
  • 09
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  •  
  •  
  •  
  •  
  •  




Das Registry Pattern


Um aus verschiedenen Klassen oder Funktionen auf "globale" Objekte und Variablen zuzugreifen, gibt es das Registry-Entwurfsmuster, man trifft es sehr häufig neben dem Singleton Pattern.
Eine Registry ist streng gesehen nur eine Verschiebung des globalen Gültigkeitsbereiches.
Die Registry kann als abstract deklariert werden, da nur statische Attribute und Methoden verwendet werden.


so zu erst die Klasse/n

Variante mit Exceptions


PHP CODE
  1. abstract class Registry
  2. {
  3.     /**
  4.     * Object registry provides storage for shared objects
  5.     *
  6.     * @var array 
  7.     */
  8.     private static $_registry = array();
  9.  
  10.     /**
  11.     * Adds a new variable to the Registry.
  12.     *
  13.     * @param string $key Name of the variable
  14.     * @param mixed $value Value of the variable
  15.     * @throws Exception
  16.     * @return boolean
  17.     */
  18.     public static function set( $key, $value ) {
  19.         if ( !self::has($key) ) {
  20.             self::$_registry[$key] = $value;
  21.             return true;
  22.         } 
  23.         else {
  24.             throw new Exception( 'Unable to set variable `' . $key . '`. It was already set.' );
  25.         }
  26.     }
  27.  
  28.     /**
  29.     * Adds a new variables from an array to the Registry.
  30.     *
  31.     * @param array $array The list of variabls
  32.     * @throws Exception
  33.     * @return boolean
  34.     */
  35.     public static function setFromArray( array $array = null ) {
  36.  
  37.         if ( !empty( $array ) ) {
  38.             foreach( $array as $key => $value ) {
  39.                 self::set( $key, $value );
  40.             }
  41.             return true;
  42.         }
  43.         else {
  44.             throw new Exception( 'Array of Variabls was empty.' );
  45.         }
  46.     }
  47.  
  48.     /**
  49.     * change a variable to the Registry.
  50.     *
  51.     * @param string $key Name of the variable
  52.     * @param mixed $value Value of the variable
  53.     * @throws Exception
  54.     * @return boolean 
  55.     */
  56.     public static function change( $key, $value ) {
  57.         if ( self::has($key) ) {
  58.             self::$_registry[$key] = $value;
  59.             return true;
  60.         } 
  61.         else {
  62.             throw new Exception( 'Unable to change variable `' . $key . '`. It was not set.' );
  63.         }
  64.     }
  65.  
  66.     /**
  67.     * Tests if given $key exists in registry
  68.     *
  69.     * @param string $key
  70.     * @return boolean
  71.     */
  72.     public static function has( $key ) {
  73.         return isset( self::$_registry[$key] );
  74.     }
  75.  
  76.     /**
  77.     * Returns the value of the specified $key in the Registry.
  78.     *
  79.     * @param string $key Name of the variable
  80.     * @return mixed Value of the specified $key
  81.     */
  82.     public static function get( $key )  {
  83.         if ( self::has( $key ) ) {
  84.             return self::$_registry[$key];
  85.         }
  86.         return null;
  87.     }
  88.  
  89.     /**
  90.     * Returns the whole Registry as an array.
  91.     *
  92.     * @return array Whole Registry
  93.     */
  94.     public static function getAll() {
  95.         return self::$_registry;
  96.     }
  97.  
  98.     /**
  99.     * Removes a variable from the Registry.
  100.     *
  101.     * @param string $key Name of the variable
  102.     * @return boolean
  103.     */
  104.     public static function remove( $key ) {
  105.         if ( self::has( $key ) ) {
  106.             unset( self::$_registry[$key] );
  107.             return true;
  108.         }
  109.         return false;
  110.     }
  111.  
  112.     /**
  113.     * Removes all variables from the Registry.
  114.     *
  115.     * @return boolean
  116.     */
  117.     public static function removeAll() {
  118.         self::$_registry = array();
  119.         return true;
  120.     }
  121.  
  122.     /**
  123.     * Gets the number ob variables in the Registry
  124.     *
  125.     * @return integer
  126.     */
  127.     public static function size() {
  128.         return sizeof( self::$_registry );
  129.     }
  130.  
  131. }


Variante 2 ohne Exceptions



PHP CODE
  1. abstract class Registry
  2. {
  3.     /**
  4.     * Object registry provides storage for shared objects
  5.     *
  6.     * @var array 
  7.     */
  8.     private static $_registry = array();
  9.  
  10.     /**
  11.     * Adds a new variable to the Registry.
  12.     *
  13.     * @param string $key Name of the variable
  14.     * @param mixed $value Value of the variable
  15.     * @throws Exception
  16.     * @return boolean
  17.     */
  18.     public static function set( $key, $value ) {
  19.         if ( !self::has($key) ) {
  20.             self::$_registry[$key] = $value;
  21.             return true;
  22.         } 
  23.         else {
  24.             echo 'Unable to set variable `' . $key . '`. It was already set.';
  25.             exit;
  26.         }
  27.     }
  28.  
  29.     /**
  30.     * Adds a new variables from an array to the Registry.
  31.     *
  32.     * @param array $array The list of variabls
  33.     * @throws Exception
  34.     * @return boolean
  35.     */
  36.     public static function setFromArray( array $array = null ) {
  37.  
  38.         if ( !empty( $array ) ) {
  39.             foreach( $array as $key => $value ) {
  40.                 self::set( $key, $value );
  41.             }
  42.             return true;
  43.         }
  44.         else {
  45.             echo 'Array of Variabls was empty.';
  46.             exit;
  47.         }
  48.     }
  49.  
  50.     /**
  51.     * change a variable to the Registry.
  52.     *
  53.     * @param string $key Name of the variable
  54.     * @param mixed $value Value of the variable
  55.     * @throws Exception
  56.     * @return boolean 
  57.     */
  58.     public static function change( $key, $value ) {
  59.         if ( self::has($key) ) {
  60.             self::$_registry[$key] = $value;
  61.             return true;
  62.         } 
  63.         else {
  64.             echo 'Unable to change variable `' . $key . '`. It was not set.' ;
  65.             exit;
  66.         }
  67.     }
  68.  
  69.     /**
  70.     * Tests if given $key exists in registry
  71.     *
  72.     * @param string $key
  73.     * @return boolean
  74.     */
  75.     public static function has( $key ) {
  76.         return isset( self::$_registry[$key] );
  77.     }
  78.  
  79.     /**
  80.     * Returns the value of the specified $key in the Registry.
  81.     *
  82.     * @param string $key Name of the variable
  83.     * @return mixed Value of the specified $key
  84.     */
  85.     public static function get( $key )  {
  86.         if ( self::has( $key ) ) {
  87.             return self::$_registry[$key];
  88.         }
  89.         return null;
  90.     }
  91.  
  92.     /**
  93.     * Returns the whole Registry as an array.
  94.     *
  95.     * @return array Whole Registry
  96.     */
  97.     public static function getAll() {
  98.         return self::$_registry;
  99.     }
  100.  
  101.     /**
  102.     * Removes a variable from the Registry.
  103.     *
  104.     * @param string $key Name of the variable
  105.     * @return boolean
  106.     */
  107.     public static function remove( $key ) {
  108.         if ( self::has( $key ) ) {
  109.             unset( self::$_registry[$key] );
  110.             return true;
  111.         }
  112.         return false;
  113.     }
  114.  
  115.     /**
  116.     * Removes all variables from the Registry.
  117.     *
  118.     * @return boolean
  119.     */
  120.     public static function removeAll() {
  121.         self::$_registry = array();
  122.         return true;
  123.     }
  124.  
  125.     /**
  126.     * Gets the number ob variables in the Registry
  127.     *
  128.     * @return integer
  129.     */
  130.     public static function size() {
  131.         return sizeof( self::$_registry );
  132.     }
  133.  
  134. }


Welche Variante ihr benutzt liegt an euch solltet ihr aber die Exceptions Variante nutze bedenkt die Exceptions auf zufangen mit

Auffangen der Exeptions mit der Exception Variante


PHP CODE
  1. try {
  2.     // ausführen von Registry::set( $key, $value ); 
  3.     // oder von Registry::setFromArray( array( 'val1' => 'abc' ) );
  4.     // oder von Registry::change( $key, $value );
  5. }
  6. catch ( Exception $e ) {
  7.     echo $e->getMessage();
  8.     $traceArray = $e->getTrace();
  9.     // macht was ihr wollt mit dem Trace ;) :D
  10. }


File ambesten speichern als class.Registry.php

Der include der Klasse


PHP CODE
  1. include( 'path_to_class' . DIRECTORY_SEPARATOR . 'class.Registry.php' );


um die Klasse zu nutzen geht man wie folgt vor

Eine Variable in die Registry schreiben


PHP CODE
  1. Registry::set( 'test', 'Ich bin ueberall verfuegbar.' );


Variable aus einem Array in die Registry schreiben


PHP CODE
  1. $array = array( 'value1' => 'ich', 'vaule2' => 'du' );
  2. Registry::setFromArray( $array );


Eine Variable aus der Registry lesen


PHP CODE
  1. $test = Registry::get( 'test' ); // Output: ich bin ueberall verfuegbar.
  2. echo $test;


Alle Variablen aus der Registry als array geben lasse


PHP CODE
  1. $all = Registry::getAll(); 


Eine Variable aus der Registry entfernen


PHP CODE
  1. Registry::remove( 'test' );


Alle Variablen aus der Registry entfernen


PHP CODE
  1. Registry::removeAll();


Eine Variable aus der Registry ändern


PHP CODE
  1. Registry::change( 'test', 'ich bin immer noch ueberall verfuegbar' );


Prüfen ob eine Variable in der Registry gesetzt ist


PHP CODE
  1. Registry::has( 'test' );


Die Anzahl aller Variablen aus der Rigistry geben lassen


PHP CODE
  1. $registrySite = Registry::size();
  2. echo $registrySize;


Das Registry Pattern läst sich wunderbar mit den Singleton Pattern Verbinden

PHP CODE
  1. class singletonExample
  2. {
  3.     ......
  4.  
  5.     // Singleton instance
  6.     public static function getInstance()
  7.     {
  8.         if ( Registry::has( 'singletonExample' ) === false ) {
  9.             Registry::set( 'singletonExample', new self() );
  10.         }
  11.  
  12.         return Registry::get('singletonExample');
  13.     }
  14.  
  15.     ......
  16. }

Änliche Beiträge

Diesen Beitrag teilen

RSS-Feed  auf Twitter.com teilen  auf delicious.com teilen  auf Digg.com teilen   auf Facebook.com teilen


Kommentare
noch keine Kommentare vorhanden