For example, let’s assume you have a relatively small system that contains a class called Users. This class reads user data from a small file located on disk. Your system booms, and you need to move to a RDBMS (Relational Database Management System). Because of this, your methods in the class, data source and other items change, breaking the code that is utilizing the Users class. This is where the factory pattern comes in.

The factory pattern’s purpose is to contain methods that create objects for you. Instead of directly instantiating the Users class, you request an instance from a factory class (we’ll call it UsersFactory), and call a static method (we’ll call it getInstance).

Example

<?php
class Users
{
	private $_userId;
	public function getUserById()
	{
		// go get a user
	}
 
	public function __construct($id)
	{
		$this->_userId = $id;
	}
}
 
class UsersFactory
{
	public static function getInstance($id)
	{
		return new Users($id);
	}
}
 
$user = UsersFactory::getInstance($id);
?>

The example above demonstrates how a factory method would work. Now, let’s add in that new class that gets the users from the database. Let’s assume you have 25 other scripts that use the existing class. You can create the new Users_From_DB class and create a static method to reference that as well.

<?php
 
class Users
{
	private $_userId;
	public function getUserById()
	{
		// go get a user
	}
 
	public function __construct($id)
	{
		$this->_userId = $id;
	}
}
 
class Users_From_DB
{
	// same class only from db
}
 
class UsersFactory
{
	public static function getInstance($id)
	{
		return new Users($id);
	}
 
	public static function getUsersFromDB($id)
	{
		return new Users_From_DB($id);
	}
}
?>

This allows you to maintain a loose coupling with a class that could create major problems in the event it goes through major changes.

Conclusion

I have seen where some use the factory pattern as a singleton. They look similar but serve two very different purposes. Take the code below:

<?php
 
class Users_Model
{
	public function getUserById($id)
	{
		// do something
	}
}
 
class Model
{
	private static $instances=array();
 
	public static function factory($model_name)
	{
		if (array_key_exists($model_name, self::$instances))
		{
			return self::$instances[$model_name];
		}
		return self::$instances[$model_name] = new $model_name();
	}
}
 
$model = Model::factory('Users_Model');
$model2 = Model::factory('Users_Model');
?>

While the case could be made that it is acting as a factory pattern, it is being used more as a singleton, maintaining a single instance of a class.

The factory pattern does a really good job, and like the singleton, it serves a very specific purpose.