PHP Design Patterns: Singleton Pattern Example

Rob — Sun, 18 Jan 2009 15:39:16 +0000

The Singleton pattern is generally the first Design Pattern a developer is exposed to, because it solves a common problem and it is easy to understand and implement. Even though Design Patterns are language independent, each language often implements them differently. It is also important to remember that the context of the application can cause the implementation to change as well. Design Patterns are patterns not rules.

PHP allows you to create the Singleton in such a way that the internal code of the class can be agnostic. Changing the package or class name does not affect the Singleton implementation itself.

Traditionally you would create a Singleton like this:

Example 1.0 – Traditional implementation of Singleton

^?View Code PHP

class DP_Singleton
{
    private static $_instance;
 
    /**
     * @return DP_Singleton
     */
    static function getInstance()
    {
        if(empty(DP_Singleton::$_instance)) {
            DP_Singleton::$_instance = new DP_Singleton();
        }
        return DP_Singleton::$_instance;
    }
 
    private function __construct ()
    {
        echo 'Singleton created.';
    }
}

Example 1.1 – Using the Singleton

^?View Code PHP

// Cannot instantiate
//$singleton = new DP_Singleton();
 
/*
 * Output:
 * Fatal error: Call to private DP_Singleton::__construct() ...
 */
 
// Will instantiate a new class - first time its called
$singleton = DP_Singleton::getInstance();
 
/*
 * Output:
 * Singleton created
 */
 
// Will use already existing class
$singleton = DP_Singleton::getInstance();
 
/*
 * Output:
 *
 */

This works and is correct. However, we are not taking advantage of the PHP language. PHP has the notion of self in which it can reference the class it resides in. Static objects reside on the class reference not the instance.

By changing our code to this, we have now made our Singleton operation class independent.

Example 1.2 – Singleton using self.

^?View Code PHP

class DP_Singleton
{
    private static $_instance;
 
    /**
     * @return DP_Singleton
     */
    static function getInstance()
    {
        if(empty(self::$_instance)) {
            self::$_instance = new self();
        }
        return self::$_instance;
    }
 
    private function __construct ()
    {
        echo 'Singleton created.';
    }
}

Later, if we need to refactor the package or name of our class, we do not need to refactor the Singleton implementation. Notice that I still have the comment indicating the return value. I have left this as the name of the class, for two reasons: 1) Many IDEs (such as Zend Studio) can provide auto-completion if it exists in the code; 2) for publishing documentation using PHPDocs.

Design Patterns as patterns not rules

If you look up design patterns by GoF or on Wikipedia, we have covered the definition, but we could go one step further and “extend” the pattern. For example:

Example 1.3 – Singleton with scope.

^?View Code PHP

class DP_Singleton
{
    private static $_instance = array();
 
    /**
     * @return DP_Singleton
     */
    static function getInstance( $scope = 'default' )
    {
        if(empty(self::$_instance[$scope])) {
            self::$_instance[$scope] = new self();
        }
        return self::$_instance[$scope];
    }
 
    private function __construct ()
    {
        echo 'Singleton created.';
    }
}

Example 1.4 – Using the Singleton class with scope

^?View Code PHP

// Cannot instantiate
//$singleton = new DP_Singleton();
 
/*
 * Output:
 * Fatal error: Call to private DP_Singleton::__construct() ...
 */
 
// Will instantiate a new class - first time its 
// called with 'default' scope
$singleton = DP_Singleton::getInstance();
 
/*
 * Output:
 * Singleton created
 */
 
// Will use already existing class
$singleton = DP_Singleton::getInstance();
 
/*
 * Output:
 *
 */
 
// Will instantiate a new class with our custom 
// scope 'my_scope'
$singleton = DP_Singleton::getInstance('my_scope');
 
/*
 * Output:
 * Singleton created
 */

We have introduced “scope” into our singleton. The nice thing about this addition is you can add it at anytime without affecting previously written code because scope is optional. Now if you have a need for another instance in the system, you can create one and other parts can use it as well.

rob [ON] code » Design Patterns

PHP Design Patterns: Singleton Pattern Example