class Decorator {
	protected $obj;
	public function __construct($name,$args=null){
		if (is_object($name)) {
			$this->obj = $name;
		} else if($args) {
			$reflection = new ReflectionClass($name);
			$this->obj = $reflection->newInstanceArgs($args);
		} else {
			$this->obj = new $name;
		}
	}

	public function __call($name,$args){
		if($args)
			return call_user_func_array(array($this->obj,$name), $args);
		else
			return $this->obj->{$name}();
	}
}

Все началось как пример одному долбаёбу на форуме, а закончилось как небольшой но прикольный класс. Естественно сначала я пару раз переписал пример, потом потестил его на локальном сервере и только потом написал эту статью, так что в классе есть небольшие изменения.

На вопрос нах вообще нуже декоратор я отвечать не буду - читайте вики или еще что-то. А вот на вопрос как это работает отвечу. Для начала создадим класс который нужно декорировать.

class MyClass {
	private $property;
	public function __construct($property){
		$this->property = $property;
	}
	public function printMethodName(){
		echo __METHOD__;
	}
	
	public function printMyArgument($arg){
		echo $arg;
	}
	
	public function printMyProperty(){
		echo $this->property;
	}
	public function myDecoratedMethod(){
		echo "Decorated Method!";
	}
}

Как понятно методы особой смысловой нагрузки не несут, а только показывают что были вызваны именно они. Теперь создадим класс производный от декоратора, который будет декорировать последний метод класса MyClass.

class ConcreteDecorator extends Decorator {
	public function myDecoratingMethod(){
		return $this->myDecoratedMethod();
	}
}

Теперь это все можно использовать примерно вот таким образом:

$myObj = new ConcreteDecorator("MyClass", array("String passed via constructor"));

$myObj->printMyProperty();
$myObj->printMethodName();
$myObj->printMyArgument("String passed via printMyArgument");
$myObj->myDecoratingMethod();

Но что-то как-то некрасиво получается, надо бы добавить в после каждого метода обрыв строки, для этого создадим еще один декоратор:

class MyNewLineDecorator extends Decorator {
	public function __call($name,$args){
		parent::__call($name,$args);
		echo "<br />";
	}
}

И добавим его в код.

$myObj = new ConcreteDecorator("MyClass", array("String passed via constructor"));
$myObj = new MyNewLineDecorator($myObj);

$myObj->printMyProperty();
$myObj->printMethodName();
$myObj->printMyArgument("String passed via printMyArgument");
$myObj->myDecoratingMethod();

В результате получаем:

String passed via constructor<br />
MyClass::printMethodName<br />
String passed via printMyArgument<br />
Decorated Method!<br />

Приятного использования.

class Singleton {
	private static $instance; // object

	/**
	 * Private constructor does nothing
	 *
	 */
	final private function __construct(){
		/* ... */
	}

	/**
	 * Return the single instance of object
	 *
	 * @return object
	 */
	public static function & __instance(){
		if (!isset(self :: $instance))
			self :: $instance = new self;
		return self :: $instance;
	}
}

$single = Singleton::__instance();

Паттерн ServiceLocator изначально спроектирован для Java и дает возможность находить сервисы, зная их имя. В Java для того чтоб найти Enterprise JavaBeans (EJB) или Java Message Service (JMS) нужно использовать JNDI API. Это накладывает на код некоторые ограничения, например операции поиска и создания компонентов служб могут быть сложными (ресурсоемкими) и могут использоваться периодически в различных клиентах приложения. Для этого ввели паттерн, который позволяет абстрагироваться от использования JNDI и скрытия сложностей создания исходного контекста, а также может повторно использоваться несколькими клиентами.

Но поскольку для PHP это все недоступно, мы будем искать объекты для одного клиента, абстрагируясь от их создания и места расположения классов их описывающих. Мы будем использовать ту же модель иерархии и связей, что и Java но с поправками на угловатости PHP.

На картинке изображена диаграмма последовательности действий, показывающая взаимодействия между различными участниками ServiceLocator

Итак задача получить объект страницы для дальнейшего использования, зная только название объекта.

Для этого нам понадобиться четыре класса и три исключения порождаемых этими классами. Я думаю, начать стоит именно с этих трех исключений, поскольку смысловой нагрузки они пока не несут, а являются лишь абстракциями для дальнейшей реализации и внесены в код для его схожести с Java.

class ServiceLocatorExeption extends  Exception{
}

class InitialContextException extends  Exception{
}

class PageFactoryExeption extends  Exception{
}

