编程范例：具有继承的强类型参数

Question

Warning: might cause TL:DR

I am working with PHP 5.3.10 and have the following problem. I do have an abstract class DataMapper, which is extended for the specific DataModel I want to persist. The following code does this trick:

abstract class DataMapper {
    public abstract function findById($id);
    public abstract function fetchAll();
    public abstract function save(IModel $model);               // DISCUSSION
    /* more helper functions here */
}

class PersonMapper extends DataMapper {
    public function findById($id) { /* ...magic ... */ }
    public function fetchAll() { /* ...magic ... */ }
    public function save(IModel $model) { /* ...magic ... */ }  // DISCUSSION
}

interface IModel {
    public function setOptions(array $options);
    public function toArray();
}

abstract class Model implements IModel {
    protected $_fields = array();
    protected $_data = array();

    public function setOptions(array $options) { /* ...magic ... */ }
    public function toArray() { /* ...magic ... */ }

    public function __construct(array $options = null) { /* ...magic ... */ }
    public function __set($name, $value) { /* ...magic ... */ }
    public function __get($name) { /* ...magic ... */ }
}

class PersonModel extends Model {
    protected $_fields = array('id', 'name', 'passhash', /*...*/);

    public function setId($value) {
        /* ...Validation happening... */
        $this->_data['id'] = $value;
        return $this;
    }

    public function checkPassword($password) { /* ...magic... */ }
}

This works fine, but is really quirky for my feeling.

As you can see, I've used an interface IModel to be able to tell the DataMapper, that it does need a certain set of parameters and methods. However, some Models do have extra methods needed by the corresponding DataMapper - in the example, a checkPassword() method, which is used test a password against the stored hash value. This method may also instruct the DataMapper to rehash the just tested password and update it due to new requirements (e.g. an increased difficulty for a password hash function).

So what I actually want is to change the signature of PersonMapper to PersonMapper::save(PersonModel $model) - and e.g. in another DataMapper toPostMapper::save(PostModel $model), etc. This is due to these DataMappers needing a certain signature. So my ideal solution looks like this:

abstract class DataMapper {
    public abstract function findById($id);
    public abstract function fetchAll();
    public abstract function save(Model $model);                   // UPDATED
}

class PersonMapper extends DataMapper {
    public function findById($id) { /* ...magic... */ }
    public function fetchAll() { /* ...magic... */ }
    public function save(PersonModel $model) { /* ...magic... */ } // UPDATED
}

abstract class Model { /* ...unchanged... */ }

class PersonModel extends Model { /* ...unchanged... */ }

Notice the Update save-Methods in the abstract class and its implementation. Since PersonModel is inherited from Model, thus obviously having a common base set of signatures, I would expect this to work just fine. But it doesn't - PHP complains about a changed interface in the childclass PersonMapper

My Questions:

• Is there another solution working with PHP 5.3.10 that expresses the relationship better?
• Does it work in a later version of PHP, so that it might be worth upgrading the server?

Answer 1

You might try using interfaces instead.

interface OtherModel {
    public function getThis();
}

interface OtherOtherModel {
    public function getThat();
}

Your Model Class might implement one or more interfaces...

class PersonModel extends Model implements OtherModel {
    protected $_fields = array('id', 'name', 'passhash', /*...*/);

    public function setId($value) {
        /* ...Validation happening... */
        $this->_data['id'] = $value;
        return $this;
    }

    public function checkPassword($password) { /* ...magic... */ }

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

Your concrete Mapper Class can use the instanceof to check if this Model does what it should.

class PersonMapper extends DataMapper {
    public function findById($id) { /* ...magic... */ }
    public function fetchAll() { /* ...magic... */ }
    public function save(Model $model) { 
       // verify that certain methods are implemented...
       // throw an exception or reacting accordingly
       print ($model instanceof PersonModel)? 'yes' : 'no';
       print ($model instanceof OtherOtherModel)? 'yes' : 'no';
    } 
}

Another possible approach might be the following:

<?php

abstract class DataMapper {
    public abstract function findById($id);
    public abstract function fetchAll();

    public  function save(Model $model) {
        throw new Exception('You have to implement this!');
    }
}

Throw an Exception if the save method is not overriden in an inheriting class. Now you can really use a different typehint. This will work:

class PersonMapper extends DataMapper {
    public function findById($id) { /* ...magic... */ }
    public function fetchAll() { /* ...magic... */ }
    public function save(PersonModel $model)  {
        // do something
    }
}

I could think of another possible approach, by using interfaces to define the implementation. Like for example:

interface PersonModelAware {
   public function save(PersonModel $model);
}

interface OtherModelAware {
   public function save(OtherModel $model);
}

etc. Your abstract method might have a default save method or no save method at all. The inheriting class will implement the interface it needs.

To sum it up, making your type more specific will not work as the abstract method clearly states it expects a Model.