{ BlogMania }

Every PHP developer must have heard of Design Patterns, but it all comes to benefit when actually using it efficiently. This time let me try to explain it in more on assignment type documentation

Goal

The goal of this post is how to (efficiently) use the PHP Design Patterns, particularly Factory pattern and Singleton pattern as of this tutorial.

Basics

Factory Pattern

As the name suggest, factory pattern is responsible for manufacturing items (objects in most cases) at run-time environment. The keyword run-time is very important here since all the resources allocation will be done at script execution time and not at compile time

Nothing is better way than example to learn coding

if( !class_exists ( $class))
{
     $splitClass = explode('_', $class);
     switch ( $count = count ( $splitClass) )
     {
          case ($count == 1) :
               require_once __PATH_TO_CLASSES . $class;
               break;
          case ($count >= 2) :
               $path = str_replace('_', '/', $class);
               require_once __PATH_TO_MODEL . $path;
               break;
          default :
               require_once __PATH_TO_CLASSES . $class;
     }
     return new $class();
}

I will explain this example in details later on while we merge both code of factory and singleton pattern…. stay tuned

Singleton Pattern

This is one of my favorite and far simplest pattern available in PHP. The basic idea is to have only one connection/link available from the same resource for multiple consumers. This pattern is being used to optimize the resource allocation and speedup the process. The very common example would be database connection because many components of our code are using database pretty frequently, it is necessary to optimize the database connection. That means no matter how many functions will call the same database connection, our code should be smart enough to return the first opened connection until we explicitly close it. Little in more detail, we don’t want database connection function to return a new connection every time someone call the connect method.

Basic idea is create a separate class for singleton method and declare a private constructor so no one outside the class can directly instantiate the class. Second most important thing is declare private static class variable that will hold the instance of the requested object/class. Furthermore, we need a method/function (usually getInstance()) that will be responsible for all the transaction for new class/object. Let’s take an example again

class Singleton
{
      private static $__instances = array();     // instance holder array
      private static $__instance;                // return variable

      private function __construct()
      {
            echo '';
      }

      /**
       * Singleton implementation for any class
       *
       * @param <string> $class
       * @return <object> $__instance - return by reference
       **/
       public static function &getInstance( $class )
       {
           if ( !isset(self::$__instances[ $class ]))
           {
                require_once 'path/to/' . $class;      // include file
                self::$__instances[ $class ] = new $class ();
                self::$__instance = & self::$__instances[ $class ];
           }
           return self::$__instance;
      }

      public function __clone()
      {
           error_log ('Oo Oo .... cloning not allowed in singleton');
      }
}

As seen from the example above, whoever tries to call the function getInstance, it will first check whether the instance is already created or not. If the instance is not created  then it will create new instance of the class and store it in the holder array and if the instance is already created it will return the already created instance. Note we are using the `Return by Reference` here so it doesn’t matter wherever the class file is we create an instance of it and pass the address of the constructor of that class . To know more about return by reference see here.

Implementation

So now you might have got some idea about both the patterns and how they works. The fun part is still missing !!!. Remember we want maximum efficiency and code re-usability to achieve maximum performance at run-time. Let’s combine both the pattern and see how it works in real world. The example below is for general classes, i.e. singleton function for universal classes, so no matter what class you want to instantiate this example will take care of it. It combines all two code samples described earlier and some more interesting stuffs, so there we go

class Singleton
{
     private static $__instances = array();
     private static $__instance;

     /**
     * Singleton implementation for any class
     *
     * @param <string> $class
     * @return <object> $__instance - return by reference
     */

