Question

我想将数据与数据源分开。一个用于数据库交互的类和用于数据操作的类。但我的做法违反了LSP：preconditions cannot be strengthened in a subtype并引发了严格的错误：Declaration of DataRepositoryItem::save() should be compatible with DataRepositoryAbstract::save(DataAbstract $data)

class DataAbstract {
}

class DataItem extends DataAbstract {
}

class DataObject extends DataAbstract {
}

abstract class DataRepositoryAbstract {
    /** @return DataAbstract */
    public function loadOne(){}
    /** @return DataAbstract[] */
    public function loadAll(){}                          
    public function save(DataAbstract $data){}
}

class DataRepositoryItem extends DataRepositoryAbstract {
    /** @return DataItem */
    public function loadOne(){}
    /** @return DataItem[] */
    public function loadAll(){}
    public function save(DataItem $data) {}               // <--- violates LSP, how to avoid it?
}

class DataRepositoryObject extends DataRepositoryAbstract {
    /** @return DataObject */
    public function loadOne(){}
    /** @return DataObject[] */
    public function loadAll(){}
    public function save(DataObject $data) {}             // <--- violates LSP, how to avoid it?
}

如何重新组合代码以适应LSP？

更新：好的，我可以重写方法。

class DataRepositoryItem extends DataRepositoryAbstract {
    /** @return DataItem */
    public function loadOne(){}
    /** @return DataItem[] */
    public function loadAll(){}
    public function save(DataAbstract $data) {
        assert($date instanceof DataItem);
        //...
    }               
}

适用于PHP，但仍违反LSP。如何避免呢？

Answer 1

如果您的语言支持泛型，那么问题将很容易解决：

public interface Repository<T> {
    public void save(T data);
}

public class DataItemRepository implements Repository<DataItem> {...}

如果没有泛型，那么您可以简单地避免一开始就拥有一个泛型存储库，这样做弊大于利。确实有任何客户端代码应该依赖DataRepositoryAbstract而不是具体的存储库类吗？如果不是，那为什么要在设计中强制使用无用的抽象呢？

public interface DataItemRepository {
    public DataItem loadOne();
    public DataItem[] loadAll();
    public void save(DataItem dataItem);
}

public class SqlDataItemRepository implements DataItemRepository {
  ...
}    

public interface OtherRepository {
    public Other loadOne();
    public Other[] loadAll();
    public void save(Other other);
}

现在，如果以某种通用方式可以处理所有save操作，您仍可以实现一个RepositoryBase类，该类可以被所有存储库扩展而不会违反LSP。

public abstract class RepositoryBase {
    protected genericSave(DataAbstract data) { ... }
}

public class SqlDataItemRepository extends RepositoryBase implements DataItemRepository {
    public void save(DataItem item) {
        genericSave(item);
    }
}

但是在那时，您可能应该通过让存储库与GenericRepository实例协作来在继承上使用合成：

public void save(DataItem item) {
    genericRepository.save(item);
}

PS：请注意，所有代码都不是实际的PHP代码。我不是PHP程序员，也没有查找语法，但是您应该弄清楚。

Answer 2

无论如何，您的继承层次结构违反了LSP原理，因为保存方法及其使用取决于传入对象中的具体类。即使您在save方法中删除了类型断言，您也将无法使用子类DataRepositoryItem而不是父类DataRepositoryAbstract，因为保存DataItem实体与保存DataAbstact实体是不同的。让我们想象以下使用DataRepositoryItem代替DataRepositoryAbstract的情况：

$repository = new DataRepositoryItem();
$entity = new DataAbstract()
// It causes incorrect behavior in DataRepositoryItem
$repository->save($entity);

我们可以得出结论：在DataRepositoryAbstract中声明保存方法没有意义。保存方法只能在具体的存储库类中声明。

abstract class DataRepositoryAbstract 
{
    /** 
     * @return DataAbstract 
     */
    public function loadOne(){}

    /** 
     * @return DataAbstract[] 
     */
    public function loadAll(){}                              
}

class DataRepositoryItem extends DataRepositoryAbstract 
{
    /** 
     * @return DataItem 
     */
    public function loadOne(){}

    /** 
     * @return DataItem[] 
     */
    public function loadAll(){}

    /** 
     * @param DataItem
     */
    public function save(DataItem $data) {}
}

class DataRepositoryObject extends DataRepositoryAbstract 
{
    /** 
     * @return DataObject 
     */
    public function loadOne(){}

    /** 
     * @return DataObject[] 
     */
    public function loadAll(){}

    /** 
     * @param DataObject
     */
    public function save(DataObject $data) {}
}

此继承层次结构提供了从DataRepositoryObject和DataRepositoryItem读取数据的功能，与从DataRepositoryAbstract中读取数据的功能相同。

但是让我问：您在哪里以及如何使用DataRepositoryAbstract类？我确定您使用它来确保具体的存储库类和另一个代码之间的联系。这意味着您的DataRepositoryAbstract类没有实现任何功能，没有在功能上使用，而是纯接口。如果我的假设是正确的，那么您应该使用接口而不是抽象类

接口：

interface BaseDataRepositoryInterface
{        
    /** 
     * @return DataAbstract 
     */
    public function loadOne();

    /** 
     * @return DataAbstract[] 
     */
    public function loadAll();      
}

interface DataRepositoryItemInterface extends BaseDataRepositoryInterface
{
    /** 
     * @return DataItem 
     */
    public function loadOne();

    /** 
     * @return DataItem[] 
     */
    public function loadAll(); 

    /** 
     * @param DataItem $data 
     */
    public function save(DataItem $data);
}

interface DataRepositoryObjectInterface extends BaseDataRepositoryInterface
{
    /** 
     * @return DataObject 
     */
    public function loadOne();

    /** 
     * @return DataObject[] 
     */
    public function loadAll(); 

    /** 
     * @param DataObject $data 
     */
    public function save(DataObject $data);
}

具体实现：

class DataRepositoryItem implements DataRepositoryItemInterface 
{       
    public function loadOne()
    {
    //...       
    }

    public function loadAll()
    {
    //...
    }

    public function save(DataItem $data)
    {
    //...
    }
}

避免违反LSP

2 个答案: