10.1 Pattern Observer

Intent

Define a one-to-many dependency between objects so that when one object changes, all its dependents are notified and updated automatically. This pattern observes the change of one particular attribute and notifies all its dependents. It uses the Smalltalk change/update mechanism.

Motivation

A common side-effect of partitioning a system into a collection of cooperating classes is the need to maintain consistency between related objects. You don't want to achieve consistency by making the classes tightly coupled, because that reduces their reusability.

Applicability

Use the Observer pattern in any of the following situations:

When an abstraction has two aspects, one dependent on the other. Encapsulating these aspects in separate objects lets you vary and reuse them independently.
When a change to one object requires changing others, and you don't know how many objects need to be changed.
When an object should be able to notify other objects without making assumptions about who these objects are. In other words, you don't want these objects tightly coupled.

Participants

Objects:

target.
The Observer-Object to install pattern to.
sourceClass (preset)
The class of the Subject which should be observed. If left empty, the target class is assumed.

Attributes:

attribute
The attribute that should be observed.

Methods:

init (optional, preset)
The name of the init method that registers the Observer with its sourceClass upon initialization.

Interfaces

action (optional)
Call the corresponding method if the observer changes. If the method expects an argument (i.e. the method name ends with a colon (:)), the new Value is given as argument when the method is called. The participants method and code can be used together or exclusively.

Expressions:

source (preset)
An expression that gives the observed object. Usually this expression follows a relation and returns the connected object. The actual object (self or this) is used if the parameter is not set.
code (optional)
The code that should be executed upon changing of the observer. Can be left empty if a method should be called (see participant action (optional)).

Consequences

The Observer pattern lets you vary subjects and observers independently. You can reuse subjects without reusing their observers, and vice versa. It lets you add observers without modifying the subject or other observers.

Further benefits and liabilities of the Observer pattern include the following:

Abstract coupling between Subject and Observer
Support for broadcast communication
Unexpected updates

Implementation

{attribute}:

...
self changed: #{attribute} with: newValue.

update: anAspect with: newValue from: aSender

    super update: anAspect with: newValue from: aSender.
    (anAspect = #{attribute}) ifTrue: [ {code} or {action} ].
     ].
    ... other aspects ...
    ^self

{init}

    ((self dependents includes: {source}) or: [ {source} isNil ])
        ifFalse: [{source} addDependent: self]
    self {establish}

AG VLSI Design and Architecture

SFB 501 - Project D1: Application System "Buildings"

PSiGene

Pattern Catalog