The Factory Pattern: OOP Techniques in PHP

Posted on 02. Mar, 2009 by Will Fitch in PHP

The purpose of the factory pattern is to assist with maintaining loose coupling. Code that is tightly coupled is error prone in that if a class is changed, it can have a domino affect to other scripts using it. This is typical to large-scale systems and smaller systems that grow very fast.

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

_userId = $id;
	}
}

class UsersFactory
{
	public static function getInstance($id)
	{
		return new Users($id);
	}
}

$user = UsersFactory::getInstance($id);
?>

PHP

<?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

_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);
	}
}
?>

PHP

<?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

<?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’);
?>