php设计模式

<?php


/***
 * 抽象工厂
 * 意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
 * 主要解决：主要解决接口选择的问题。
 * 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
 * 如何解决：在一个产品族里面，定义多个产品。
 * 关键代码：在一个工厂里聚合多个同类产品。
 * 应用实例：工作了，为了参加一些聚会，肯定有两套或多套衣服吧，比如说有商务装（成套，一系列具体产品）、时尚装（成套，一系列具体产品），甚至对于一个家庭来说，可能有商务女装、商务男装、时尚女装、时尚男装，这些也都是成套的，即一系列具体产品。假设一种情况（现实中是不存在的，要不然，没法进入共产主义了，但有利于说明抽象工厂模式），在您的家中，某一个衣柜（具体工厂）只能存放某一种这样的衣服（成套，一系列具体产品），每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解，所有的衣柜（具体工厂）都是衣柜类的（抽象工厂）某一个，而每一件成套的衣服又包括具体的上衣（某一具体产品），裤子（某一具体产品），这些具体的上衣其实也都是上衣（抽象产品），具体的裤子也都是裤子（另一个抽象产品）。
 * 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
 * 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。
 * 使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。
 * 注意事项：产品族难扩展，产品等级易扩展。
 */

interface shape
{
    public function draw();
}

class square implements shape
{
    function draw()
    {
        echo "square::draw()";
    }
}
class circle implements shape
{
    function draw()
    {
        echo "circle::draw()";
    }
}



interface color
{
    public function fill();
}

class red implements color
{
    function fill()
    {
        echo "red::fill()";
    }
}

class blue implements color
{
    function fill()
    {
        echo "blue::fill()";
    }
}



abstract class abstractFactory
{
    abstract function getColor($color);
    abstract function getShape($shape);
}


class shapeFactory extends abstractFactory
{
    // overwrite
    public function getColor($color)
    { }

    public function getShape($shape)
    {
        if ($shape == 'circle') {
            return new circle();
        } else if ($shape == 'square') {
            return new square();
        }
    }
}

class colorFactory extends abstractFactory
{
    public function getColor($color)
    {
        if ($color == 'red') {
            return new red();
        } else if ($color == 'blue') {
            return new blue();
        }
    }

    // overwrite
    public function getShape($shape)
    { }
}


class factoryProducer
{
    public static function getFactory($choice)
    {
        if ($choice == 'color') {
            return new colorFactory;
        } else if ($choice == 'shape') {
            return new shapeFactory;
        }
    }
}


$shapeFac = factoryProducer::getFactory('shape');
$shape = $shapeFac->getShape('circle');
$shape->draw();


$colorFac = factoryProducer::getFactory('color');
$color = $colorFac->getColor('red');

$color->fill();

---

<?php


/**
 * 建造者
 * 意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
 * 主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
 * 何时使用：一些基本部件不会变，而其组合经常变化的时候。
 * 如何解决：将变与不变分离开。
 * 关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
 * 应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。
 * 优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
 * 缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
 * 使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
 * 注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
 * 
 */


interface packing
{
    public function pack();
}

class bottle implements packing
{
    public function pack()
    {
        echo "-bottle-";
    }
}

class wrapper implements packing
{
    public function pack()
    {
        echo "-wrapper-";
    }
}


interface item
{
    public function name();
    public function packing();
    public function price();
}

abstract class Burger implements item
{
    public function packing()
    {
        return new wrapper();
    }
}

abstract class drink implements item
{
    public function packing()
    {
        return new bottle();
    }
}

class vegBurger extends Burger
{
    public function name()
    {
        echo "vegBurger";
    }

    public function price()
    {
        echo 0.2;
    }
}

class chickenBurger extends Burger
{
    public function name()
    {
        echo "checkenBurger";
    }

    public function price()
    {
        echo 0.1;
    }
}

class Pepsi extends drink
{
    public function price()
    {
        echo 0.3;
    }
    public function name()
    {
        echo "Pepsi";
    }
}


class Coke extends drink
{
    public function price()
    {
        echo 0.4;
    }
    public function name()
    {
        echo "Coke";
    }
}


class meal
{
    private $list;
    public function addItem(item $item)
    {
        $this->list[] = $item;
    }
    public function getcost()
    {
        $cost = 0;
        foreach ($this->list as $item) {
            $cost += $item->price();
        }
        return $cost;
    }
}


