Laravel学习笔记-常用设计模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

1.单例模式

单例模式（Singleton Pattern）是最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

<?php
//单例模式
class Singleton {
    private $runtime;
    private static $instance;

    private function __construct() {
        $this->runtime = time();
    }

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

    public function run() {
        echo $this->runtime,PHP_EOL;
    }

    private function __clone() {
    }

    public function __destruct() {
    }
}
$a = Singleton::getInstance();
$a->run();
$b = Singleton::getInstance();
$b->run();
$c = Singleton::getInstance();
$c->run();

2.工厂模式

工厂模式（Factory Pattern）是最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

<?php
//工厂模式
abstract class Operation {
    abstract public function getValue($num1, $num2);
}

class OperationAdd extends Operation {
    public function getValue($num1, $num2) {
        return $num1 + $num2;
    }
}

class OperationSub extends Operation {
    public function getValue($num1, $num2) {
        return $num1 - $num2;
    }
}

class Factory {
    public static function createObj($operate) {
        switch ($operate) {
            case '+':
                return new OperationAdd();
                break;

            case '-':
                return new OperationSub();
                break;
        }
    }
}

$test = Factory::createObj('+');

echo $test->getValue(2, 3);

3.注册模式

<?php
//注册模式
//创建单例
class Single{
    public $hash;
    static protected $ins=null;

    final protected function __construct(){
        $this->hash=rand(1,9999);
    }

    static public function getInstance(){
        if (self::$ins instanceof self) {
            return self::$ins;
        }
        self::$ins=new self();
        return self::$ins;
    } 
}

//工厂模式
class RandFactory{
    public static function factory(){
        return Single::getInstance();
    }
}

//注册树
class Register{
    protected static $objects;
    public static function set($alias,$object){
        self::$objects[$alias]=$object;
    }
    public static function get($alias){
        return self::$objects[$alias];
    }
    public static function _unset($alias){
        unset(self::$objects[$alias]);
    }
}

Register::set('rand',RandFactory::factory());
$object=Register::get('rand');
print_r($object);

4.适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。

这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。

<?php
//适配器模式
//目标角色  
interface Target {  
    public function simpleMethod1();
    public function simpleMethod2();
}

//源角色class Adaptee {
    public function simpleMethod1(){
        echo 'Adapter simpleMethod1'."<br>";
    }
}

//类适配器角色
class Adapter implements Target {
    private $adaptee;

    function __construct(Adaptee $adaptee) {
        $this->adaptee = $adaptee;
    }

    //委派调用Adaptee的sampleMethod1方法
    public function simpleMethod1(){
        echo $this->adaptee->simpleMethod1();
    }

    public function simpleMethod2(){
        echo 'Adapter simpleMethod2'."<br>";
    }   
}

//客户端
class Client {
    public static function main() {
        $adaptee = new Adaptee();
        $adapter = new Adapter($adaptee);
        $adapter->simpleMethod1();
        $adapter->simpleMethod2();
    }
}
Client::main();

5.观察者模式

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

<?php
//观察者模式
// 主题接口
interface Subject{
    public function register(Observer $observer);
    public function notify();
}

// 观察者接口
interface Observer{
    public function watch();
}

// 主题
class Action implements Subject{
    public $_observers=array();

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

    public function notify(){
        foreach ($this->_observers as $observer) {
            $observer->watch();
        }

    }
 }

// 观察者
class Cat implements Observer{
    public function watch(){
        echo "Cat watches TV<hr/>";
    }
}

class Dog implements Observer{
    public function watch(){
        echo "Dog watches TV<hr/>";
    }
}

class People implements Observer{
    public function watch(){
        echo "People watches TV<hr/>";
    }
}

// 应用实例
$action=new Action();
$action->register(new Cat());
$action->register(new People());
$action->register(new Dog());
$action->notify();