php 设计模式，设计模式

php 设计模式，设计模式

几个模式简述：

1、工厂模式

工厂模式 是一种类，它具有为您创建对象的某些方法。

您可以使用工厂类创建对象，而不直接使用 new。这样，如果您想要更改所创建的对象类型，只需更改该工厂即可。使用该工厂的所有代码会自动更改。　　

系统某个部分中的函数和类严重依赖于系统的其他部分中函数和类的行为和结构。

您需要一组模式，使这些类能够相互通信，但不希望将它们紧密绑定在一起，以避免出现联锁。

在大型系统中，许多代码依赖于少数几个关键类。需要更改这些类时，可能会出现困难。

2、单元素模式

某些应用程序资源是独占的，因为有且只有一个此类型的资源。

例如，通过数据库句柄到数据库的连接是独占的。

您希望在应用程序中共享数据库句柄，因为在保持连接打开或关闭时，它是一种开销，在获取单个页面的过程中更是如此。

3、观察者模式

观察者模式为您提供了避免组件之间紧密耦合的另一种方法。

该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者 注册自己）使本身变得可观察。

当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可 以相互对话，而不必了解原因。

4、命令链模式

命令链 模式以松散耦合主题为基础，发送消息、命令和请求，或通过一组处理程序发送任意内容。

每个处理程序都会自行判断自己能否处理请求。如果可以，该请求被处理，进程停止。您可以为系统添加或移除处理程序，而不影响其他处理程序。

5、策略模式

我们讲述的最后一个设计模式是策略 模式。在此模式中，算法是从复杂类提取的，因而可以方便地替换。

例如，如果要更改搜索引擎中排列页的方法，则策略模式是一个不错的选择。

思考一下搜索引擎 的几个部分 —— 一部分遍历页面，一部分对每页排列，另一部分基于排列的结果排序。

在复杂的示例中，这些部分都在同一个类中。通过使用策略模式，您可将排列部分放入另一个 类中，以便更改页排列的方式，而不影响搜索引擎的其余代码。

常用模式详解：

1、 单例模式（三私一公）

①、私有的构造方法 (访问控制：防止外部代码使用new操作符创建对象，单例类不能在其他类中实例化，只能被其自身实例化)

②、私有的静态属性 (拥有一个保存类的实例的静态成员变量)

③、私有的克隆方法 (拥有一个访问这个实例的公共的静态方法，常用getInstance()方法进行实例化单例类，通过instanceof操作符可以检测到类是否已经被实例化)

④、公有的静态方法 (防止对象被复制)

所谓单例模式，也就是在任何时候，应用程序中只会有这个类的一个实例存在。

常见的，我们用到单例模式只让一个对象去访问数据库，从而防止打开多个数据库连接。

要实现一个单例类应包括以下几点：

和普通类不同，单例类不能被直接实例化，只能是由自身实例化。因此，要获得这样的限制效果，构造函数必须标记为private。 

要让单例类不被直接实例化而能起到作用，就必须为其提供这样的一个实例。

因此，就必须要让单例类拥有一个能保存类的实例的私有静态成员变量和对应的一个能访问到实例的公共静态方法。 

在PHP中，为防止对单例类对象的克隆来打破单例类的上述实现形式，通常还为基提供一个空的私有__clone()方法。 

下面是一个基本的单例模式：

class SingetonBasic {

    private static $instance;

    private function __construct() {

        // do construct..

    }

    private function __clone() {}

    public static function getInstance() {

        if (!(self::$instance instanceof self)) {

            self::$instance = new self();

        }

        return self::$instance;

}

}

$a = SingetonBasic::getInstance();

$b = SingetonBasic::getInstance();

var_dump($a === $b);

2、工厂模式

工厂模式在于可以根据输入参数或者应用程序配置的不同来创建一种专门用来实现化并返回其它类的实例的类。下面是一个最基本的工厂模式：

class FactoryBasic {

    public static function create($config) {

    }

}

比如这里是一个描述形状对象的工厂，它希望根据传入的参数个数不同来创建不同的形状。

// 定义形状的公共功能：获取周长和面积。

interface IShape {

    function getCircum();

    function getArea();

}

// 定义矩形类

class Rectangle implements IShape {

    private $width, $height;

    public function __construct($width, $height) {

        $this->width = $width;

        $this->height = $height;

    }

    public function getCircum() {

        return 2 * ($this->width + $this->height);

    }

    public function getArea() {

        return $this->width * $this->height;

    }

}

// 定义圆类

class Circle implements IShape {

    private $radii;

    public function __construct($radii) {

        $this->radii = $radii;

    }

    public function getCircum() {

        return 2 * M_PI * $this->radii;

    }

    public function getArea() {

        return M_PI * pow($this->radii, 2);

    }

}

// 根据传入的参数个数不同来创建不同的形状。

class FactoryShape {

    public static function create() {

        switch (func_num_args()) {

            case 1:

                return new Circle(func_get_arg(0));

                break;

            case 2:

                return new Rectangle(func_get_arg(0), func_get_arg(1));

                break;

        }

    }

}

// 矩形对象

$c = FactoryShape::create(4, 2);

var_dump($c->getArea());

// 圆对象

$o = FactoryShape::create(2);

var_dump($o->getArea());

使用工厂模式使得在调用方法时变得更容易，因为它只有一个类和一个方法，若没有使用工厂模式，则要在调用时决定应该调用哪个类和哪个方法；

使用工厂模式还使得未来对应用程序做改变时更加容易，比如要增加一种形状的支持，只需要修改工厂类中的create()一个方法，而没有使用工厂模式，则要修改调用形状的代码块。

3、观察者模式

观察者模式为您提供了避免组件之间紧密耦合的另一种方法。

该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者注册自己）使本身变得可观察。

当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可以相互对话，而不必了解原因。

一个简单的示例：当听众在收听电台时（即电台加入一个新听众），它将发送出一条提示消息，通过发送消息的日志观察者可以观察这些消息。

// 观察者接口

interface IObserver {

    function onListen($sender, $args);

    function getName();

}

// 可被观察接口

interface IObservable {

    function addObserver($observer);

    function removeObserver($observer_name);

}

// 观察者类

abstract class Observer implements IObserver {

    protected $name;

    public function getName() {

        return $this->name;

    }

}

// 可被观察类

class Observable implements IObservable {

    protected $observers = array();

    public function addObserver($observer) {

        if (!($observer instanceof IObserver)) {

            return;

        }

        $this->observers[] = $observer;

    }

    public function removeObserver($observer_name) {

        foreach ($this->observers as $index => $observer) {

            if ($observer->getName() === $observer_name) {

                array_splice($this->observers, $index, 1);

                return;

            }

        }

    }

}

// 模拟一个可以被观察的类：RadioStation

class RadioStation extends Observable {

    public function addListener($listener) {

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

            $observer->onListen($this, $listener);

        }

    }

}

// 模拟一个观察者类

class RadioStationLogger extends Observer {

    protected $name = 'logger';

    public function onListen($sender, $args) {

        echo $args, ' join the radiostation.
';

    }

}

// 模拟另外一个观察者类

class OtherObserver extends Observer {

    protected $name = 'other';

    public function onListen($sender, $args) {

        echo 'other observer..
';

    }

}

$rs = new RadioStation();

// 注入观察者

$rs->addObserver(new RadioStationLogger());

$rs->addObserver(new OtherObserver());

// 移除观察者

$rs->removeObserver('other');

// 可以看到观察到的信息

$rs->addListener('cctv');