Liskov替换原则和使用继承类的正确方法

Question

我有一些处理程序（“控制器”）类，它们可以以某种方式处理项目：

interface IHandler
{
    public function execute(Item $item);
}

class FirstHandler implements IHandler
{
    public function execute(Item $item) { echo $item->getTitle(); }
}

class SecondHandler implements IHandler
{
    public function execute(Item $item) { echo $item->getId() . $item->getTitle(); }
}

class Item
{
    public function getId() { return rand(); }
    public function getTitle() { return 'title at ' . time(); }
}

但是我需要在子 Item 类中添加一些新功能：

class NewItem extends Item
{
    public function getAuthor() { return 'author ' . rand(); }
}

并在 SecondHandler 中使用它

class SecondHandler implements IHandler
{
    public function execute(Item $item) { printf('%d %s, author %s', $item->getId(), $item->getTitle(), $item->getAuthor()); }
}

但是Item 类实际上没有getAuthor 方法。而且，如果我尝试在SecondHandler 类中更改接受方法的签名，我将捕获E_STRICT 关于声明兼容性的错误。当然，这有点违反 LSP。

我该如何解决这个问题？我是否需要两个接口，例如INewHandler 和IHandler，具有不同的execute 方法签名？但这是某种代码重复。

另外，我不能在处理程序中使用__constructor(Item $item) 和__construct(NewItem $item)（以及不带参数的execute 方法），这将被视为更好的解决方案：它们必须是不可变的，并且应用程序中允许的每个策略只有一个实例生命周期。

Answer 1

您确定要在此处使用策略模式吗？

看起来，这里的策略动作取决于它处理的元素的类型。在这种情况下，Visitor 模式也可能适用于此。

Answer 2

就目前而言，您似乎想要执行可扩展的数据记录（Item 和 NewItem）。考虑改为执行一些可插入的行为（通过接口实现）。

从您的文章中很难猜出这种行为会是什么，因为 (New)Item 在您提供的示例中只是一个美化的数据结构。

Answer 3

正如您自己发现的那样，PHP 的类型提示实现有很多限制，使得您所描述的场景变得比应有的更难。在 Java 和 Swift 等其他类型语言中，您的实现是绝对合法的。

在对您的问题进行了一些思考后，我得出了Félix 提出的解决方案，但与问题相比，我认为它过于工程化。

我对您问题的回答不是解决方案，而是我在使用 PHP 多年开发后给您的建议：

放弃 PHP 中的类型提示，以动态的方式进行开发……。

PHP 比 Java/C++ 更类似于 Ruby/Python/JavaScript，并且尝试从静态类型语言中进行 1 对 1 的复制会转化为强制和复杂的实现。

您的实施问题的解决方案很简单，因此不要过度复杂化并保持其应有的简单性（KISS 原则）。

在没有类型的情况下声明方法的参数，并在您真正需要的地方进行检查（例如抛出异常）。

interface IStrategy
{
    public function execute($item);
}

class FirstStrategy implements IStrategy
{
    public function execute($item) {
        echo $item->getTitle();
    }
}

class SecondStrategy implements IStrategy
{
    public function execute($item) {
        // execute(NewItem $item) is identical to this check.
        if (! $item instanceof NewItem) {
            throw new Exception('$item must be an instance of NewItem');
        }
        echo $item->getAuthor();
    }
}

class Item
{
    public function getId() { return rand(); }
    public function getTitle() { return 'title at ' . time(); }
}

class NewItem extends Item
{
    public function getAuthor() { return 'author ' . rand(); }
}

同样，不要在 Java 中思考，而是尽可能遵循鸭子类型的方式。

如果可能，尽量不要严格强制参数的类型，而是根据可用接口（Duck Typing）调整代码的行为。

