strategy for observer pattern?

I want to use observer pattern for a logging system.

We have got logObservers and logObservables.

The class that will have to log something will implement iLogObservable and include these methods:

private $logObservers = array();

public function addLogObserver($logObserver) {
    $this->logObservers[] = $logObserver;
}
public function removeLogObserver($logObserver) {
    this->logObservers[] = $logObserver;
}
public function write($type, $message) {
    foreach($this->logObservers as $logObserver) {
        $logObserver->log($level, $message);
    }
}

Then I noticed, that a lot of classes that will use logging will have these methods and I have to copy paste. So isn't it better to have these methods in a class I call LogObservable or just Log and then use strategy (instant开发者_如何学Pythoniate this class inside all classes that will have to log). When I change the methods in Log, all logObservables will be affected.

However, I have not seen anyone use observer pattern with strategy pattern yet, but it seems to be very efficient and remove the duplications.

What do you think?

It's not unusual for an object that supports this functionality to INHERIT from an Observable class, which supports these methods, in languages that support multiple inheritance.

I have never come across a solution that uses aggregation to support this, which is what you are describing, but given PHP doesn't support multiple-inheritance, it sounds like a reasonable work-around to me.

Now you can use Traits and define observerAbles methods in one trait.