微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

php中的Decorator完全继承行为

分类：PHP作者：编程之家

我一般不习惯设计图案,我从未使用过装饰器.我想要一个根据上下文可以有不同行为的对象.这些行为在不同的类中定义.我猜装饰师会做到这一点.但我需要每个装饰器都可以访问相同的属性,并首先调用children方法,就像继承一样.所以我在这里做了什么：

abstract class Component{

    /**
     * Used to access last chain Decorator
     *
     * @var Decorator
     */
    protected $this;

    protected $prop1;//These properies have to be accessed in any decorators

    protected $prop2;

    protected $prop3;

    //this method is used to share properties with the childrens
    public function getAttributesReferencesArray() {
        $attributes=[];
        foreach($this as $attr=>&$val)
                $attributes[$attr]=&$val;
        return $attributes;
    }

}

class Foo extends Component{

    public function __construct() {
        $this->prop1="initialized";
        //...
    }

    public function method1() {//this method can be "overrided" and called here
        //...
    }

    public function method2() {//this method call the overrided or not method1
        //...
        $this->this->method1();
        //...
    }

}

abstract class Decorator extends Component{

    /**
     * Used to access parent component
     *
     * @var Component
     */
    protected $parent;

    public function __construct(Component $parent) {
        $attributes=$parent->getAttributesReferencesArray();
        foreach($attributes as $attr=>&$val)
                $this->{$attr}=&$val;
        $this->parent=$parent;
        $this->this=$this;
    }

    public function __call($method, $args) {
        if(!$this->parent instanceof Decorator &&
            !method_exists($this->parent, $method))
                throw new Exception("Undefined method $method attempt.");
        return call_user_func_array(array($this->parent, $method), $args);
    }

}

class Bar extends Decorator{

    //this method call the component method (I guess Decorator classical way)
    public function method1(){
        //...
        $this->parent->method1();
        $this->prop2="set in Bar";
    }
}

class Baz extends Decorator{

    public function method2(){//this method call the overrided or not method1
        //...
        $this->this->method1();
        //...
    }

}

现在我们可以根据上下文“构建”“继承”：

//...
$obj=new Foo();
if($context->useBar())
        $obj=new Bar($obj);
if($context->somethingElse())
        $obj=new Baz($obj);

并使用行为抽象运行对象：

$obj->method1();
//...

它做我想要的,但是：

>不再有封装了
> $this->父母是丑陋的
> $this->这很难看

你觉得怎么样？

>我如何以另一种方式访问​​decorator(“children”)方法
>我如何共享属性,如果它们在继承的上下文中受到保护
>这是装饰师的坏用法吗？
>是否有更优雅的模式可以解决问题
>父母和这个属性是一种重塑轮子不是吗？

一个现实世界的例子：咖啡机

abstract class CoffeeFactory{// Component

    /**
     * Used to access last chain Decorator
     *
     * @var Decorator
     */
    protected $this;

    /**
     * Used to access user choices
     *
     * @var CoffeeMachine
     */
    protected $coffeeMachine;

    protected $water;//the water quantity in cl

    protected $coffeePowder;

    protected $isspoon=FALSE;

    protected $cup=[];

    //this method is used to share properties with the childrens
    public function getAttributesReferencesArray() {
        $attributes=[];
        foreach($this as $attr=>&$val)
                $attributes[$attr]=&$val;
        return $attributes;
    }

}

class SimpleCoffeeFactory extends CoffeeFactory{//Foo

    public function __construct(CoffeeMachine $coffeeMachine) {
        $this->coffeeMachine=$coffeeMachine;
        $this->water=$coffeeMachine->isEspresso()?10:20;
        $this->coffeePowder=$coffeeMachine->isDouble()?2:1;
        $this->water-=$this->coffeePowder;
        $this->this=$this;
    }

    private function addCoffeePowder(){
        $this->cup["coffeePowder"]=$this->coffeePowder;
    }

    private function addSpoon(){
        if($this->isspoon)
                $this->cup["spoon"]=1;
    }

    public function isWaterHot($boilingWater){
        return $this->getWaterTemperature($boilingWater)>90;
    }

    private function addWater() {
        $boilingWater=$this->getWaterForBoiling($this->water);
        while(!$this->this->isWaterHot($boilingWater))
                $this->boilWater($boilingWater);
        $this->cup["water"]=$boilingWater;
    }

