PHP中的设计模式 <持续更新中...>

摘要：工厂模式工厂模式代码片段访问静态属性要加符静态方法生成实例对象，作为函数的参数工厂就是负责生成对象的类或方法工厂模式，是把创造者类和要生产的类分开，创建者是个工厂类，定义了用于生产产品对象的方法行程特殊的代码重复，不必要的子类话，为了工

/* 工厂模式代码片段*/
class Employee{

    private static $type = array("minion", "wellcon", "student");

    public static function recuit($name)
    {
        $num = rand(1, count(Employee::$type)) - 1 ;
        $class = Employee::$type[$num]; // 访问静态属性要加$符
        return new $class($name);
    }
}
$boss = new Boss();
$boss->addEmployee(Employee::recuit("hard")); // 静态方法生成实例对象，作为addEmployee函数的参数

工厂就是负责生成对象的类或方法

class Demo {

    public function getInstance($type)
    {
        switch($type){
            case "1":
                return new A();
                break;
            case "2":
                return new B();
                break;
            case "3":
                return new C();
                break;

        }
    }
}

工厂模式，是把创造者类和要生产的类分开，创建者是个工厂类，定义了用于生产产品对象的方法

abstract class commonMessage {

    abstract function getInstance();
}

class A extends commonMessage{

    public function getInstance()
    {
        return new A();
    }
}

class B extends commonMessage{

    public function getInstance()
    {
        return new B();
    }
}

行程特殊的代码重复，不必要的子类话，为了工厂模式，而为创建类创建子类

对于那些不必须要的子类模式，合并起来，通过一个类中多个方法就可以完成工厂输出

abstract class messageFactor
{

    abstract function getHeader();

    abstract function getMail();

    abstract function getMobile();

    abstract function getFooter();
}

class smudgeMo extends messageFactor
{

    public function getHeader()
    {
        return "Header";
    }

    public function getMail()
    {
        return new Mail();
    }

    public function getMobile()
    {
        return new Mobile();
    }

    public function getFooter()
    {
        return "Footer";
    }
}

class julylovinMo extends messageFactor
{

// 和上个子类相似
}

虽然减少了子类继承，但是耦合问题太严重，如果增加一个产品类型， 抽象函数和子类继承体，都需要增加对应的方法

abstract class factory{

    const APPT = 1;
    const TTD = 1;
    const CONTACT = 1;
    abstract function make($flag_int);
}

class mailModel extends factory{

    public function make($flag_int)
    {
        switch ($flag_int){

            case self::APPT:
                return new apptEncoder();
                break;

            case self::TTD:
                return new ttdEncoder();
                break;

            case self::CONTACT:
                return new contactEncoder();
                break;
        }


    }
}

紧凑型工厂模式，但是耦合度高，不利于维护

全局变量将类捆绑于特定环境中，破坏了封装
特点：
preference 可以被任何对象调用，无需将对象作为参数传递
preference 不该保存在全局变量中
系统中不应超过一个preference对象，即只允许实例化一次

class Preference
    {

    static $instance;
    public $name;

    private function __construct()
    {

    }

    public function setName($name)
    {
        $this->name = $name;
    }

    public function getName()
    {
        return $this->name;
    }

    public static function getInstance()
    {
        if (empty(self::$instance)) // 控制了只有一个Preference实例对象
        {
            self::$instance = new Preference();
        }
        return self::$instance;
    }
}

$prf = Preference::getInstance(); // 任何地方可以获取Preference实例对象
$prf->setName("Julylovin");
echo $prf->getName(); // Julylovin

用组合代替继承，抽象工厂模式有平行层次继承，会有耦合问题
使用clone关键词复制已经存在的产品, 具体产品本身，便成为自身生成的基础

class sea {
private $navigability = 0 ; //可航行
public function __construct($navigability)
    {
        $this->navigability = $navigability;
    }
}
class earthsea extends sea{}
class plain{}
class earthplain extends plain{}
class forest{}
class earthforest extends forest{}
class factory{

    private $sea;
    private $plain;
    private $forest;

    public function __construct(sea $sea, plain $plain, forest $forest)
    {
        $this->sea = $sea;
        $this->plain = $plain;
        $this->forest = $forest;
    }

    public function getSea()
    {
        return clone $this->sea;// 只是引用对象，是同一个对象，并非两个对象
    }

    public function getPlain()
    {
        return clone $this->plain;
    }

    public function getForest()
    {
        return clone $this->forest;
    }
}

$earthInstance = new factory(new earthsea(1), new earthplain(), new earthforest()); //海域可航行
$earthInstance->getForest(); // new earthforest() 的实例

