php设计模式专题附源码（适配器模式、模板模式、命令模式、单例模式、观察者模式）

 /**
  *适配器模式*
  *将一个类的接口转换成客户希望的另外一个接口,使用原本不兼容的而不能在一起工作的那些类可以在一起工作*/
 //这个是原有的类型
 class OldCache{
     public function __construct()
     {
         echo "Old Cache construct";
     }
     public function store($key, $value)
     {
         echo "Old Cache store";
     }
     public function remove($key)
     {
         echo "Old Cache remove";
     }
     public function fetch($key)
     {
         echo "Old Cache fetch";
     }
 }
 interface Cacheable
 {
     public function set($key, $value);
     public function get($key);
     public function del($key);
 }
 class OldCacheAdapter implements Cacheable
 {
     private $_cache = null;

     public function __construct()
     {
         $this->_cache = new OldCache();
     }
     public function set($key, $value)
     {
         return $this->_cache->store($key, $value);
     }
     public function get($key)
     {
         return $this->_cache->fetch($key);
     }
     public function del($key)
     {
         return $this->_cache->remove($key);
     }
 }
 $objCache = new OldCacheAdapter();
 $objCache->set("test", 1);
 $objCache->get("test");
 $objCache->del("test", 1);

 /**
  *模板模式*
  *定义一个操作中的算法骨架,而将一些步骤延迟到子类中,
  * 使得子类可以不改变一个算法的结构可以定义该算法的某些特定步骤**/

 abstract class TemplateBase
 {
     public function Method1()
     {
         echo "abstract Method1";
     }
     public function Method2()
     {
         echo "abstract Method2";
     }
     public function Method3()
     {
         echo "abstract Method3";
     }
     public function doSomeThing()
     {
         $this->Method1();
         $this->Method2();
         $this->Method3();
     }
 }
 class TemplateObject extends TemplateBase
 {
 }
 class TemplateObject1 extends TemplateBase
 {
     public function Method3()
     {
         echo "Template Object1 Method3";
     }
 }
 class TemplateObject2 extends TemplateBase
 {
     public function Method2()
     {
         echo "Template Object2 Method2";
     }
 }
 //实例化
 $objTemplate = new TemplateObject();
 $objTemplate1 = new TemplateObject1();
 $objTemplate2 = new TemplateObject2();
 $objTemplate->doSomeThing();
 $objTemplate1->doSomeThing();
 $objTemplate2->doSomeThing();

 /**
  *命令模式*
  *将一个请求封装为一个对象从而使你可用不同的请求对客户进行参数化,
  * 对请求排除或记录请求日志,以及支持可取消的操作*/
 interface Command
 {
     public function execute();
 }
 class Invoker
 {
     private $_command = array();
     public function setCommand($command)
     {
         $this->_command[] = $command;
     }
     public function executeCommand()
     {
         foreach ($this->_command as $command) {
             $command->execute();
         }
     }
     public function removeCommand($command)
     {
         $key = array_search($command, $this->_command);
         if ($key !== false) {
             unset($this->_command[$key]);
         }
     }
 }
 class Receiver
 {
     private $_name = null;

     public function __construct($name)
     {
         $this->_name = $name;
     }
     public function action()
     {
         echo $this->_name . "action";
     }
     public function action1()
     {
         echo $this->_name . "action1";
     }
 }
 class ConcreteCommand implements Command
 {
     private $_receiver;
     public function __construct($receiver)
     {
         $this->_receiver = $receiver;
     }
     public function execute()
     {
         $this->_receiver->action();
     }
 }
 class ConcreteCommand1 implements Command
 {
     private $_receiver;
     public function __construct($receiver)
     {
         $this->_receiver = $receiver;
     }
     public function execute()
     {
         $this->_receiver->action1();
     }
 }
 class ConcreteCommand2 implements Command
 {
     private $_receiver;
     public function __construct($receiver)
     {
         $this->_receiver = $receiver;
     }
     public function execute()
     {
         $this->_receiver->action();
         $this->_receiver->action1();
     }
 }
 $objRecevier = new Receiver("No.1");
 $objRecevier1 = new Receiver("No.2");
 $objRecevier2 = new Receiver("No.3");
 $objCommand = new ConcreteCommand($objRecevier);
 $objCommand1 = new ConcreteCommand1($objRecevier);
 $objCommand2 = new ConcreteCommand($objRecevier1);
 $objCommand3 = new ConcreteCommand1($objRecevier1);
 $objCommand4 = new ConcreteCommand2($objRecevier2); //使用Recevier的两个方法
 $objInvoker = new Invoker();
 $objInvoker->setCommand($objCommand);
 $objInvoker->setCommand($objCommand1);
 $objInvoker->executeCommand();
 $objInvoker->removeCommand($objCommand1);
 $objInvoker->executeCommand();
 $objInvoker->setCommand($objCommand2);
 $objInvoker->setCommand($objCommand3);

 /**
  *单例模式*
  *保证一个类仅有一个实例,并提供一个访问它的全局访问点
  **/
 class Singleton
 {
     static private $_instance = null;
     private function __construct()
     {

     }
     static public function getInstance()
     {
         if (is_null(self::$_instance)) {
             self::$_instance = new Singleton();
         }
         return self::$_instance;
     }
     public function display()
     {
         echo "it is a singlton class function";
     }
 }
 //$obj=new Singleton();
 //声明不能成功$obj=Singleton::getInstance();var_dump($obj);$obj->display();
 $obj1 = Singleton::getInstance();

 /**
  *观察者模式*
  *定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新
  *能够便利地创建查看目标对象状态的对象,并且提供与核心对象非耦合的指定功能
  *插件系统*/
 class Observerable
 {
     private $_observers = array();

     public function registerObserver($observer)
     {
         $this->_observers[] = $observer;
     }
     public function removeObserver($observer)
     {
         $key = array_search($observer, $this->_observers);
         if (!($key === false)) {
             unset($this->_observers[$key]);
         }
     }
     public function notifyObservers()
     {
         foreach ($this->_observers as $observer) {
             if ($observer instanceof Observer)
                 $observer->update($this);
         }
     }
 }
 interface Observer
 {
     public function update($observer);
 }
 interface DisplayElement
 {
     public function display();
 }
 //--实例类定义
 class NewsObserverable extends Observerable
 {
     private $_sports_news;
     public function setSportsNews($data)
     {
         $this->_sports_news = $data;
         $this->notifyObservers();
     }
     public function getSportsNews()
     {
         return $this->_sports_news;
     }
     private $_local_news;
     public function setLocalNews($data)
     {
         $this->_local_news = $data;
         $this->notifyObservers();
     }
     public function getLocalNews()
     {
         return $this->_local_news;
     }
 }
 class SportsNews implements Observer, DisplayElement
 {
     private $_data = null;
     public function update($observer)
     {
         if ($this->_data != $observer->getSportsNews()) {
             $this->_data = $observer->getSportsNews();
             $this->display();
         }
     }
     public function display()
     {
         echo $this->_data . date("Y-m-d H:i:s") . "";
     }
 }
 class LocalNews implements Observer, DisplayElement
 {
     private $_data = null;
     public function update($observer)
     {
         if ($this->_data != $observer->getLocalNews()) {
             $this->_data = $observer->getLocalNews();
             $this->display();
         }
     }
     public function display()
     {
         echo $this->_data . date("Y-m-d H:i:s") . "";
     }
 }
 //--实例化---
 $objObserver = new NewsObserverable();
 $local = new LocalNews();
 $sports = new SportsNews();
 $objObserver->registerObserver($local);
 $objObserver->registerObserver($sports);
 $objObserver->setSportsNews("sportsnews1");
 $objObserver->setLocalNews("localnews1");
 $objObserver->removeObserver($sports);
 $objObserver->setLocalNews("localnews2");
 $objObserver->setSportsNews("sportsnews2");
 $objObserver->removeObserver($local);
 $objObserver->setLocalNews("localnews3");