阿飞呓语

定义一个算法，把它们一个一个封装起来，并且使它们可以相互替换。本模式使得算法可独立于使用它的客户而变化。

上帝制造了男人:

<?php
	interface Man
	{
		public function getName();
		public function setWoman(Woman $woman);
		public function fallingInLove();
	}

上帝又制造了女人：

interface Woman
{
	public function love(Man $man);
}

有一天出现了一个花样美少男，他能遇见不同的女人并让对方爱上他：

class Flowerman implements Man
{
	private $name;
	private $girlfriend;
	public function __construct($name)
	{
		$this->name = $name;
	}
	public function getName()
	{
		return $this->name;
	}
	public function setWoman (Woman $woman){
		$this->girlfriend = $woman;
		return $this;
	}
	public function fallingInLove(){
		$this->girlfriend->love($this);
		return $this;
	}
}

三个女人一台戏：

class Woman70 implements Woman
{
	private $name;
	public function __construct($name)
	{
		$this->name = $name;
	}
	public function love(Man $man)
	{
		echo $this->name , '疯狂的爱上了' , $man->getName(),'';
	}
}
class Woman80 implements Woman
{
	private $name;
	public function __construct($name)
	{
		$this->name = $name;
	}
	public function love(Man $man)
	{
		echo $this->name , '奋不顾身爱上了' , $man->getName(),'';
	}
}
class Woman90 implements Woman
{
	private $name;
	public function __construct($name)
	{
		$this->name = $name;
	}
	public function love(Man $man)
	{
		echo $this->name , '非主流的爱上了' , $man->getName(),'';
	}
}

这是一段刻骨铭心的琼瑶剧：

$boy = new Flowerman('花样美少男');
$girl_70 = new Woman70('70后的大姐');
$girl_80 = new Woman80('80后的姑娘');
$girl_90 = new Woman90('90后的妹子');
$boy->setWoman($girl_70)->fallingInLove()
	->setWoman($girl_80)->fallingInLove()
	->setWoman($girl_90)->fallingInLove();

定义一个操作的算法的骨架，而将这一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

<?php
	abstract class AbstractClass{
		final function TemplateMethod(){
			$this->step1();
			$this->step2();
			$this->step3();
		}
		abstract function step1();
		abstract function step2();
		abstract function step3();
	}

这里的例子中，模板方法（TemplateMethod），已经把算法定义好了第一步，第二步，第三步，而每一步的具体实现得由子类去实现。

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确的指定具体类

抽象工厂其实是工厂方法的一种扩展。可以这样认为，提供一组相关对象的工厂方法，允许客户（代码的使用者）使用抽象的接口来创建一组相关的产品。

<?php
	abstract class AbstractFactory{
		abstract function CreateProductA();
		abstract function CreateProductB();
		abstract function CreateProductC();
	}

	class ConcreteFactory1 extends AbstractFactory{
		public function CreateProductA1(){
			...
		}
		public function CreateProductB1(){
			...
		}
		public function CreateProductC1(){
			...
		}
	}

	class ConcreteFactory2 extends AbstractFactory{
		public function CreateProductA2(){
			...
		}
		public function CreateProductB2(){
			...
		}
		public function CreateProductC2(){
			...
		}
	}

这里的AbstractFactory也可以使用interface的形式来写，看情况需求了。

定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类

首先让我们来了解一下简单工厂，简单工厂在我们实际使用中出现的非常频繁，以至于并没有把它定义为一种设计模式，而是把它当做一种惯例：

<?php
	interface Pizza() {
		public function make();
	}

	class CheesePizza implements Pizza {
		public function make() {
			//return a CheesePizza;
		}
	}

	class ClamPizza implements Pizza {
		public function make() {
			//return a ClamPizza;
		}
	}
	//简单工厂
	class SimpleFactory {
		private $pizza;

		public function createPizza ($type) {
			switch ($type) {
				case 'cheese' :
					$pizza = new CheesePizza();
				break;

				case 'clam' :
					$pizza = new ClamPizza();
				break;
				default:
					$pizza = null;
			}

			return $pizza;
		}
	}

	//使用简单工厂
	class PizzaStore {
		private $factory;

		public function __construct(SimpleFactory $factory) {
			$this->factory = $factory;
		}

		public function orderPizza($type) {
			$pizza = $this->factory->createPizza($type);
			if($pizza) {
				$pizza->make();
			}
			return $pizza;
		}

	}

——————————–我是蛋疼的分割线——————————–

现在让我们忘了上面的例子，看一下工厂方法：