组合模式有助于集合和组件之间关系建立模型
枪手（Archer）组合成军队（Arm），多个枪手可以增加军队的战斗力（bombardStrength）

abstract class unit {

    public function addunit(Unit $unit){
        // 阻止独立单元再次添加对象
        throw new unitException(get_class($unit)."is a leaf");
    }

    public function removeunit(Unit $unit){
        // 阻止独立单元删除添加对象
        throw new unitException(get_class($unit)."is a leaf");
    }
    abstract function bombardStrength();
}

class unitException extends Exception{}

class Archer extends unit {

    public function bombardStrength()
    {
        return 4 ;
    }
}

class Army extends unit{  //组合模式体

    private $units = array();

    public function addunit(Unit $unit)
    {
        if(in_array($unit, $this->units, true))
        {
            return ;
        }
        $this->units[] = $unit;
    }

    public function removeunit(Unit $unit)
    {
        $units = array();
        foreach ($this->units as $item)
        {
            if($item !== $unit)
            {
                $units[] = $item;
            }
        }
        $this->units = $units;
    }

    public function bombardStrength()
    {
        $ret = 0 ;
        foreach ($this->units as $unit)
        {
            $ret += $unit->bombardStrength();
        }
        return $ret;
    }
}

$SubArmy = new Army();
$SubArmy->addunit( new Archer());
$SubArmy->addunit( new Archer());
echo $SubArmy->bombardStrength(); // 8

组合模式用户聚合组件，装饰模式使用类似功能，改变组件具体功能
继承是共享父类特性的简单方法，所以当改变某些特性时，各种硬编码会出现在继承体
导致功能定义依赖于继承体，导致代码增多，导致代码重复

abstract class tile{

    abstract function get_wealth();
}

class plains extends tile {
    private $wealth = 2;
    public function get_wealth()
    {
        return $this->wealth;
    }
}

class polluted extends plains {
    public function get_wealth()
    {
        return parent::get_wealth()-2;
    }
}

class diamond extends plains{
    public function get_wealth()
    {
        return parent::get_wealth()+10 ;
    }
}
// 上图组合模式 不容易实现既是钻石地段又是污染地段的价值，常规做法，会建立类 diamond_polluted

 装饰模式是使用组合和委托，而不是单纯的继承
abstract class tile {
    abstract function getwealth();
}

class plains extends tile {
    private $wealth = 2;
    public function getwealth()
    {
        return $this->wealth;
    }
}

abstract class tile_decorate extends tile{
    protected $tile ; // 保护属性，便于子类和当前类当问
// 构造方法，接收实例对象，保存在tile属性中
    public function __construct(tile $tile)
    {
        $this->tile = $tile;
    }
}

class pollute_decorate extends tile_decorate {
    public function getwealth()
    {
        return $this->tile->getwealth()-4;
    }
}

class diamon_decorate extends tile_decorate {
    public function getwealth()
    {
        return  $this->tile->getwealth()+2;
    }
}

$tile = new plains();
echo $tile->getwealth();
$tile = new diamon_decorate(new plains());
echo  $tile->getwealth();
$tile = new pollute_decorate(new diamon_decorate(new plains())); // 组合成一个整体
echo $tile->getwealth();
// 多个组合及委托，极具灵活性

  多个装饰器串联起来，形成管道，便于创建过滤器，核心组件和装饰漆组合，对其流程进行过滤缓冲，压缩
class request_helper{}

abstract class process_request{
    abstract function process(request_helper $req);
}

class main_process extends process_request {
    public function process(request_helper $req)
    {
        echo __CLASS__."is processing 
";
    }
}

abstract class process_decorate extends process_request {

    protected $process_request;
    public function __construct(process_request $pro)
    {
        $this->process_request = $pro;
    }
}

class log_process extends process_decorate {
    public function process(request_helper $req)
    {
        print __CLASS__."is processing log 
";
        $this->process_request->process($req);
    }
}

class authenticate extends process_decorate {
    public function process(request_helper $req)
    {
        print __CLASS__."is processing authentication 
";
        $this->process_request->process($req);
    }
}

class structure_request extends process_decorate {
    public function process(request_helper $req)
    {
        print __CLASS__."is processing structure 
";
        $this->process_request->process($req);
    }
}

$process = new authenticate(new structure_request(new log_process(new main_process())));
$process->process(new request_helper());
// auth->struct->log->main

装饰模式一定是组合和继承同时使用
等同于__call 拦截方法，捕捉不存在的方法自动调用