     public static function &getInstance( $class /* ,arg1, arg2 .... */)
     {
          if( array_key_exists ( $class, self::$__instances ))
          {
               self::$__instance = &self::$__instances[ $class ];
          }
          else
          {
               if( !class_exists ( $class))
               {
                    $splitClass = explode('_', $class);

                    switch ( $count = count ( $splitClass) )
                    {
                         case ($count == 1) :
                              require_once __PATH_TO_CLASSES . $class;
                              break;
                         case ($count >= 2) :
                              $path = str_replace('_', '/', $class) . '.php';
                              require_once __PATH_TO_MODEL . $path;
                              break;
                         default :
                              require_once __PATH_TO_CLASSES . $class;
                    }
               }

               $fullArguments = func_get_args();
               $shifted = array_shift($fullArguments);

               $argList = (func_num_args() - 1) > 0
                     ? implode(',', $fullArguments)
                     : NULL
               ;

               self::$__instances[ $class ] = &new $class( $argList);
               self::$__instance = &self::$__instances[ $class ];
          }

          return self::$__instance;
     }
}

This example is smart enough to take care of variable number of arguments passed to class constructor. So you can instantiate any class with variable number of arguments like

 $object = &Singleton::getInstance('ClassName', arg1, arg2, arg3 .... argn)   

The getInstance() method returns by reference so we have to call the function by reference (using & operator). Below are some examples you can do with this method

     $obj = &Singleton::getInstance('Database', $schema = 'live');
     $obj = &Singleton::getInstance('Database', $schema = 'staging');
     $obj = &Singleton::getInstance('Database', $schema = 'dev');
                              OR
     $obj = &Singleton::getInstance('Database', $host, $db, $user, $pass);
     $obj = &Singleton::getInstance('Swap', $a, $b);

Now let’s take a look at the class Singleton. The class first declared two private static class variables $__instances and $__instance. $__instances is an array that would hold different class instances as a key pair value while $__instance is static variable that would return the current requested instance. Right after, there is a check for whether the class is already initialized or not. If the class is already initialized it would be stored in a variable $__instances with class name as a key and instance as a value. If the class is not yet instantiated the function first looks whether the class exists using the function class_exists(). If not then first it will try to explode the class name to determine directory structure. So let’s say the class name is Database_Connection then it will break it into two part Database and Connection and try to look for class Connection in Database directory (Database/Connection.php). Now according to the number of arguments passed it will try to include that class file from directory structure. Here if $count is one that means we want the class with no arguments, if $count is two then we want class with 1 argument and so on.

The function will smart to get the number of arguments passed using func_get_args() and func_num_args() PHP functions and that’s why I love PHP the most . Once it knows the number of arguments passed, it need to remove the first argument, because it’s a class name not an actual argument. It uses array_shift() function to remove the first element from an array. Now it has all the pure arguments requested by the caller function and then it replaces all ‘_’ with the ‘\’ to create relative path i.e. the class name Database_Connection will be converted to ‘Database/Connection.php’. That’s it, then it will include it. Finally $argList contains NULL if no arguments passed and list of arguments instead. Now all we need to do is create a new element in $__instances array that points to the new requested class’s instance with class name as an index. In our case it would create new entry (‘Database_Connection => new Connection()’). Now it will store the address of this new instance into the static variable $__instance and return it to the caller

Facts

• __PATH_TO_MODEL is main directory of the model folder in MVC design structure
• __PATH_TO_CLASSES is main directory of all the classes inside the model directory. Examples would be
  • ‘/application/models/classes/setup.php’
  • ‘/application/models/classes/Database/Database_Connection.php’
  • ‘/application/models/classes/Database/Database_Functions.php’
  • ‘/application/models/classes/Database/Database_Utility.php’
  • ‘/application/models/classes/Core/Core_Setup.php’
  • ‘/application/models/classes/Core/Core_Config.php’
• This Singleton class can be use for universal class instantiation, i.e. only one class for all instance creation.
• This class can be useful for variable number of arguments while calling the class constructor.
• Efficiency ++, Performance ++, Load –, Re-usability ++
• The getInstance() function uses classes in case-sensitive manner, so Database and database will be treated as two different classes.
• The only requirement for this class to be working is the file name should be carved according to the directory structure i.e. if you want file Connection inside Database directory it must be named Database_Connection.php to be used by the getInstance() method.
• I hope this tutorial helps. Drop me a line if you like it.