Ben Wendt's blog

The observer pattern is a nifty way to decouple objects from one another. Rather than having methods explicitly rely on, create, and access other objects, the other objects can subscribe to an object and enact their own changes as necessary.

Our implementation will have two general groups of objects, subscribers and observers. A subscriber class will hook in to an observer class and make actions when the observer publishes certain messages. The observer class will give objects methods to subscribe and unsubscribe from its messages.

We’ll begin by setting up an interface for our subscribers. Our subscribers could really be anything, so we want to specify some general behaviour that they will have. We don’t want to be restrictive and have an abstract class that they will inherit from because that would restrict functionality of all subscribers and limit the usefulness of this pattern.

interface Subscriber {
    public function EventCall($str);
}

Now we’ll set up an abstract class for Observables. This may be more useful as a trait but we actually do have to implement some functionality here.

abstract class Observable {
    private $_subscribers = array();
    public function Subscribe($o) {
        // give objects an ability to add themselves to the subscribers list.
        if (!in_array($o, $this->_subscribers)) {
            $this->_subscribers[] = $o;
        }
    }
    public function Unsubscribe($o) {
        // give objects an ability to remove themselves from the subscribers list.
        if (in_array($o, $this->_subscribers)) {
            foreach($this->_subscribers as $key => $value) {
                if ($o == $value) {
                    unset($this->_subscribers[$key]);
                }
            }
        }    
    }
    public function Event($event) {
        // when the event occurs, call the corresponding method on the clients.
        foreach($this->_subscribers as $subscriber) {
            $subscriber->EventCall($event);
        }
    }
}

Now that the abstract class and interface are ready, we can make some concrete classes based on these.

class Observer extends Observable {
    public function Talk() {
        echo "I am an observern";
    }
}

class Subscriber1 implements Subscriber{
    public function EventCall($str) {
        echo "Subscriber1 event occured $strn";
    }
}

class Subscriber2 implements Subscriber {
    private $data;
    public function __construct($data) {
        $this->data = $data;
    }
    public function EventCall($str) {
        echo "Subscriber2 event occured $str data is " . $this->data . "n";
    }
}

class Subscriber3 implements Subscriber {
    public function EventCall($str) {
        echo "Subscriber3 event occured $strn";
    }
}

And now let’s make some instances of these:

$observer = new Observer();
$subscriber1 = new Subscriber1();
$subscriber2 = new Subscriber2('one');
$subscriber2too = new Subscriber2('two');
$subscriber3 = new Subscriber3();

$observer->Subscribe($subscriber1);
$observer->Subscribe($subscriber2);
$observer->Subscribe($subscriber2);
$observer->Subscribe($subscriber2too);
$observer->Subscribe($subscriber3);

$observer->Event('wow check out this awesome message that is being passed, bro.');
$observer->Talk();

$observer->Unsubscribe($subscriber2);

$observer->Event('what unheard of madness will happen next?');

And of course the output is:

Subscriber1 event occured wow check out this awesome message that is being passed, bro.

Subscriber2 event occured wow check out this awesome message that is being passed, bro. data is one

Subscriber2 event occured wow check out this awesome message that is being passed, bro. data is two

Subscriber3 event occured wow check out this awesome message that is being passed, bro.

I am an observer

Subscriber1 event occured what unheard of madness will happen next?

Subscriber2 event occured what unheard of madness will happen next? data is two

Subscriber3 event occured what unheard of madness will happen next?

Consider the following three scenarios:

1. class Dog {
   ...
   public function Bark($str) {
      echo $str;
   }
   ... }
   
   

class AnimalCommunication { … public function DogBark(Dog $dog, $str) { $dog->Bark($str); } … }

2. class Dog {
   ...
   public function Bark($str) {
      echo $str;
   }
   ... }
   
   
   

class AnimalCommunication { … public function AnimalCommunicate($str) { echo $str; } … }

3. Interface IAnimal {
   public function Speak($str); }
   
   

Class Dog implements IAnimal { … public function Speak($str) { $this->Bark($str); } …. } class AnimalCommunication { … public function AnimalCommunicate(IAnimal $animal, $str) { $animal->speak($str); } … }

Note the following about these examples:

1. The first is tightly coupled to the dog class, and hence is not very extensible.
2. The second is coupled to echo. It does not allow different “animals” to output their text differently. What if we later added a TelepathicGecko class, which didn’t echo out to speak, but rather published to some ESP API somewhere? Clearly the coupling here is not ideal either.
3. The third is best. By programming to an interface, we reduce coupling to the minimum necessary amount.

A promise is a way to defer the execution of a given routine until the data it needs to run is ready. This is a very useful pattern in asynchronous languages, so using promises in a language like javascript is a great idea.

Of course PHP is (without forking) totally synchronous so there is really no reason to implement the promise pattern in PHP.

But the motto of every programmer is “if it’s a bad idea, I will do it!” (no, it isn’t), so here’s an implementation of promises in PHP:

class PromiseClass {
    private $callbacks = array();
    private $last_return;
    function promise($promise) {
        if (get_class($promise) == 'Promise') {
            return $promise;
        } else if (is_callable($promise)) {
            $this->then($promise);
            return $this;
        }
    }
    function then (callable $callback) {
        $this->callbacks[] = $callback;
        return $this;
    }
    function resolve () {
        $callback = array_shift($this->callbacks);
        if (is_callable($callback)) {
            $this->last_return = $callback($this->last_return);
        }
        if (count($this->callbacks) > 0) {
            $this->resolve();
        }
    }
}

A few things to note here:

1. First you will have to make an instance of the class.
2. You start by passing a function to the promise method. You could use then but the code wouldn’t look as descriptive or read as well.
3. You can then add any functions that would be run after with successive calls to then.
4. None of the functions that have been set up will be run until you call the resolve method on the object.

Here’s an example of usage of this useless and pointless class:

$promiser = new PromiseClass();

$promiser->promise(function() {
        echo "sleepingn";
        sleep(3);
        return 3;
    })
    ->then(function($args) {
        echo "that farn$argsn";
        sleep(1);
    })
    ->then(function() {
        echo "even farthernn";
    });

$promiser->resolve();    

Note: I’ve added some sleep statements here so it almost seems like something asynchronous is happening. Really sleep is just blocking. The output will be something like:

sleeping
that far
3
even farther