class Builder
{
    public function prepareVegBurger()
    {
        $meal = new meal();
        $meal->addItem(new vegBurger);
        $meal->addItem(new Pepsi);
        return $meal;
    }
}

(new Builder())->prepareVegBurger()->getcost();

---

<?php

/***
 * 装饰器模式
 * 意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
 * 主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
 * 何时使用：在不想增加很多子类的情况下扩展类。
 * 如何解决：将具体功能职责划分，同时继承装饰者模式。
 * 关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。
 * 应用实例： 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。
 * 优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
 * 缺点：多层装饰比较复杂。
 * 使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。
 * 注意事项：可代替继承。
 * 
 */

interface shape
{
    public function draw();
}

class rectangle implements shape
{
    public function draw()
    {
        echo "shape:rectangle\n";
    }
}

class circle implements shape
{
    public function draw()
    {
        echo "shape:circle\n";
    }
}

abstract class shapeDecorate implements shape
{
    protected $decorateShape;

    public function __construct(shape $decorateShape)
    {
        $this->decorateShape = $decorateShape;
    }

    public function draw()
    {
        $this->decorateShape->draw();
    }
}

class redShapeDecorator extends shapeDecorate
{
    public function __construct(shape $shape)
    {
        parent::__construct($shape);
    }

    public function draw()
    {
        $this->decorateShape->draw(); // 实现子类功能，替代继承
        $this->setRedBorder($this->decorateShape);  // 扩展功能
    }

    public function setRedBorder(shape $decorateShape)
    {
        echo "Border Color: Red\n";
    }
}


//$circle = new circle;
//$redCircle = new redShapeDecorator(new circle);
$redRectangle = new redShapeDecorator(new rectangle);
//$circle->draw();
//$redCircle->draw();
$redRectangle->draw();

---

<?php

/***
 * 
 * 工厂模式
 * 意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
 * 主要解决：主要解决接口选择的问题。
 * 何时使用：我们明确地计划不同条件下创建不同实例时。
 * 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
 * 关键代码：创建过程在其子类执行。
 * 优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了【 如$shap = $factory->getShape('circle'); 】。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。
 * 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
 * 使用场景：【有多个功能相近的服务可选择时】 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 
 */


interface shape
{
    public function draw();
}

class Rectangle implements shape
{
    public function draw()
    {
        echo "Rectangle::draw()";
    }
}

class Circle implements shape
{
    public function draw()
    {
        echo "Circle::draw()";
    }
}

class shapeFactory
{
    public function getShape($shape)
    {
        if ($shape == 'circle') {
            return new Circle();
        } else if ($shape == 'rectangle') {
            return new Rectangle();
        } else {
            echo 'error';
            return false;
        }
    }
}

$factory = new shapeFactory;

$shap = $factory->getShape('circle');
$shap->draw();

---

<?php

/***
 * 观察者模式
 * 意图：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
 * 主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
 * 何时使用：一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。
 * 如何解决：使用面向对象技术，可以将这种依赖关系弱化。
 * 关键代码：在抽象类里有一个 ArrayList 存放观察者们。
 * 应用实例： 1、拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。 2、西游记里面悟空请求菩萨降服红孩儿，菩萨洒了一地水招来一个老乌龟，这个乌龟就是观察者，他观察菩萨洒水这个动作。
 * 优点： 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。
 * 缺点： 1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。
 * 
 */

abstract class subject
{
    private $observers =  array();

    public function addObserver(observer $observer)
    {
        $this->observers[] = $observer;
        echo "添加观察者成功\n";
    }
    public function delObserver(observer $observer)
    {
        $key = array_search($observer, $this->observers);
        if ($observer === $this->observers[$key]) {
            unset($this->observers[$key]);
            echo "删除成功";
        } else {
            echo "不存在";
        }
    }

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


class server extends subject
{
    public function publish()
    {
        echo "发现更新包";
        $this->notifyObservers();
    }
}

interface observer
{
    public function update();
}

class wechat implements observer
{
    public function update()
    {
        echo "微信更新";
    }
}

class web implements observer
{
    public function update()
    {
        echo "web更新";
    }
}
class app implements observer
{
    public function update()
    {
        echo "app更新";
    }
}
$server = new server;
$server->addObserver(new web);
$server->addObserver(new app);
$server->addObserver(new wechat);
$server->publish();

---

<?php

/**
 * 原型模式
 * 意图：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
 * 主要解决：在运行期建立和删除原型。
 * 如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。
 * 优点： 1、性能提高。 2、逃避构造函数的约束。
 * 缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 
 */

abstract class prototype
{
    abstract function __clone();
}

class map extends prototype
{
    public $width;