Далее я бы хотел начать с конца, потому что чем дальше от начала тем сильнее уровень абстракции и меньше кода. Поэтому сервис (объект), который мы собственно пытаемся получить, в примере не имплементирует никаких интерфейсов и не расширяет никаких классов и не имеет никаких методов, а буквально состоит из своего названия. Это вполне достаточно чтобы удачно создать его экземпляр и вернуть клиенту. Кстати роль клиента тоже весьма условна, ее играет сам PHP скрипт и из-за того, что после завершения скрипта все объекты разрушаются нельзя говорить ни о каком повторном использовании созданных объектов. Единственным способом что-то использовать повторно является кэширование, основанное на БД или файлах или сессии, но при текущей задаче это слушком дорогая (время и ресурсоемкая) процедура и она не рассматривается.

class WhitePage{

}

Как понятно из названия искать мы будем объект страницы, возможно чтобы ассоциировать с ним какой-то контент, а возможно для того чтобы передать его шаблонизатору для отображения.

Второй объект с конца у нас фабрика которая должна создать или найти уже готовый объект страницы. Лично мое мнение, что фабрика должна быть статическим классом (классом в котором все методы статические), и через конструктор вообще не должна создаваться. Но в этом примере она будет именно создаваться, а еще и получая параметры, пришедшие в виде контекста.

class PageFactory{
	public $initialContext = null;
	
	public function __construct($initialContext){
		$this->initialContext = $initialContext;
	}
	
	public function & factory(){
		try{
			// do somethind depends on $initialContext
			$product =  new WhitePage();
		}catch (Exception $e){
			throw new PageFactoryExeption();
		}
		
		return $product;
	}
}

Единственный метод (кроме конструктора) этой фабрики основываясь на пришедшем контексте должен выбрать какой объект он будет создавать, это может быть страница с текстом страница с уведомлением об ошибке, список страниц, или список списков. на данный момент это не важно поскольку у нас есть только "белая страница" с которой можно будет сделать все что угодно, даже распечатать и повесить в туалете.

Соответственно если создание не удалось, то бросается исключение, которое потом будет проброшено в сам ServiceLocator.

Идем дальше по цепочке. Следующий у нас объект InitialContext, который при создании должен получать в себя все доступные переменные окружения, и тоже имеет один метод (естественно кроме конструктора) который осуществляет поиск нужной фабрики и передаче ей переменных окружения, сама же фабрика возвращается в сам ServiceLocator.

class InitialContext{
	private $data;
	public function __construct(){
		 // do something depends on 
		 // $_GET, $_POST, $_COOKIE, $_FILES, $_SESSION, etc
		 if(isset($_SESSION))
		 	$this->data = $_SESSION;
		 else 
		 	$this->data = $_REQUEST;
	}
	
	public function & lookup($name){
		$factoryName = ucfirst($name)."Factory";
		try{
			$factory = new $factoryName($this->data);	
		}catch (Exception $e){
		/*
			try{
				$factoryName::getInstance();
			}catch(Exception $ee){
				throw new InitialContextException();
			}
		*/
			throw new InitialContextException();
		}
		return $factory;
	}
}

Тут очень хотелось в блоке catch сделать еще один try для попытки получения инстанса у синглтон объекта, но его пришлось закомментировать потому что PHP поддерживает конструкцию $factoryName::getInstance() только начиная с версии 5.3. В предыдущих версиях название класса должно быть указанно непосредственно. Разработчики объясняют это тем, что при начале синтаксического разбора все статические вызовы преобразуются в функции.

Ну и наконец то мы добрались до сладенького. То есть до самой реализации ServiceLocator. По наставлению Java класс реализовывает паттерн Singleton и имеет метод getService принимающий название сервиса и возвращающий сам сервис. Больше пока ничего нет, да ничего и не будет, наверное, потому что получать id объекта, а потом восстанавливать его по этому id неоткуда.

class ServiceLocator{
	private static $instance = null;
	private static $initialContext = null;

    final private function __construct(){
    	try {
    		$this->initialContext = new InitialContext();
    	}catch (Exception $e){
    		throw new ServiceLocatorExeption();	
    	}
    } 
	
	static function & getInstance(){ 
        if (!isset(self :: $instance)) 
            self :: $instance = new self; 
        return self :: $instance; 
    }
	
	public function & getService($name){
		if (empty($name))
			throw new ServiceLocatorExeption();
		
		try{
			$serviceFactory = $this->initialContext->lookup($name);
			$service = $serviceFactory->factory();
		}catch (InitialContextException $e){
			throw new ServiceLocatorExeption();
		}catch (PageFactoryExeption $e){
			throw new ServiceLocatorExeption();
		}

		return $service;	
	}
}

