are most specifically concerned with

Transcription

1 Observer

2 Behavioral Patterns Behavioral patterns are those patterns that are most specifically concerned with communication between objects

3 Introduction Name Observer Also Known As Dependents, Publish-Subscribe

4 Observer Intent Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically Use the Observer pattern: When an abstraction has two aspects, one dependent on the other. 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.

5 Structure

6 Participants Subject knows its observers. Any number of Observer objects may observe a subject. provides an interface for attaching and detaching Observer objects. Observer defines an updating interface for objects that should be notified of changes in a subject. ConcreteSubject stores state of interest to ConcreteObserver objects. sends a notification to its observers when its state changes. ConcreteObserver maintains a reference to a ConcreteSubject object. stores state that should stay consistent with the subject's. implements the Observer updating interface to keep its state consistent with the subject's.

7 Collaborations

8 SpreadSheet Example

9 SpreadSheet Example How to implement a spreadsheet?

10 Java's Implementation Java API implements a framework for this pattern Java's observer interface is the Observer abstract class in the pattern Java's Observable class is the Subject abstract class in the pattern Class java.util.observable Observable object may have any number of Observers Whenever the Observable instance changes, it notifies all of its observers Notification is done by calling the update() method on all observers. Interface java.util.observer When implemented, this interface allows all classes to be observable by instances of class Observer

11 java.util.observable Methods addobserver(observer) Adds an observer to the observer list. clearchanged() Clears an observable change. countobservers() Counts the number of observers. deleteobserver(observer) Deletes an observer from the observer list. deleteobservers() Deletes observers from the observer list. haschanged() Returns a true boolean if an observable change has occurred.

12 java.util.observable Methods notifyobservers() Notifies all observers if an observable change occurs. notifyobservers(object) Notifies all observers of the specified observable change which occurred. setchanged() Sets a flag to note an observable change. Interface java.util.observer update Called when observers in the observable list need to be updated

13 A Java Example The Classes indicates interface

14 Class Descriptions Counter A Counter can increase or decrease by one. Each time a counter changes value, it notifies its observers of the type of change. IncreaseDectector IncreaseDetector is an observer that observes counters. IncreaseDetector counts the number of times one of its observables increases. It notifies its observers when it changes

15 Class Descriptions CounterButton Abstract class for changing a counter each time the button is pressed IncreaseButton A button that increases a counter each time the button is pressed DecreaseButton A button that decreases a counter each time the button is pressed

16 Class Descriptions CounterView A parent window view that observes a counter. Does nothing with counter. Used as parent for other views. CounterTextView A window for displaying the value of a counter in ASCII. ButtonController A window for changing the value of a counter using IncreaseButton and DecreaseButton. RectangleView Draws a colored rectangle that depends on two counters. One counter is the width of the rectangle, the other counter is the height of the rectangle. The color of rectangle varies with its shape.