    public $height;

    public $sea;

    public function setAttribute(array $attributes)
    {
        foreach ($attributes as $key => $val) {
            $this->$key = $val;
        }
    }

    public function __clone()
    { }
}

class sea
{
    public $color = 'red';

    public function setcolor($color)
    {
        $this->color = $color;
    }
}

$map_prototype = new map();
$attributes = array('width' => 40, 'height' => 60, 'sea' => (new sea()));
$map_prototype->setAttribute($attributes);

$new_map = clone $map_prototype;

// 这是一个浅拷贝的例子
var_dump($new_map); // red
var_dump($map_prototype); // red
$map_prototype->sea->setcolor('blue');
var_dump($map_prototype);  // blue
var_dump($new_map); // blue

// 鉴于上面的案例，拷贝需要深拷贝

class Map1 extends Prototype
{
    public $clone_id = 0;
    public $width;
    public $height;
    public $sea;
    public function setAttribute(array $attributes)
    {
        foreach ($attributes as $key => $val) {
            $this->$key = $val;
        }
    }
    //实现克隆方法，用来实现深拷贝
    public function __clone()
    {
        $this->sea = clone $this->sea;
    }
}

---

<?php

/**
 * 
 * 意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
 * 主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。
 * 何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。
 * 如何解决：将这些算法封装成一个一个的类，任意地替换。
 * 关键代码：实现同一个接口。
 * 应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。
 * 优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。
 * 缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。
 * 使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。
 * 注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。
 */


interface strategy
{
    public function doOperation($num1, $num2);
}

class add implements strategy
{
    public function doOperation($num1, $num2)
    {
        return $num1 + $num2;
    }
}


class multiply implements strategy
{
    public function doOperation($num1, $num2)
    {
        return $num1 * $num2;
    }
}


class substract implements strategy
{
    public function doOperation($num1, $num2)
    {
        return $num1 - $num2;
    }
}


class context
{
    private $strategy;
    public function __construct(strategy $strategy)
    {
        $this->strategy = $strategy;
    }

    public function executeStrategy($num1, $num2)
    {
        return $this->strategy->doOperation($num1, $num2);
    }
}

$context = new context(new add());
echo $context->executeStrategy(20, 3);

// laravel中间件的实现原理：管道模式

<?php

/**
 * array_reduce 返回值为匿名函数返回值
 * $v1 初始值是initValue值（默认null），之后是前一次迭代的返回值
 * $v2 是数组每一项的值
 */

$a = array("Dog", "Cat", "Horse", 'AAA', 'BBB', 'CCC', 'DDD', 'EEE');
print_r(
    array_reduce($a, function ($v1, $v2) {
        var_dump($v1);
        return $v1 . "-" . $v2;
    }, 'initValue')
);


#############################################################################################


/**
 * Laravel中间件，管道之面向切面编程
 */

interface Middleware
{
    public static function handle(Closure $next);
}

class VerfiyCsrfToken implements Middleware
{
    public static function handle(Closure $next)
    {
        echo "Token";
        $next();
    }
}

class VerfiyAuth implements Middleware
{
    public static function handle(Closure $next)
    {
        echo "Auth";
        $next();
    }
}

class SetCookie implements Middleware
{
    public static function handle(Closure $next)
    {
        $next();
        echo "Cookie";
    }
}


// 实例一，不好扩展和维护的代码
function call_middware()
{
    SetCookie::handle(function () {
        VerfiyAuth::handle(function () {
            VerfiyCsrfToken::handle(function () {
                echo "执行";
            });
        });
    });
}

call_middware();



// 实例二
// 定义管道处理方法 ,使用array_reduce递归调用
$pop_arr = [
    'VerfiyCsrfToken',
    'VerfiyAuth',
    'SetCookie'
];

$handle = function () {
    echo '当前要执行的程序!';
};

// 可以使用foreach实现管道模式，管道模式的实质： 本次迭代可以加工上次迭代的结果 .
$callback = array_reduce($pop_arr, function ($stack, $pipe) {
    return function () use ($stack, $pipe) {
        return $pipe::handle($stack);
    };
}, $handle);

// var_dump($callback);

call_user_func($callback);