Ну я думаю тут тоже ничего сложного нет. Приватный конструктор при единственном вызове создает InitialContext и сохраняет его. getInstance обеспечивает доступ к инстансу, а getService запускает всю вышеописанную цепочку и возвращает нам нашу белую страничку. Для запуска все этого добра требуется всего две строчки:

$serviceLocator = ServiceLocator::getInstance();
var_dump($serviceLocator->getService("page"));
// object(WhitePage)#4 (0) { }

Вообще эта статья была написана в поисках того как можно объединить паттерн Registry и Pattern ServiceLocator. Вышло следующее, но реально применять на сайте я пока не стал из-за отсутствия наличия PHP 5.3 на сервере.

class PageFactory{
	public $initialContext = null;
	
	public function __construct(){
		 if(isset($_SESSION))
		 	$this->initialContext = $_SESSION;
		 else 
		 	$this->initialContext = $_REQUEST;
	}
	
	public function & factory(){
		try{
			// do something depends on $initialContext
			$product =  new WhitePage();
		}catch (Exception $e){
			throw new PageFactoryExeption();
		}
		
		return $product;
	}
}

Классом InitialContext я пожертвовал, решив, что он лишний в этой пищевой цепочке и переложил его функции частично на класс PageFactory и частично на ServiceLocator::factory. Новый ServiceLocator основан на всем, что было в паттерн Registry, по сути, добавляя только один новый метод getObjId. Метод getService является синонимом register с той лишь разницей, что добавляет уникальный идентификатор и дает хранить несколько объектов одного типа. Метод getObj это обертка для extract. А вот метод getObjId это уникальная плюшка класса ServiceLocator которая дает возможность получать id имея объект, операция противоположная для getObj. И, наконец переписан метод factory добавляя дополнительную возможность создания объекта через его фабрику. Например, если есть page но не известно как его создать сначала будет создана фабрика PageFactory, а потом будет попытка создать из нее что-нибудь, используя метод factory.

require_once("class.registry.php");

class ServiceLocator extends Registry {

	/**
	 * Looks up for services
	 *
	 * @param string $name
	 * @return mixed
	 */
	static public function & getService($name){
		$id = md5(time());
		$service = self::register($name,$id);
		return $service;
	}

	/**
	 * Restore object by id
	 *
	 * @param string $id
	 * @return mixed
	 */
	static public function & getObj($id){
		return self::extract($id);	
	}	
	
	/**
	 * extracts object id
	 *
	 * @param mixed $obj
	 * @return string
	 */
	static public function & getObjId($obj){
		$reg = self::__instance();
		// array_search($obj, $reg->tools) ???
		foreach ($reg->tools as $key => &$val)
			if($obj === $val)
				break;
		return $key;
	}
	
	/**
	 * Implementation of factory pattern
	 *
	 * @param string $name
	 * @param array $param
	 * @param string $func
	 * @return object
	 */
	static public function & factory($name,$params=null,$func="__instance"){
		
		if (is_object($name)) 
			return $name;
		
		if (!class_exists($name) && is_callable("__autoload"))
			__autoload($name);
		
		if (class_exists($name)){
			if(is_callable(array($name,$func))){
				return call_user_func_array(array($name,$func),$params); // метод $name::$func вызван статично
			}else if(!$params){ // пытаемся сэкономить время
				return new $name();
			}else{
				$reflection = new ReflectionClass($name);
				return $reflection->newInstanceArgs($params);
			}
		}else{
			$factory = ucfirst($name)."Factory";
			
			if (!class_exists($factory) && is_callable("__autoload"))
				__autoload($factory);

			if(class_exists($factory) && is_callable(array($factory,"factory"),true)){
				return call_user_func_array(array($factory,"factory"),$params);
			}
		}
		// если мы до сюда дошли и ничего не вернули то бросаем исключение
		throw new Exception("Class '$name' doesn't declared and can't be loaded so does it's factory");

	}
}

Прежде чем вы попробовали запустить этот код, спешу заметить что работать код будет только на PHP 5.3, хотя сам я пока не проверял. По причине указанной выше статические методы классов наследников не перезаписывают статические методы классов родителей. Для того чтобы пример заработал нужно добавить новые методы в класс паттерн Registry и переписать метод factory.

	Возможно вам будет интересна статья ServiceLocator, она имеет непосредственное отношение к этой статье.

Решил обновить класс, но очень не хотел переписывать прошлую статью, она мне дорога как память :). Поэтому решил еще раз опубликовать свежий класс. Напомню или расскажу для тех, кто не заметил сверху ссылки на предыдущую версию, что класс реализует паттерн Registry. То есть это Singleton класс, имеющий в себе ссылки на все основные ресурсы сайта. Например, удобно получать ссылку на объект для работы с базой данных с помощью выражения Registry::extract('db') не заботясь о том где, как и когда он был создан.