<?php
	interface Pizza() {
		public function make();
	}
	//中国风味的CheesePizza
	class CnCheesePizza implements Pizza {
		public function make() {
			//return a CnCheesePizza;
		}
	}
	//中国风味的ClamPizza
	class CnClamPizza implements Pizza {
		public function make() {
			//return a CnClamPizza;
		}
	}
	//美国风味的CheesePizza
	class UsCheesePizza implements Pizza {
		public function make() {
			//return a UsCheesePizza;
		}
	}
	//美国风味的ClamPizza
	class UsClamPizza implements Pizza {
		public function make() {
			//return a UsClamPizza;
		}
	}

	abstract class PizzaStore {

		public function orderPizza($type) {
			$pizza = $this->createPizza($type);
			if($pizza) {
				$pizza->make();
			}
			return $pizza;
		}
		//工厂方法
		protected abstract function createPizza ($type);

	}

	//我们来到一家中国风的Pizza店
	class CnPizzaStore extends PizzaStore  {
		protected function createPizza ($type) {
			switch ($type) {
				case 'cheese' :
					$pizza = new CnCheesePizza();
				break;

				case 'clam' :
					$pizza = new CnClamPizza();
				break;
				default:
					$pizza = null;
			}
			return $pizza;
		}
	}

	//我们来到一家美国风的Pizza店
	class UsPizzaStore extends PizzaStore  {
		protected function createPizza ($type) {
			switch ($type) {
				case 'cheese' :
					$pizza = new UsCheesePizza();
				break;

				case 'clam' :
					$pizza = new UsClamPizza();
				break;
				default:
					$pizza = null;
			}
			return $pizza;
		}
	}

工厂方法用来处理对象的创建，并将这样行为封装在子类中。选择哪个子类，就意味着选着了哪种创建方式。

//return a product object
//工厂方法是抽象的，让子类去实现
abstract factoryMethod($type);

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

最近因为工作变动的原因，很久没有更新博客了，这两天终于缓下来，继续完成我的设计模式篇。
今天要讨论的是，观察者模式，这是一个很容易理解的模式，不过大道至简，如独狐九剑，一刺一挑在对方的弱点上，往往能发挥最强的威力…高手飞花拈叶匀能伤人…老人挤公交往往是一把好手…（举个例子，插件机制用此模式浑然天成）。

以上纯属废(hui)话，接下来进入正题：

先看UML：

《img 占位 哥还没找到好看的UML工具》

我看来看下原生态的代码：

<?php
	interface Subject {
		public function attach(Observer $observer);
		public function detach(Observer $observer);
		public function notify();
	}
	interface Observer {
		public function update(Subject $subject);
	}

	class DemoSubject implements Subject {

		private $observers;

		public function __construct() {
			$this->observers = array();
		}

		public function attach(Observer $observer) {
			$this->observers[] = $observer;
		}

		public function detach(Observer $observer) {
			if($idx = array_search($observer, $this->observers, true)) {
				unset($this->observers[$idx]);
			}
		}

		public function notify() {
			foreach($this->observers as $observer) {
				$observer->update($this);
			}
		}
	}

	class DemoObserver implements Observer {
		public function update(Subject $subject){
			//doSometing;
			//echo 'update!';
		}
	}

我们把echo ‘update’;这个注释去掉测试一下

$subject = new DemoSubject();
$observer = new DemoObserver();
$subject->attach($observer);
$subject->notify();

更具威力的是当你有DemoObserver1，DemoObserver2…DemoObserverN时，只要你注册到Subject中，都能在notify时候被通知道，并且代码具有最小藕合与扩展的灵活性；
————————我是蛋疼的分割线————————
刚刚我们讲到的是我们手动实现的两个接口类，其实PHP5中已经有内置的主题/观察者接口，他的原型如下：

<?php
        //http://cn.php.net/manual/en/class.splsubject.php
	interface SplSubject {
		public function attach(SplObserver $observer);
		public function detach(SplObserver $observer);
		public function notify();
	}
        //http://cn.php.net/manual/en/class.splobserver.php
	interface SplObserver {
		public function update(SplSubject $subject);
	}

于是我们可以不用自己去写接口，而是直接使用内置接口：

<?php
	class DemoSubject implements SplSubject {

		private $observers;

		public function __construct() {
			$this->observers = array();
		}

		public function attach(SplObserver $observer) {
			$this->observers[] = $observer;
		}

		public function detach(SplObserver $observer) {
			if($idx = array_search($observer, $this->observers, true)) {
				unset($this->observers[$idx]);
			}
		}

		public function notify() {
			foreach($this->observers as $observer) {
				$observer->update($this);
			}
		}
	}

	class DemoObserver implements SplObserver {
		public function update(SplSubject $subject){
			//doSometing;
			//echo 'update!';
		}
	}

纸上得来终觉浅，绝知此事要躬行。等把这一系列文章写完后，会写几篇文章描述在实际编码中如何去使用此模式。