    public function prepare() {
        $this->addCoffeePowder();
        $this->addSpoon();
    }

    public function getCup() {
        $this->this->prepare();
        $this->addWater();
        return $this->cup;
    }

}

abstract class Decorator extends CoffeeFactory{

    /**
     * Used to access parent component
     *
     * @var Component
     */
    protected $parent;

    public function __construct(Component $parent) {
        $attributes=$parent->getAttributesReferencesArray();
        foreach($attributes as $attr=>&$val)
                $this->{$attr}=&$val;
        $this->parent=$parent;
        $this->this=$this;
    }

    public function __call($method, $args) {
        if(!$this->parent instanceof Decorator &&
            !method_exists($this->parent, $method))
                throw new Exception("Undefined method $method attempt.");
        return call_user_func_array(array($this->parent, $method), $args);
    }
}

class SugarCoffeeFactory extends Decorator{

    protected $sugar;

    public function __construct(Component $parent) {
        parent::__construct($parent);
        $this->sugar=$this->coffeeMachine->howMuchSugar();
        $this->water-=$this->sugar;
        $this->isspoon=TRUE;
    }

    public function prepare() {
        $this->cup['sugar']=$this->sugar;
        $this->parent->prepare();
    }
}

class MilkCoffeeFactory extends Decorator{

    protected $milk;

    public function __construct(Component $parent) {
        parent::__construct($parent);
        $this->milk=$this->coffeeMachine->howMuchMilk();
        $this->water-=$this->milk;
    }

    public function prepare() {
        $this->parent->prepare();
        $this->cup['milk']=$this->milk;
    }

    public function isWaterHot($boilingWater){
        //The milk is added cold, so the more milk we have, the hotter water have to be.
        return $this->getWaterTemperature($boilingWater)>90+$this->milk;
    }

}

//Now we can "construct" the "inheritance" according to the coffee machine:

//...
$coffeeFactory=new SimpleCoffeeFactory($coffeeMachine);
if($coffeeMachine->wantSugar())
        $coffeeFactory=new SugarCoffeeFactory($coffeeFactory);
if($coffeeMachine->wantMilk())
        $coffeeFactory=new MilkCoffeeFactory($coffeeFactory);

//and get our cup with abstraction of behavIoUr:

$cupOfCoffee=$coffeeFactory->getCup();
//...

解决方法:

Decorator模式不是为了在基类中进行内部更改(您将其称为父类).你正在做的是这种模式的糟糕用法.装饰器只应更改函数的输出而不是使用变量.

一种解决方案是为受保护的变量定义getter和setter,并从Decorator中调用它们.

另一种解决方案是我个人喜欢的,它是分裂依赖于上下文和基类的行为：

class Component {
    protected $behavIoUr;
    function __construct() {
        $this->behavIoUr = new StandardBehavIoUr();
    }

    function method1() {
        $this->prop2 = $this->behavIoUr->getProp2Value();
    }
    function setBehavIoUr(BehavIoUr $behavIoUr) {
        $this->behavIoUr = $behavIoUr;
    }
}

abstract class BehavIoUr {
    abstract function getProp2Value();
}

class StandardBehavIoUr extends BehavIoUr {
    function getProp2Value() {
        return 'set by bahavIoUr ';
    }
}

class BarBehavIoUr extends StandardBehavIoUr {
    function getProp2Value() {
        return parent::getProp2Value().' Bar';
    }
}

class BazBehavIoUr extends BarBehavIoUr {
    function getProp2Value() {
        return 'set in Baz';
    }
}

现在我们可以像这样使用它：

$obj=new Foo();
if($context->useBar())
    $obj->setBehavIoUr(new BarBehavIoUr);
if($context->somethingElse())
    $obj->setBehavIoUr(new BazBehavIoUr);

我希望这回答了你的问题！

评论后编辑

我明白你的观点是行为互相取代而不是链接.这确实是装饰器类的典型问题.但是你真的不应该在装饰器类中更改原始类.装饰器类仅“装饰”原始输出.下面是一个典型的示例,说明装饰器模式将如何在您提到的真实世界场景中使用：

interface ICoffeeFactory {
    public function produceCoffee();
}