class Registry {

	private $tools = array(); // array
	private static $instance; // object

	/**
	 * Private constructor does nothing
	 *
	 */
	final private function __construct(){
		/* ... */
	}

	/**
	 * Return the single instance of object
	 *
	 * @return object
	 */
	public static function & __instance(){
		if (!isset(self :: $instance))
			self :: $instance = new self;
		return self :: $instance;
	}
	
	/**
	* Register tools
	*
	* @param object|string $tool
	* @param string $name
	* @param array $p
	* @return object
	*/
	public static function & register($tool, $name='', $p=null, $f='__instance'){
		if (is_string($tool) && !$name)
			$name = $tool;
		$instance = self :: __instance();
		$instance->tools[$name] = $instance->factory($tool, $p, $f);
		return $instance->tools[$name];
	}

	/**
	 * Unregister tools
	 *
	 * @param string $name
	 * @param bool $force
	 */
	public static function unregister($name, $force=false){
		$instance = self :: __instance();
		unset($instance->tools[$name]);
		if ($force && is_callable(array($name,"__kill")))
	   		call_user_func(array($name,"__kill"));
	}

	/**
	 * Search for tool
	 *
	 * @param srting $name
	 * @return bool
	 */
	public static function has($name){
		$instance = self :: __instance();
		if (isset($instance->tools[$name]))
			return true;
		return false;
	}

	/**
	 * Factory method
	 *
	 * @param string|object $name
	 * @return object
	 */
	public static function & factory($name,$params=null,$func="__instance"){

		if (is_object($name))
			return $name;

		if (!class_exists($name) && is_callable("__autoload"))
			__autoload($name);
		
		if (class_exists($name)){
			if(is_callable(array($name,$func))){
				return call_user_func_array(array($name,$func),$params); // метод $name::$func вызван статично
			}else if(!$params){ // пытаемся сэкономить время
				return new $name();
			}else{
				$reflection = new ReflectionClass($name);
				return $reflection->newInstanceArgs($params);
			}
		}
		throw new RegistryException("Class '$name' doesn't declared and can't be loaded!");

	}

	/**
	 * Access method for tools
	 *
	 * @param string $name
	 * @return object
	 */
	public static function & extract($name){
		if (!self :: has($name))
			self :: factory($name);
		$instance = self :: __instance();
		return $instance->tools[$name];
	}

	/**
	 * Overload
	 *
	 * @param string $name
	 * @return object
	 */
	public function __get($name){
		return self :: extract($name);
	}

	/**
	 * Overload
	 *
	 * @param string $name
	 * @param object|string $tool
	 * @return object
	 */
	public function __set($name,$tool){
		return self :: register($tool,$name);
	}

	/**
	 * Cloning is deprecated
	 *
	 */
	public function __clone(){
		throw new RegistryException('Clone is not allowed!');
	}

	/**
	 * Destroy all tools
	 *
	 */
	public function __destruct(){
		$instance = self :: __instance();
		$tools = array_reverse(array_keys($instance->tools),true);
		foreach ($tools as $name){
			echo "Вызыв. деструктор $namen";
			self :: unregister($name,true);
		}
	}
}

Основные изменения коснулись фабричного метода, были добавлены новые параметры и реализовано создание класса с параметрами через конструктор, что до сих пор было не возможно. Причем старый метод создания класса без параметров остался в силу того, что работает он быстрее, чем новый основанный на рефлекции. Так была исправлена ошибка, которая регистрировала свежесозданные объекты прямо в фабрике.

Из-за неудобства в использовании были убраны исключения порождаемые при попытке повторной регистрации под тем же именем и разрегистрации несуществующего объекта, теперь не придется проверять наличие/отсутствие объектов перед их заменой.

Еще одно нововведение - теперь класс имеет перегруженные методы __set и __get, благодаря которым практически отпадает надобность в статических методах.

Для демонстрации возможностей создадим два демонстрационных класса. Первый будет реализовывать паттерн Singleton а второй будет обычным.

/**
 * Класс реализовывающий паттерн Singleton должен иметь два метода
 * __instance - для создания инстанса
 * __kill - для разрушения инстанса
 */
class B
{
	private static $instance;

	final private function __construct(){
		echo "B :: __construct()n";
	}

	static function & __instance(){
		if (!isset(self :: $instance))
			self :: $instance = new self;
		return self :: $instance;
	}

	public function __kill(){
		echo "Разрушаем объект  Bn";
		self :: $instance = null;
	}

	public function __destruct(){
		echo "Объект разрушен   Bn";
	}
}

