php 设计模式

什么是设计模式：

设计模式就是一个教你如何利用真实可靠的设计来组织你的代码的模板。

所有的设计模式都有一些常用的特性：一个标识（a name），一个问题陈述（a problem statement）和一个解决方案(a solution)。

1、一个设计模式的标识是重要的，因为它会让其他的程序员不用进行太深入的学习就能立刻理解你的代码的目的（至少通过这个标识程序员会很熟悉这个模式）。

2、问题描述是用来说明这个模式的应用的领域。

3、解决方案描述了这个模型的执行。一个好的设计模式的论述应该覆盖使用这个模型的优点和缺点。

比如，你从店铺里面买的一件衬衫是一个代码库，它的颜色，样式和大小都由设计师和厂商决定，但它满足了你的需求。然而，如果店里面没有什么衣服适合你，那你就能自己创建自己的衬衫（设计它的形状，选择布料，然后裁缝在一起）。但是如果你不是一个裁缝，你可能会发现自己很容易的去找一个合适的模式然后按着这个模式去设计自己的衬衫。使用一个模型，你可以在更少的时间内得到一个熟练设计的衬衫。

php一共有传统的23种设计模式，

Interpreter(解释器模式)，Factory(工厂模式)，Facade(外观模式)，Decorator(装饰模式)，Builder(建造者模式)

Adapter(适配器模式)，Template (模板模式)，Command(命令链模式)，Singleton(单例模式)，Observer(观察者模式)

Strategy(策略模式)，Visitor (访问者模式)，Memento (备忘录模式)，Prototype (原型模式)，Mediator (中介者模式)

FlyWeight (享元模式)，Chain Of Responsibility (职责链模式)，Bridge (桥接模式)，Proxy (代理模式)，State (状态模式)

Composite (组合模式)，Interator (迭代器模式)，DAO(数据访问对象模式)，Delegation(委托模式)

其中有五种php常见的设计模式

1.工厂模式 2.单例模式（单元素模式）3.观察者模式 4.命令链模式 5.策略模式

什么是耦合：

　　　耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决与模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分摸块的一个准则就是高内聚低耦合

工厂模式：

工厂模式的最大优点在于创建对象上面，就是把创建对象的过程封装起来，这样随时可以产生一个新的对象。

减少代码进行复制粘帖，耦合关系重，牵一发动其他部分代码。

通俗的说，以前创建一个对象要使用new，现在把这个过程封装起来了。

假设不使用工厂模式：那么很多地方调用类a，代码就会这样子创建一个实例：new a(),假设某天需要把a类的名称修改，意味着很多调用的代码都要修改。

建立一个工厂（一个函数或一个类方法）来制造新的对象,它的任务就是把对象的创建过程都封装起来，

创建对象不是使用new的形式了。而是定义一个方法，用于创建对象实例。

    工厂方法：

比如你的工厂叫做“香烟工厂”，那么可以有“七匹狼工厂”“中华工厂”等，但是，这个工厂只生厂一种商品：香烟；

抽象工厂：无法描述它到底生产什么产品，它生产很多类型的产品(所以抽象工厂就会生成子工厂)。

你的工厂是综合型的，是生产“一系列”产品，而不是“一个”，比如：生产“香烟”，还有“啤酒”等。然后它也可以有派生出来的具体的工厂，但这些工厂都是生产这一系列产 品，只是可能因为地域不一样，为了适应当地人口味，味道也不太一样。

工厂模式：理解成只生成一种产品的工厂。比如生产香烟的。

工厂方法：工厂的一种产品生产线 。比如键盘的生成过程。

< php

/**

 * 工厂方法模式

 *

 * 定义一个用于创建对象的接口,让子类决定将哪一个类实例化,使用一个类的实例化延迟到其子类

*/

/*

class DBFactory

{

    public static function create($type)

    {

        swtich($type)

        {

            case "Mysql":

                return new MysqlDB(); break;

            case "Postgre":

                return new PostgreDB(); break;

            case "Mssql":

                return new MssqlDB(); break;

        }

    }

}

*/

class DBFactory

{

　　　publicstaticfunction create($type)

    {

　　　$class=$type."DB";

　　　returnnew$class;

    }

}

interface DB

{

　　　publicfunction connect();

　　　publicfunctionexec();

}

class MysqlDB implements DB

{

　　　publicfunction __construct() {

　　　echo"mysql db<br/>";

    }

　　　publicfunction connect() {

    }

　　　publicfunctionexec() {

    }

}

class PostgreDB implements DB

{

　　　publicfunction __construct() {

　　　echo"Postgre db<br/>";

    }

　　　publicfunction connect() {

　　　}

　　　publicfunctionexec() {

     } 

} 

class MssqlDB implements DB

{

　　　publicfunction __construct() {

　　　echo"mssql db<br/>";

    }

　　　publicfunction connect() {

    }

　　　publicfunctionexec() {

    }

}

$oMysql= DBFactory::create("Mysql");

$oPostgre= DBFactory::create("Postgre");

$oMssql= DBFactory::create("Mssql");

单例模式：

作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统全局地提供这个实例。它不会创建实例副本，而是会向单例类内部存储的实例返回一个引用。

（1）. 需要一个保存类的唯一实例的静态成员变量:private static $_instance; 

（2）. 构造函数和克隆函数必须声明为私有的，防止外部程序new类从而失去单例模式的意义:

private function __construct()   

{   

     $this->_db = pg_connect(‘xxxx‘);  

}   

private function __clone()

{ 

}

（3）. 必须提供一个访问这个实例的公共的静态方法（通常为getInstance方法），从而返回唯一实例的一个引用:

public static function getInstance()    

{    

     if(! (self::$_instance instanceof self) )   

     {    

         self::$_instance = new self();    

     }  

     return self::$_instance;    

} 