class SecondStrategy implements IStrategy
{
    public function execute($item) {
        $message = $item->getTitle();

        // PHP 5 interface availability check.
        if (is_callable([$item, 'getAuthor'])) {
            $message .= ' ' . $item->getAuthor();
        }

        // With PHP 7 is even better.
        // try {
        //     $message .= ' ' . $item->getAuthor();
        // } catch (Error $e) {}

        echo $message;
    }
}

希望对你有所帮助。 ^_^

Answer 4

如果您想使用/操作另一个对象中的对象，您可以/应该使用接口。

interface IStrategy
{
    public function execute(ItemInterface $item);
}

interface ItemInterface 
{
   public function getTitle();
   .....
}

如果您想扩展 (New)Item 类的公共功能，您可以为 newItem 创建新接口

interface NewItemInterface extends ItemInterface 
{
...
}

class SecondStrategy implements IStrategy
{
    public function execute(NewItemInterface $item) 
    { .... }
}

或者您可以使用其他人提到的一些实例检查。

Answer 5

如果您对 SecondHandler 应该同时处理 Item 和 NewItem 的继承和建议一开始是正确的，那么您应该能够将此功能隐藏在通用接口后面。从您的示例中，它可能被称为 toString() ，它可能是 Item 接口的一部分。

否则，您的设计最初可能有问题。你必须改变你的继承权或你处理物品的方式。或者其他我们不知道的事情。

另外，我不知道您为什么需要 DTO，但似乎对 Doctrine 存在一些误解。 Doctrine 是一个 ORM，它解决了你的持久性问题。它增加了您如何与引入存储库的存储进行通信的限制，但它没有定义您的域逻辑。

Answer 6

@daniele-orlando 和 @ihor-burlachenko 都得到了有效的分数。 考虑以下方法重载方法，这是一种折衷方案，应该可以很好地扩展：

interface IHandler
{
    /**
     * @param $item Item|NewItem
     */
    public function execute($item);

    // protected function executeItem(Item $item);
    // protected function executeNewItem(NewItem $item);    
}

trait IHandlerTrait
{   
    public function execute($item) 
    {
        switch(true) {
            case $item instanceof Item:
                return $this->executeItem($item);
            case $item instanceof NewItem:
                return $this->executeNewItem($item);
            default:
                throw new \InvalidArgumentException("Unsupported parameter type " . get_class($item));
        }
    }

    protected function executeItem(Item $item)
    {
        throw new \LogicException(__CLASS__ . " cannot handle execute() for type Item");
    }

    protected function executeNewItem(NewItem $item)
    {
        throw new \LogicException(__CLASS__ . " cannot handle execute() for type NewItem");
    }
}

class FirstHandler implements IHandler
{
    use IIHandlerTrait;

    protected function executeItem(Item $item) { echo $item->getTitle(); }
}

class SecondHandler implements IHandler
{
    use IIHandlerTrait;

    // only if SecondHandler still need to support `Item` for backward compatibility
    protected function executeItem(Item $item) { echo $item->getId() . $item->  getTitle(); }

    protected function executeNewItem(NewItem $item) { printf('%d %s, author    %s', $item->getId(), $item->getTitle(), $item->getAuthor()); }
}

Answer 7

根据接口隔离，请找到一些解决方案。

```

# based on interface segrigation.

interface BasicInfo
{
    public function getId();
    public function getTitle();
}

interface AuthorInfo
{
    public function getAuthor();
}

interface IHandler
{
    public function execute(Item $item);
}

class FirstHandler implements IHandler
{
    public function execute(Item $item) { echo $item->getTitle(); }
}

class SecondHandler implements IHandler
{
    public function execute(Item $item) { echo $item->getId() . $item->getTitle(); }
}

class Item implements BasicInfo
{
    public function getId() { return rand(); }
    public function getTitle() { return 'title at ' . time(); }
}

class Item2 extends Item implements AuthorInfo
{
    public function getAuthor() { return 'author ' . rand(); }
}

但我认为你不应该保留 Item 类的依赖关系。您应该编写一些重复的代码以保持类可插入/独立。所以打开/关闭原则也应该在那里。