Singleton класс помимо __construct и __destruct реализовывает еще два магических метода: __instance для создания/получения сущности и __kill для уничтожения этой сущьности при разрегистрации. Напомню, что если разрегистировать класс не вызвав __kill, то ссылка на класс останется в нем самом, и его можно будет продолжать использовать, реальное же разрушение класса произойдет только по окончанию скрипта.

class C
{
	public $B;

	public function __construct($B){
		echo "C :: __construct()n";
		$this->setB($B);
	}

	public function setB($B){
		$this->B = $B;
	}

	public function __destruct(){
		echo "Объект разрушен   Cn";
	}
}

Обычный класс, создаваемый через конструктор, не должен содержать никаких дополнительных методов, и будет разрушаться при разрегистрации сразу же если на него не осталось ссылок.

Демонстрация фабричного метода, без регистрации

// Создание singleton объекта
$b = Registry::factory("B", null, "__instance");

// Или короткий способ
$b = Registry::factory("B");

// Создание обычного объекта c параметрами
$c = Registry::factory("C",array($b));

Демонстрация регистрации и удаления объекта

// Создаем и регистрируем singleton объект
$b = Registry::register("B");

// Создаем и регистрируем обычный объект с параметрами
Registry::register("C","C",array($b));

// Экстрагируем объект
$c = Registry::extract("C");

// Регистрируем уже готовый объект
Registry::register($c,"D");

// Разрушаем обычный объект
Registry::unregister("D");

// Разрушаем singleton объект
Registry::unregister("B",true);

// Разрушаем ссылку на B в С
Registry::extract("C")->setB(null);

// разрушаем ссылки на объекты в глобальной области видимости
$b = $c = null;

// теперь остался один зарегистрированный экземпляр С
echo Registry::has("C");

А теперь внимание новинка, забудьте о двойных двоеточиях! Теперь не обязательно использовать статические методы класса Registry, можно с тем же успехом работать с ним как с обычным классом, присваивая и читая его свойства с помощью перегруженных __set и __get.

// Создаем и регистрируем обычный объект
Registry::register("C");

// присваиваем инстанс класса переменной
$registry = Registry::__instance();

// читаем и пишем в свойства объекта
var_dump($registry->C);

$Registry->B = "B";
var_dump($registry->B);

$registry->D = new C(new B());

Шаблон Factory заключается в том, что метод одного объекта возвращает другой новый объект. Проиллюстрируем небольшим примером.

class Factory{
	public function factory(){
		return new Product();
	}
}

class Product{
}

$factory = new Factory();
$product = $factory->factory();

Хотя чаще фабричный метод делают статичным, но если метод нуждается в других ресурсах объекта то необходимо использовать еще и паттерн Singleton. Для этого создадим класс чуть по сложнее:

class Factory{
	private static $instance;
	public $name = 'Product';
	
	private function __construct(){
	}

	public static function __instance(){
		if (!isset(self::$instance)){
			self::$instance = new self;
		}
		return self::$instance;
	}

	public static function factory(){
		$instance = self::__instance();
		return new $instance->name();
	}
}

class Product{
}

$product = Factory::factory();

Теперь предположим что конструктор Product нуждается в параметрах, которые нужно передавать в фабричный метод.

	// чтобы не пложить код, я заменил один метод в прошлом примере
	public static function factory($a,$b,$c){
		$instance = self::__instance();
		return new $instance->name($a,$b,$c);
	}

Теоретически правильно, но параметров может быть неограниченное количество (я же тут за универсализм борюсь!).

Казалось бы есть выход сделать это при помощи call_user_func_array но таким образом можно вызывать только статичные методы, а конструктор не может быть статичным, поэтом делаем маленькую хитрость. При помощи встроеного класса ReflectionClass рефлекторно вызываем нужный нам класс с параметрами.

class Factory{
	private static $instance;
	public $name = 'Product';
	
	private function __construct(){
	}

	public static function __instance(){
		if (!isset(self::$instance)){
			self::$instance = new self;
		}
		return self::$instance;
	}

	public static function factory(){
		$instance = self::__instance();
		$args = func_get_args(); // func_get_args нельзя использовать в качестве агрумента другой функции.
		$reflection = new ReflectionClass($instance->name);
		return $reflection->newInstanceArgs($args); 
	}
}

class Product{
	public function __construct($a,$b,$c){
		echo $a,$b,$c;
	}
}

$product = Factory::factory('a','b','c');

Теперь мы можем вызывать любой класс с любым количеством параметров, но ведь не все классы создаются через конструктор, поэтому еще усложним задачу, предположим что некоторые объекты сами могут быть фабриками и одиночками.