class SimpleCoffeeFactory implements ICoffeeFactory{
    protected $water;//the water quantity in cl

    public function __construct() {
        $this->water=20;
    }

    protected function addCoffeePowder($cup){
        $cup["coffeePowder"]=1;
        return $cup;
    }

    protected function addWater($cup) {
        $cup["water"]=$this->water;
        return $cup;
    }

    public function produceCoffee() {
        $cup = array();
        $cup = $this->addCoffeePowder($cup);
        $cup = $this->addSpoon($cup);
        $cup = $this->addWater($cup);
        return $cup;
    }

}

class EspressoCoffeeFactory extends SimpleCoffeeFactory {
    public function __construct() {
        $this->water=5;
    }

    protected function addCoffeePowder($cup){
        $cup["coffeePowder"]=3;
        return $cup;
    }
}

abstract class Decorator implements ICoffeeFactory {
    function __construct(ICoffeeFactory $machine)
}

class SugarCoffee extends Decorator{
    public function produceCoffee() {
        $cup = $this->factory->produceCoffee();
        if ($cup['water'] > 0)
            $cup['water'] -= 1;

        $cup['spoon']  = TRUE;
        $cup['sugar'] += 1;
        return $cup;
    }
}

class MilkCoffee extends Decorator{
    protected function produceCoffee() {
        $cup = $this->factory->produceCoffee();
        $cup['milk'] = 5;
        return $cup;
    }
}

//Now we can "construct" the "inheritance" according to the coffee machine:

//...
$coffee=new SimpleCoffeeFactory();
if($coffeeMachine->wantSugar())
        $coffee=new SugarCoffee($coffee);
if($coffeeMachine->wantMilk())
        $coffee=new MilkCoffee($coffee);

//and get our cup with abstraction of behavIoUr:

$cupOfCoffee=$coffee->produceCoffee();
//...

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

vue+thinkphp5实现微信扫码支付(NATIVE支付)
统一支付是JSAPI/NATIVE/APP各种支付场景下生成支付订单，返回预支付订单号的接口，目前微信支付所有场景均使用这一接口。下面介绍的是其中NATIVE的支付实现流程与PC端实现扫码支付流程
uniapp+thinkphp5实现微信扫码支付(APP支付)
统一支付是JSAPI/NATIVE/APP各种支付场景下生成支付订单，返回预支付订单号的接口，目前微信支付所有场景均使用这一接口。下面介绍的是其中APP的支付的配置与实现流程
uniapp+thinkphp5实现微信登录
前言 之前做了微信登录，所以总结一下微信授权登录并获取用户信息这个功能的开发流程。 配置 1.首先得在微信公众平台申请一下微信小程序账号并获取到小程序的AppID和AppSecret https://mp.weixin.qq.com/cgi-bin/loginpage?url=%2Fwxamp%2F
【PHP】关于fastadmin框架中使用with进行连表查询时setEagerlyType字段的理解
FastAdmin是我第一个接触的后台管理系统框架。FastAdmin是一款开源且免费商用的后台开发框架，它基于ThinkPHP和Bootstrap两大主流技术构建的极速后台开发框架，它有着非常完善且强大的功能和便捷的开发体验，使我逐渐喜欢上了它。
【workerman】uniapp+thinkPHP5使用GatewayWorker实现实时通讯
之前公司需要一个内部的通讯软件，就叫我做一个。通讯软件嘛，就离不开通讯了，然后我就想到了长连接。这里本人用的是GatewayWorker框架。
uniapp+thinkphp5实现微信支付(JSAPI支付)
统一支付是JSAPI/NATIVE/APP各种支付场景下生成支付订单，返回预支付订单号的接口，目前微信支付所有场景均使用这一接口。下面介绍的是其中JSAPI的支付实现流程
服务器优化必备：深入了解PHP8底层开发原理
服务器优化必备：深入了解PHP8底层开发原理
Golang的网络编程：如何快速构建高性能的网络应用？
Golang的网络编程：如何快速构建高性能的网络应用？
Golang和其他编程语言的对比：为什么它的开发效率更高？
Golang和其他编程语言的对比：为什么它的开发效率更高？
PHP8底层开发原理揭秘：如何利用新特性创建出色的Web应用
PHP8底层开发原理揭秘：如何利用新特性创建出色的Web应用
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native