17 class Counter /** A counter can increase/decrease by 1. Each time a counter changes value, it notifies its observers of the type of change. */ class Counter extends Observable { public static final String INCREASE = "increase"; public static final String DECREASE = "decrease"; private int count = 0; private String label; public Counter( String label ) { this.label = label; public String label() { return label; public int value() { return count; public String tostring() { return String.valueOf( count ); public void increase() { count++; setchanged(); notifyobservers( INCREASE ); public void decrease() { count--; setchanged(); notifyobservers( DECREASE );

18 class IncreaseDetector /** * IncreaseDetector is an observer that observes counters. *IncreaseDetector counts the number of times one of its * observables increases. */ class IncreaseDetector extends Counter implements Observer { public IncreaseDetector( String label ) { super( label ); public void update( Observable whatchanged, Object message) { if ( message.equals( Counter.INCREASE) ) increase();

19 abstract class CounterButton /** * An abstract class for changing a counter each time the button is pressed */ abstract t class CounterButton tt extends Button { protected Counter count; public CounterButton( String buttonname, Counter count ) { super( buttonname ); this.count = count; public boolean action( Event processnow, Object argument ) { changecounter(); return true; abstract protected void changecounter();

20 class IncreaseButton /** * A button that increases a counter each time it is pressed */ class IncreaseButton extends CounterButton { public IncreaseButton( Counter count ) { super( "Increase", count ); protected void changecounter() { count.increase();

21 class DecreaseButton /** * A button that decreases a counter each time it is pressed */ class DecreaseButton extends CounterButton { public DecreaseButton( Counter count ) { super( "Decrease", count ); protected void changecounter() { count.decrease();

22 class CounterView /** * A parent window view that observes a counter */ class CounterView extends Frame implements Observer { public CounterView( String label, int x, int y, int width, int height ) { settitle( label ); reshape(x, y, width, height ); setlayout( new FlowLayout() ); /** * Redraw the window when an observed counter changes */ public void update(observable counter, Object argument) { repaint();

23 class CounterTextView /** * A window for displaying the value of a counter in ascii */ class CounterTextView tvi extends CounterView { Counter model; public CounterTextView( Counter model, String label, int x, int y, int width, int height ) { super( label, x, y, width, height ); this.model = model; model.addobserver( this ); show(); public void paint( Graphics display ) { int y = bounds().height - 20; int x = 20; display.drawstring( "The value of " + model.label() + " is " + model, x, y );

24 class ButtonController /** * A window for changing the value of a counter */ class ButtonController t extends CounterView { public ButtonController( Counter model, int x, int y, int width, int height ) { super( model.label(), x, y, width, height ); model.addobserver( this ); // show the value of the counter new CounterTextView( model, // buttons to change counter add( new IncreaseButton( model )); add( new DecreaseButton( model )); show(); "Value of " + model.label(), x + width + 5,y, 150, 50);

25 class RectangleView /** * Draws a colored rectangle that depends on two counters. One counter is the width, the other counter is the height ht of the rectangle. The color of rectangle varies with its shape */ class RectangleView extends CounterView { Counter width; Counter height; public RectangleView( Counter rectwidth, Counter rectheight, int x, int y ) { super( "Rectangle", x, y, 150, 150 ); height = rectheight; width = rectwidth; rectwidth.addobserver( ddob this ); rectheight.addobserver( this ); show();

26 class RectangleView Continued public void paint( Graphics display ) { int x = 10; int y = 10; // Magnify value by 5 to get a bigger visual effect int height = 5 * this.height.value(); int width = 5 * this.width.value(); // Determine color. Colors chosen for fun. // The factor of 3 is just to magnify effect of change if (( width >= 0 ) && ( height >= 0 )) display.setcolor( setcolor( new Color( 3*width width, 3*height height, width + height) ); else if (( width < 0 ) && ( height >= 0 )) display.setcolor( Color.pink ); else if (( width >= 0 ) && ( height < 0 )) display.setcolor( setcolor( Color.orange orange ); else if (( width < 0 ) && ( height < 0 )) display.setcolor( Color.red ); display.fillrect(x, y, Math.abs(width), abs(width) Math.abs( abs( height ) );

27 Sample Program class TestButton { public static void main( String args[] ) { Counter x = new Counter( "x" ); Counter y = new Counter( "y" ); IncreaseDetector plus = new IncreaseDetector( "Pluses" ); x.addobserver( plus ); y.addobserver( plus ); new ButtonControler( x, 30, 30, 150, 50 ); new ButtonControler( y, 30, 100, 150, 50 ); new CounterTextView( plus, "# of increases", 30, 170, 150, 50); new RectangleView( x, y, 340, 30 );

28 Sample Program

29 Runtime Object Interaction

30 Consequences Abstract coupling between Subject and Observer Support for broadcast communication Unexpected updates Simple change in subject can cause numerous updates, which can be expensive or distracting Updates can take too long Subject can not perform any work until all observers are done

31 Implementation Issues Mapping subjects(observables) to observers Use list in subject Use hash table Observing more than one subject If an observer has more than one subject how does it know which one changed? Pass information in the update method Dangling references to Deleted Subjects Deleting a subject should not produce dangling references in its observers ers Make the subject notify its observers deleting the observers is not an option

32 Who Triggers the update? Have methods that change the state, trigger update class Counter extends Observable { // some code removed public void increase() { count++; setchanged(); notifyobservers( INCREASE ); If there are several of changes at once, you may not want each change to trigger an update It might be inefficient or cause too many screen updates

33 Who Triggers the update? Have clients call Notify at the right time class Counter extends Observable { // some code removed public void increase() { count++; { Counter pagehits = new Counter(); pagehits.increase(); pagehits.increase(); pagehits.increase(); pagehits.notifyobservers();

34 Make sure Subject is selfconsistent before Notification Important to make sure Subject state is self-consistent before calling Notify, because observers query the subject for its current state in the course of updating their own state This self-consistency rule is easy to violate unintentionally when Subject subclass operations call inherited operations.

35 Make sure Subject is selfconsistent before Notification For example: the notification in the following code sequence is trigged when the subject is in an inconsistent state: void MySubject::Operation (int newvalue) { BaseClassSubject::Operation(newValue); // trigger notification _myinstvar += newvalue; // update subclass state (too late!)

36 Make sure Subject is selfconsistent before Notification You can avoid this pitfall by sending notifications from template methods in abstract Subject classes Template Pattern Define the skeleton of an algorithm in an operation, deferring some steps to subclasses Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure

37 Make sure Subject is selfconsistent before Notification Define a primitive operation for subclasses to override Make Notify the last operation in the template method, which h will ensure that the object is selfconsistent when subclasses override Subject operations void Text::Cut (TextRange r) { ReplaceRange(r); // redefined in subclasses Notify(); Document which Subject operations trigger notifications

38 Specifying modifications of interest explicitly You can improve update efficiency by extending the subject's registration ti interface to allow registering i observers only for specific events of interest. When such an event occurs, the subject informs only those observers that t have registered interest t in that t event. One way to support this uses the notion of aspects for Subject objects. To register interest in particular events, observers are attached to their subjects using void Subject::Attach(Observer*, Aspect& interest); where interest specifies the event of interest. At notification time, the subject supplies the changed aspect to its observers as a parameter to the Update operation. For example: void Observer::Update(Subject*, Aspect& interest);

39 Avoiding observer-specific update protocols the push and pull models Often the subject broadcast additional information about the change. The subject passes this information as an argument to Update. The amount of information may vary widely.

40 Push Model At one extreme, which we call the push model The subject sends observers detailed information about the change, whether they want it or not the push model assumes subjects know something about their observers' needs The push model might make observers less reusable Subject classes make assumptions about Observer classes that might not always be true

41 Pull Model At the other extreme is the pull model the subject sends nothing but the most minimal notification, and observers ask for details explicitly thereafter The pull model emphasizes the subject's ignorance of its observers the pull model may be inefficient Observer classes must ascertain what changed without help from the Subject

42 Adding information about the change push model - add parameters in the update method class IncreaseDetector extends Counter implements Observer { // stuff not shown public void update( Observable whatchanged, Object message) { if ( message.equals( equals( INCREASE) ) increase(); class Counter extends Observable { // some code removed public void increase() { count++; setchanged(); notifyobservers( INCREASE );

43 Adding information about the change pull model - observer asks Subject what happened class IncreaseDetector extends Counter implements Observer { // stuff not shown public void update( Observable whatchanged ) { if ( whatchanged.didyouincrease() didyouincrease() ) increase(); class Counter extends Observable { // some code removed public void increase() { count++; setchanged(); notifyobservers( );