class Factory {
	private static $instance;
	
	/**
	 * Constructor
	 *
	 */
	private function __construct(){
	}
	
	/**
	 * Singleton inplementation
	 *
	 * @return object
	 */
	public static function instance(){
		if (!isset(self::$instance))
			self::$instance = new self;
		return self::$instance;
	}
	
	/**
	 * Craft new object
	 *
	 * @param string $name
	 * @param array $params
	 * @param string $func
	 * @return object
	 */
	public static function factory($name,$params=null,$func='__instance'){
		if (!class_exists($name) && is_callable("__autoload"))
			__autoload($name);
		
		if (class_exists($name)){
			if(is_callable(array($name,$func))){
				return call_user_func_array(array($name,$func),$params); // метод $name::$func вызван статично
			}else if(!$params){ // пытаемся сэкономить время
				return new $name();
			}else{
				$reflection = new ReflectionClass($name);
				return $reflection->newInstanceArgs($params);
			}
		}else{
			$factory = ucfirst($name)."Factory";
			
			if (!class_exists($factory) && is_callable("__autoload"))
				__autoload($factory);

			if(class_exists($factory) && is_callable(array($factory,"factory"),true)){
				return call_user_func_array(array($factory,"factory"),$params);
			}
		}
		// если мы до сюда дошли и ничего не вернули то бросаем исключение
		throw new FactoryException("Class '$name' doesn't declared and can't be loaded so does it's factory");
	}
}

class FactoryException extends Exception{
}

class Product1{
	public function __construct(){
		echo "Product1 <br/>\n";
	}
}

class Product2{
	public function __construct($a,$b,$c){
		echo 'Product2 ',$a,$b,$c," <br/>\n";
	}
}

class Product3{
	private static $instance;
	
	private function __construct(){
		echo "Product3 <br/>\n";
	}

	public static function __instance(){
		if (!isset(self::$instance)){
			self::$instance = new self;
		}
		return self::$instance;
	}
}

class Product4{
	private static $instance;
	
	private function __construct($a,$b,$c){
		echo 'Product4 ',$a,$b,$c," <br/>\n";
	}

	public static function __instance($a,$b,$c){
		if (!isset(self::$instance)){
			self::$instance = new self($a,$b,$c);
		}
		return self::$instance;
	}
}

class Product51{
	public function __construct(){
		echo "Product51 <br/>\n";
	}
}

class Product52{
	private static $instance;
	
	private function __construct($a,$b,$c){
		echo 'Product52 ',$a,$b,$c," <br/>\n";
	}

	public static function __instance($a,$b,$c){
		if (!isset(self::$instance)){
			self::$instance = new self($a,$b,$c);
		}
		return self::$instance;
	}
}

class Product5Factory{
	public static function factory($a=null,$b=null,$c=null){
		if($a&&$b&&$c)
			return Product52::__instance($a,$b,$c);
		return new Product51();
	}
}


$product1 = Factory::factory('Product1');
$product2 = Factory::factory('Product2',array('a','b','c'));
$product3 = Factory::factory('Product3',null,'__instance');
$product4 = Factory::factory('Product4',array('a','b','c'),'__instance');
$product51 = Factory::factory('Product5');
$product52 = Factory::factory('Product5',array('a','b','c'));

Сразу оговорюсь что можно было бы сэкономить время вызвав $name::$func() (в строке 19) без параметров, если бы интерпритатор php перед тем как выполнить скрипт не преобразовывал вызовы всех статичных методов в вызовы функций, такая фича появиться с выходом PHP5.3

Для того чтобы создать один раз экземпляр класса Product этого кода, конечно очень много, но если постоянно приходиться создавать экземпляры классов имена которых динамичны, то это очень хороший подод.

	У этой статьи есть продолжение Pattern: Registry

Как и было условлено ранее, класс должен реализовывать паттерн Singleton, чтобы исключить возможность создания его копии.

class CORE{

	private $tools;
	private static $instance;
	
	final private function __construct(){ 
		echo "CORE::__construct()\n";
	}
	
	static function & __instance(){
		if (!isset(self::$instance))
			self::$instance = new self;
		return self::$instance;
	}

	function __clone(){
		trigger_error('Clone is not allowed.', E_USER_ERROR);
	}
}

Теперь создать объект напрямую оператором new не получиться, а клонирование вызовет ошибку уровня E_USER_ERROR.