为什么要使用PHP单例模式？

1、php的应用主要在于数据库应用, 所以一个应用中会存在大量的数据库操作, 使用单例模式, 则可以避免大量的new 操作消耗的资源。

2、如果系统中需要有一个类来全局控制某些配置信息, 那么使用单例模式可以很方便的实现. 

观察者模式：

　　　观察者模式定义对象的 一对多 依赖,这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新!

　　　在观察者模式中，会改变的是主题的状态以及观察者的数目。用这个模式，你可以改变依赖于主题状态的对象，却不必改变主题。——找出程序中会变化的方面，然后将其和固定不变的方面相分离!

　　　主题和观察者都使用接口:观察者利用主题的接口向主题注册，而主题利用观察者接口通知观察者。这样可以让两者之间运作正常，又同时具有松耦合的优点! ——针对接口编程，不针对实现编程!

　　　观察者模式利用“组合”将许多观察者组合进主题中。对象(观察者——主题)之间的这种关系不是通过继承产生的，而是在运行时利用组合的方式产生的。 ——多用组合，少用继承！

<?php

/**

 * 观察者模式

 * @author: Mac

 * @date: 2012/02/22

 */

class Paper{ /* 主题    */

    private $_observers = array();

    public function register($sub){ /*  注册观察者 */

        $this->_observers[] = $sub;

    }

    public function trigger(){  /*  外部统一访问    */

        if(!empty($this->_observers)){

            foreach($this->_observers as $observer){

                $observer->update();

            }

        }

    }

}

/**

 * 观察者要实现的接口

 */

interface Observerable{

    public function update();

}

class Subscriber implements Observerable{

    public function update(){

        echo "Callback\n";

    }

}

/*  测试    */

$paper = new Paper();

$paper->register(new Subscriber());

//$paper->register(new Subscriber1());

//$paper->register(new Subscriber2());

$paper->trigger();

当新对象要填入的时候，只需要在主题(又叫可观察者)中进行注册(注册方式很多，你也可以在构造的时候，或者框架访问的接口中进行注册),然后实现代码直接在新对象的接口中进行。这降低了主题对象和观察者对象的耦合度。

命令链模式：

　　　命令链模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。如果可以，该请求被处理，进程停止。您可以为系统添加或移除处理程序，而不影响其他处理程序。

1.interface Validator  

2.{  

3.    /**  

4.     * The method could have any parameters.  

5.     * @param mixed  

6.     * @return boolean  

7.     */ 

8.    public function isValid($value);  

9.}  

10. 

11./**  

12. * ConcreteCommand.  

13. */ 

14.class MoreThanZeroValidator implements Validator  

15.{  

16.    public function isValid($value)  

17.    {  

18.        return $value > 0;  

19.    }  

20.}  

21. 

22./**  

23. * ConcreteCommand.  

24. */ 

25.class EvenValidator implements Validator  

26.{  

27.    public function isValid($value)  

28.    {  

29.        return $value % 2 == 0;  

30.    }  

31.}  

32. 

33./**  

34. * The Invoker. An implementation could store more than one  

35. * Validator if needed.  

36. */ 

37.class ArrayProcessor  

38.{  

39.    protected $_rule;  

40. 

41.    public function __construct (Validator $rule)  

42.    {  

43.        $this->_rule = $rule;  

44.    }  

45. 

46.    public function process(array $numbers)  

47.    {  

48.        foreach ($numbers as $n) {  

49.            if ($this->_rule->IsValid($n)) {  

50.                echo $n, "\n";  

51.            }  

52.        }  

53.    }  

54.}  

55. 

56.// Client code  

57.$processor = new ArrayProcessor(new EvenValidator());  

58.$processor->process(array(1, 20, 18, 5, 0, 31, 42)); 

策略模式：

　　　策略模式是对象的行为模式，用意是对一组算法的封装。动态的选择需要的算法并使用。

　　　策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性思想。

什么是多形性：

“对于面向对象的程序设计语言，多型性是第三种最基本的特征（前两种是数据抽象和继承。”

　　　“多形性”（Polymorphism）从另一个角度将接口从具体的实施细节中分离出来，亦即实现了“是什么”与“怎样做”两个模块的分离。利用多形性的概念，代码的组织以及可读性均能获得改善。此外，还能创建“易于扩展”的程序。无论在项目的创建过程中，还是在需要加入新特性的时候，它们都可以方便地“成长”。

策略模式的三个角色：

1．抽象策略角色

2．具体策略角色

3．环境角色（对抽象策略角色的引用）

实现步骤：

1．定义抽象角色类（定义好各个实现的共同抽象方法）

2．定义具体策略类（具体实现父类的共同方法）

3．定义环境角色类（私有化申明抽象角色变量，重载构造方法，执行抽象方法）

策略模式的代码实例：

< php

    abstract class baseAgent { //抽象策略类

        abstract function PrintPage();

    }

    //用于客户端是IE时调用的类（环境角色）

    class ieAgent extends baseAgent {

        function PrintPage() {

            return ‘IE‘;

        }

    }

    //用于客户端不是IE时调用的类（环境角色）

    class otherAgent extends baseAgent {

        function PrintPage() {

            return ‘not IE‘;

        }

    }

    class Browser { //具体策略角色

        public function call($object) {

            return $object->PrintPage ();

        }

    }

    $bro = new Browser ();

    echo $bro->call ( new ieAgent () );

     >

就在编程领域之外，有许多例子是关于策略模式的。例如：

如果我需要在早晨从家里出发去上班，我可以有几个策略考虑：我可以乘坐地铁，乘坐公交车，走路或其它的途径。每个策略可以得到相同的结果，但是使用了不同的资源。