The Singleton Pattern is one of the GoF (Gang of Four) Patterns. This particular pattern provides a method for limiting the number of instances of an object to just one. It's an easy pattern to grasp once you get past the strange syntax used.
Consider the following class:
PHP Code:
class Database
{
public function __construct() { ... }
public function connect() { ... }
public function query() { ... }
...
}
This class creates a connection to our database. Any time we need a connection we create an instance of the class, such as:
PHP Code:
$pDatabase = new Database();
$aResult = $pDatabase->query('...');
Lets say we use the above method many times during a script's lifetime, each time we create an instance we're creating a new Database object (we're also creating a new database connection, but that's irrelevant in this example) and thus using more memory. Sometimes you may intentionally want to have multiple instances of a class but in this case we don't.
The Singleton method is a solution to this common problem. To make the Database class a Singleton we first need to add a new property to the class, we'll call this $m_pInstance:
PHP Code:
class Database
{
// Store the single instance of Database
private static $m_pInstance;
...
}
As the comment states, this property will be used to store the single instance of our Database class. You should also note that this property
must be static.
Next we need to change the constructor's scope to private. This is one of the strange syntaxes that usually confuse people.
PHP Code:
class Database
{
// Store the single instance of Database
private static $m_pInstance;
private function __construct() { ... }
}
By making the constructor private we have prohibited objects of the class from being instantiated from outside the class. So for example the following no longer works outside the class:
PHP Code:
$pDatabase = new Database();
We now need to add a method for creating and returning our Singleton. Add the following method to the Database class:
PHP Code:
public static function getInstance()
{
if (!self::$m_pInstance)
{
self::$m_pInstance = new Database();
}
return self::$m_pInstance;
}
This funny looking function is responsible for handling our object instance. It's relatively easy to understand, basically we check our static property $m_pInstance, if it is not valid we create a new instance of the Database class by calling the constructor. Remember, we made the __construct() method private, so an instance of the object can only be created from within the class' methods. Finally the function returns a reference to our static property. On subsequent calls to getInstance(), $m_pInstance will be valid and thus the reference will be returned - no new instances are created.
So our Database class now looks something like this
PHP Code:
class Database
{
// Store the single instance of Database
private static $m_pInstance;
private function __construct() { ... }
public static function getInstance()
{
if (!self::$m_pInstance)
{
self::$m_pInstance = new Database();
}
return self::$m_pInstance;
}
}
You can now get an instance of the Database class from anywhere (without using globals or function arguments) in your project. Here's an example and comparison:
This is the usual way we create objects:
PHP Code:
$pDatabase = new Database();
$aResult = $pDatabase->query('...');
This is the Singleton way:
PHP Code:
$pDatabase = Database::getInstance();
$aResult = $pDatabase->query('...');
To conclude, the Singleton is an easy-to-use design pattern for limiting the number of instances of an object. See the attached files for working examples.