Свойство tools будет хранить в себе ссылки на все управляемые объекты, а instance ссылку на само ядро. Добавим методы регистрации и разнрегистрации объектов в ядре.

	static function & register($tool, $name=''){
		if (is_string($tool) && !$name)
			$name = $tool;
			
		if (self::has($name))
			throw new Exception("Try to re-register tool '$name'",1);
			
		$instance = self::__instance();
		$instance->tools[$name] = $instance->factory($tool);
		return $instance->tools[$name];	
	}
	
	static function unregister($name, $force=false){
		if (!self::has($name))
			throw new Exception("Try to unregister non-existing tool '$name'",1);
			
		$instance = self::__instance();
		unset($instance->tools[$name]);
		
		if ($force && is_callable(array($name,"kill"))) 
			call_user_func(array($name,"kill"));
	}

Здесь метод register принимает первым параметром объект или название класса из которого этот объект можно создать, а вторым имя под которым его нужно будет сохранить.

Метод unregister принимает название объекта который нужно уничтожить и флаг для форсирования уничтожения объекта.

Помимо этого используються еще два метода: has и factory, has проверяет не зарегистрирован ли уже объект с таким именем, а factory создает объект если указано только его название.

	static function has($name){
		$instance = self::__instance();
		
		if (isset($instance->tools[$name]))
			return true;
			
		return false;
	}
	
	static function & factory($name){
	
		if (is_object($name))
			return $name;

		if (!class_exists($name) && is_callable("__autoload"))
			__autoload($name);
		
		if (class_exists($name)){
			if(is_callable(array($name,"__instance")))
				return $instance->tools[$name] = call_user_func(array($name,"__instance")); // метод $name::__instance вызван статично
			return $instance->tools[$name] = new $name;
		}
		throw new Exception("Class '$name' doesn't declared and can't be loaded!");
	}

Немного подробнее о методе factory: он пытается создать экземпляр класса, когда известно только имя этого класса. Если такой класс не найден, то метод передает управление функции __autoload. Затем снова проверяет, доступен ли класс. Если не доступен, то бросает exception, а если доступен, то пытается создать его либо непосредственно используя оператор new, либо как паттерн Singleton используя метод __instance. При этот метод __instance вызывается статично!

Помимо всего этого нужен еще один метод, для доступа ко всему тому, что было зарегистрировано.

	static function & extract($name){
		if (!self::has($name))
			self::factory($name);
		$instance = self::__instance();
		return $instance->tools[$name];
	}

И заканчивает описание класса деструктор, который будет уничтожать объекты в обратном порядке их регистрации:

	function __destruct(){
		$instance = self::__instance();
		$tools = array_reverse(array_keys($instance->tools),true);
		foreach ($tools as $name){
			echo "Вызыв. деструктор $name\n";
			self::unregister($name,true);
		} 
		echo "Объект разрушен CORE\n";
	}

Теперь приведу пример работы с этим классом:

class B 
{
	private static $instance;
	
	final private function __construct(){ 
		echo "B::__construct()\n";
	}
	
	static function & __instance(){
		if (!isset(self::$instance))
			self::$instance = new self;
		return self::$instance;
	}
	
	public function kill(){
		self::$instance = null;
	}
	
	public function __destruct(){
		echo "Объект разрушен   B\n";
	}
}

class C 
{
	public $B;
	public function __construct($B){
		echo "C::__construct()\n";
		$this->setB($B);
	}
	public function setB($B){
		$this->B = $B;
	}
	public function __destruct(){
		echo "Объект разрушен   C\n";
	}
}


CORE::__instance();
CORE::register('B');
CORE::register(new C(CORE::extract('B')),'C');


/** RESULT ********
CORE::__construct()
B::__construct()
C::__construct()
Вызыв. деструктор C
Объект разрушен   C
Вызыв. деструктор B
Объект разрушен   B
Объект разрушен CORE
********************/

Ну я думаю стоит начать из далека... когда еще деревья были большими а колбаса вкусной...
Нет это слишком рано ;) Начнем с того что паттерны в программировании были придуманы никак не для PHP, а для Smalltalk. Ну а к PHPони были притянуты "за уши", с появлением 5-ой версии.

Идея паттерна Registry состоит в том что проект (читай : сайт) содержит много разнообразных классов, например класс для работы с БД и шаблонизатор. А теперь появился класс User который должен работать с БД и передавать данные шаблонизатору. Значит он должен знать о функциях SELECT и ASSIGN двух других классов. Классы можно было бы наследовать и получить этот доступ но наследовать в PHP можно только один класс, да и если проект большой то стоит ли наследовать 150 разных классов?! Значит надо передавать экземпляры классов в функции которые их используют, или еще лучше в конструктор а там присвоить их свойствам. А зачем передавать(?!) можно сразу создать новый экземпляр прямо в конструкторе User'a, допустим, а если при создании конструкторам нужно передавать параметры? Или можно использовать паттерн Singleton для того чтобы не пересоздавать объект каждый раз но это не всегда удобно. Ну, а что если, например вы решите сменить шаблонизатор с XTemplate на Smarty и придется искать и реплейсить все названия класса.

