我可以重复使用装饰器吗？

Question

我可以重复使用装饰器吗？

我有一个ClientDecorator 来装饰一个具有客户端引用的实体，这个装饰器在调用 getClient 时获取数据库上的客户端（在它被装饰之前，此方法返回 clientId，修饰后返回一个Client的实例）。

好的，但是，我还有一些其他实体可以使用相同的装饰器进行装饰，例如，我有另一个名为 questions 的表，该表有一个指向已提出问题的客户的引用，并且我有另一个名为 schedules 的表，其中包含一个客户端的引用。

顺便说一句，我可以用ClientDecorator装饰question和schedule。

但是，我也有一个QuestionDecorator；这家伙装饰了Answer等。

如何进行这种抽象，以便我可以随时重用装饰器？

我尝试创建ClientDecorable、QuestionDecorable 接口，但没有任何进展。

Answer 1

您总是可以实例化装饰器类，将参数传递给构造函数，该构造函数将告诉它应该如何表现或应该模拟什么类。您实际上不必将您的装饰器声明为另一个类的扩展。

PHP 类支持 magic methods，这使得将调用转发到您的对象所模拟的类成为可能，就像它使用 extends 扩展它一样。

例如：

class Client
{
    public function getId() { return 123; }
}

class Decorator
{
    private $instance = null;

    public function __construct($class)
    {
        $this->instance = new $class();
    }

    public function __call($method, $params) // magic method
    {
        return call_user_func_array(array($this->instance, $method), $params);
    }
}

$object = Decorator('Client');
echo $object->getId(); // 123

当您尝试访问不属于类Decorator 的方法时，将调用魔术方法__call()。使用魔术方法__get() 和__set() 可以对属性进行同样的操作。

Answer 2

这是一个非常棘手的问题。我可以找到一个解决方案，但它有点像 McGiver 风格......适用于 PHP 5.4+（是的，特征）。

<?php
interface Decorable
{

    public function getTarget();

}


interface ClientDecorable extends Decorable
{

    public function getClient();

}


interface LogDecorable extends Decorable
{

    public function getLog();

}

abstract class AbstractDecorator implements Decorable 
{

    private $target;

    public function __construct(ClientDecorable $target)
    {
        $this->target = $target;
    }

    public function getTarget()
    {
        // I'll be able to access the leaf node of my decorator single way 'tree'
        return $this->target->getTarget();
    }

    public function __call($method, $args) {

        $reflected = new ReflectionClass($this->target);
        if ($reflected->hasMethod($method)) {
            return call_user_func_array([$this->target, $method], $args);
        }
    }

}

class ClientDecorator extends AbstractDecorator implements ClientDecorable
{
    public function __construct(Decorable $target) {
        if (! $target->getTarget() instanceof ClientDecorable) {
            throw new Exception('Must be an instance de ClientDecorable');
        }
        parent::__construct($target);
    }
    public function getClient()
    {
        return new Client($this->getTarget()->getClient());
    }

}

class LogDecorator extends AbstractDecorator implements LogDecorable
{
    public function __construct(Decorable $target) {
        if (! $target->getTarget() instanceof LogDecorable) {
            throw new Exception('Must be an instance de LogDecorable');
        }
        parent::__construct($target);
    }

    public function getLog()
    {
        return new Log($this->getTarget()->getLog());
    }

}

abstract class AbstractTarget implements Decorable
{
    // this does the trick
    public function getTarget() { return $this; }
}

trait ClientDecorableTrait {
    public function getClient()
    {
        return $this->client;
    }
}

trait LogDecorableTrait {
    public function getLog()
    {
        return $this->log;
    }
}



class Payment extends AbstractTarget implements ClientDecorable, LogDecorable
{
    use ClientDecorableTrait;
    use LogDecorableTrait;

    private $client = 1;
    private $log = 101;
}

class Sale extends AbstractTarget implements ClientDecorable
{
    use ClientDecorableTrait;

    private $client = 2;

}

class Client
{

    // ...

}


class Log
{

    // ...

}

$sale = new Sale();
var_dump($sale->getClient());
$saleDec = new ClientDecorator($sale);
var_dump($saleDec->getClient());

$payment = new Payment();
var_dump($payment->getClient());
$paymentDec = new ClientDecorator($payment);
var_dump($paymentDec->getClient());

var_dump($paymentDec->getLog());
$paymentDecTwice = new LogDecorator($paymentDec);
var_dump($paymentDecTwice->getLog());

$saleDecTwice = new LogDecorator($saleDec); // will throw an exception

这只是一个骨架，现实世界的实现一定很棘手。我认为你最好把你的装饰器分开......