What would be the appropriate design pattern to use in this PHP class structure, given no multiple-inheritance?

Question

I have an abstract class called Node. It contains a constructor that takes a row from my database, and instantiates basic information. All pieces of content on my website extend this class - Person, Event, Project, etc.

3 of these extending classes are special - when they are constructed, in addition to pulling values from the database, they also need to query a web-service; if the web-service provides values that are different from the ones given in the DB, they need to save to the DB.

In a multiple-inheritance capable language, this would be fairly simple; any one of these classes would extend both Node, and APIData, or something like that. Without MI, I'm not sure how to handle this. Using an interface would not be helpful, as that provides no concrete implementations.

The decorator pattern is sometimes recommended as a substitue for some features of MI, but I don't have enough experience to determine if this is the appropriate choice. Any suggestions?

Answer 1

Objects should be dumb. When I construct something, it shouldn't be doing anything other than what I ask it - i.e. construct yourself. Don't be querying webservices and writing to the database. If I was using your objects as another developer on your team, I would be shocked.

This is also why I think you are struggling for the correct pattern, because your object has multiple concerns.

I think the best approach here would be to create a service that returns objects, such as a PersonService, EventService, etc., that does the following:

• Retrieve record from the database
• If need to check webservice:
  • Retrieve data from webservice
  • If changes exist, save back to database
• Pass record to object contructor
• Return object

This keeps the concerns of the webservice call in a place where it makes sense - that is, the code that retrieves the necessary data to construct and return objects, aka a service (EDIT: actually more of a DAO, but you get the idea).

Answer 2

Since the APIData class will take functionallity from your Node class, you should simply extend it. Here is some pseudo code:

abstract class APIData extends Node {

    public function __construct($data) {
        parent::__construct($data);
        $this->checkData();
    }

    protected function checkData() {
        // load data from webservice
        $data = $this->loadData();

        // check if data is the same
        foreach($data as $item => $value) {
            if ($this->data[$item] != $value) {
                // save in database
            }
        }
    }
}