И придумали умные программисты создавать один класс который бы знал о всех остальных, и раздавал кому нужно ссылки на них! При всем этом желательно чтоб еще никто не создал случайно второй экземпляр этого чудо класса поэтому в нем используют паттерн Singleton Еще неплохо было бы там использовать фабричные методы но мы это опустим... покрайней мере пока

Итак создадим класс A и скажем что напрямую его создать нельзя будет, но можно создать через функцию instance(), а также создадим статичный метод для регистрации некого объекта B о котором известно только что он создается напрямую через конструктор.

class A{

	public $registry;
	private static $instance;
	
	private function __construct(){
		echo "A::__construct()\n";
	}
	
    static function & instance(){
        if (!isset(self::$instance)){
            self::$instance = new self;
        }
        return self::$instance;
    }
    
    public static function register(&$obj){
    	$instance =& A::instance();
    	$instance->registry = $obj;
    }
    
	public function __destruct(){ 
		echo "A::__destruct()\n";
	}
}

class B {

	public function __construct(){
		echo "B::__construct()\n";
	}
	
	public function __destruct(){
		echo "B::__destruct()\n";
	}
}

A::instance();
A::register(new B);

//RESULT :
//A::__construct()
//B::__construct()
//A::__destruct()
//B::__destruct()

Создали, зарегистрировали, прикольно. Теперь обратите внимание на порядок следования деструкторов. Логично было ло бы, чтоб деструктор класса A вызывался ПОСЛЕ деструктора B для этого изменим несколько строк

	public function __destruct(){
		$instance =& A::instance();
    	$instance->registry = null;
		echo "A::__destruct()\n";
	}

//RESULT :
//A::__construct()
//B::__construct()
//B::__destruct()
//A::__destruct()

Теперь вроде бы все правильно деструкторы вызываются в правильной последовательности, но регистрация одного класса ничего не даст надо регистрировать много классов и следить чтобы их деструкторы вызывались в правильной последовательности

class A{

	public $registry;
	private static $instance;
	
	private function __construct(){
		echo "A::__construct()\n";
	}
	
    static function & instance(){
        if (!isset(self::$instance)){
            self::$instance = new self;
        }
        return self::$instance;
    }
    
    public static function register(&$obj,$name){
    	$instance =& A::instance();
    	$instance->registry[$name] =& $obj;
    }
    
    public static function & extract($name){
    	$instance =& A::instance();
    	return $instance->registry[$name];
    }
    
    public static function unregister($name) {
    	unset($instance->registry[$name]);
    }
    
	public function __destruct(){
		echo "Вызван деструктор A\n";
		$instance =& A::instance();
		foreach ($instance->registry as $name => &$obj){
			echo "Вызван деструктор $name\n";
    		$obj = null;
		}
		echo "Объект разрушен   A\n";
	}
}

class B{

	public function __construct(){
		echo "B::__construct()\n";
	}
	
	public function __destruct(){
		echo "Объект разрушен   B\n";
	}
}

class C{

	public function __construct(){
		echo "C::__construct()\n";
	}
	
	public function __destruct(){
		unset($this->B);
		echo "Объект разрушен   C\n";
	}
}

A::instance();
A::register(new B,'B');
A::register(new C,'C');

//RESULT
//A::__construct()
//B::__construct()
//C::__construct()
//Вызван деструктор A
//Вызван деструктор B
//Объект разрушен   B
//Вызван деструктор C
//Объект разрушен   C
//Объект разрушен   A

Однако на этом проблемы не заканчиваются. Случилось собственно то ради чего все это затевалось В объекте класса C понадобилась информация об объекте класса B

class C{

	public $B;
	
	public function __construct(){
		echo "C::__construct()\n";
		$this->B =& A::extract('B');
	}
	
	public function setB(&$B){
		$this->B =& $B;
	}
	
	public function __destruct(){
		echo "Объект разрушен   C\n";
	}
}

A::instance();
A::register(new B,'B');
A::register(new C,'C');

// или переприсваисаем значение через seter
A::extract('C')->setB(A::extract('B'));

//RESULT :
//A::__construct()
//B::__construct()
//C::__construct()
//Вызван деструктор A
//Вызван деструктор B
//Объект разрушен   B
//Вызван деструктор C
//Объект разрушен   C
//Объект разрушен   A

Примерно так выглядело ядро, этого сайта, пока я не перешел на WordPress, только немного сложнее - с добавлением фабричных методов.