CS 635 Advanced Object-Oriented Design & Programming Spring Semester, 2004 Command, Decorator & Proxy
	Previous    Lecture Notes Index    Next     © 2004, All Rights Reserved, SDSU & Roger Whitney San Diego State University -- This page last updated 19-Feb-04

Doc 9, Command, Decorator & Proxy Slide # 2

Command

Structure

Invoker be a menu

Client be a word processing program

Receiver a document

Action be save

Doc 9, Command, Decorator & Proxy Slide # 3

When to Use the Command Pattern

• When you need an action as a parameter

Commands replace callback functions

• When you need to specify, queue, and execute requests at different times

• When you need to support undo

• When you need to support logging changes

• When you structure a system around high-level operations built on primitive operations

A Transactions encapsulates a set of changes to data

Systems that use transaction often can use the command pattern

• When you need to support a macro language

Doc 9, Command, Decorator & Proxy Slide # 4

Consequences

Doc 9, Command, Decorator & Proxy Slide # 5

abstract class Command
   {
   abstract public void execute();
   }
   
class OpenCommand extends Command
   {
   private Application opener;
   
   public OpenCommand( Application theOpener )
      {
      opener = theOpener;
      }
   
   public void execute()
      {
      String documentName = AskUserSomeHow();
      
      if ( name != null )
         {
         Document toOpen = 
               new Document( documentName );
         opener.add( toOpen );
         opener.open();
         }
      }
   }

Doc 9, Command, Decorator & Proxy Slide # 6

class Menu
   {
   private Hashtable menuActions = new Hashtable();
   
   public void addMenuItem( String displayString, 
                  Command itemAction )
      {
      menuActions.put( displayString, itemAction );
      }
   public void handleEvent( String itemSelected )
      {
      Command runMe;
      runMe = (Command) menuActions.get( itemSelected );
      runMe.execute();
      }
   // lots of stuff missing
   }

Doc 9, Command, Decorator & Proxy Slide # 7

class MacroCommand extends Command
   {
   private Vector commands = new Vector();
   
   public void add( Command toAdd )
      {
      commands.addElement( toAdd );
      }
   
   public void remove( Command toRemove )
      {
      commands.removeElement( toAdd );
      }
   
   public void execute()
      {
      Enumeration commandList = commands.elements();
      
      while ( commandList.hasMoreElements() )
         {
         Command nextCommand;
         nextCommand = (Command)
                      commandList.nextElement();
         nextCommand.execute();
         }
      }
   }

Doc 9, Command, Decorator & Proxy Slide # 8

• Serializes object to save them to disk
• Uses commands when modifying objects
• Keeps log of commands

Doc 9, Command, Decorator & Proxy Slide # 9

import java.util.*;
import org.prevayler.implementation.AbstractPrevalentSystem;
public class Restaurant extends AbstractPrevalentSystem {
   private String name;
   ArrayList ratings = new ArrayList();
   
   public Restaurant(String newName) { name = newName;}
   
   public String name() {return name;}
   
   public void addRating( int newRating) {
      ratings.add( new Integer(newRating));
   }
   
   public float getRating() {
      if (ratings.size() == 0 ) 
         return -1;
      int total = 0;
      for (int k =0; k < ratings.size();k++)
         total = total + ((Integer)ratings.get(k)).intValue();
      return total/ ratings.size();
   }
}
Doc 9, Command, Decorator & Proxy Slide # 10

import java.io.Serializable;
import org.prevayler.Command;
import org.prevayler.PrevalentSystem;
public class AddRatingCommand implements Command {
   private final int newRating;
   
   public AddRatingCommand(int rating) {
      newRating = rating;
   }
   
   public Serializable execute(PrevalentSystem system) {
      ((Restaurant)system).addRating(newRating);
      return null;
   }
}
Doc 9, Command, Decorator & Proxy Slide # 11

import java.util.*;
import org.prevayler.implementation.SnapshotPrevayler;
   
public class PrevaylerExample {
   
    public static void main (String args[]) throws Exception {
      SnapshotPrevayler samsDinerData = 
         new SnapshotPrevayler(new Restaurant("Sams Diner"), "food");
   
      System.out.println( “Start”);
      Restaurant samsDiner = (Restaurant) samsDinerData.system();
      System.out.println( samsDiner.getRating() );
      samsDinerData.executeCommand( new AddRatingCommand( 5));
      System.out.println( samsDiner.getRating() );
    }
}

Doc 9, Command, Decorator & Proxy Slide # 12

public class PrevaylerExample {
      
    public static void main (String args[]) throws Exception {
      SnapshotPrevayler samsDinerData = 
         new SnapshotPrevayler(new Restaurant("Sams Diner"), "food");
   
      System.out.println( “Start”);
      Restaurant samsDiner = (Restaurant) samsDinerData.system();
      System.out.println( samsDiner.getRating() );
      samsDinerData.executeCommand( new AddRatingCommand( 10));
      System.out.println( samsDiner.getRating() );
    }
}

Doc 9, Command, Decorator & Proxy Slide # 13

Doc 9, Command, Decorator & Proxy Slide # 14

import java.util.*;
import java.lang.reflect.*;

public class Command
   {
   private Object receiver;
   private Method command;
   private Object[] arguments;
   
   public Command(Object receiver, Method command, 
                           Object[] arguments )
      {
      this.receiver = receiver;
      this.command = command;
      this.arguments = arguments;
      }
   public void execute() throws InvocationTargetException, 
                                 IllegalAccessException
      {
      command.invoke( receiver, arguments );
      }
   }
Doc 9, Command, Decorator & Proxy Slide # 15

public class Test {
   public static void main(String[] args) throws Exception 
      {
      Vector sample = new Vector();
      Class[] argumentTypes = { Object.class };
      Method add = 
         Vector.class.getMethod( "addElement", argumentTypes);
      Object[] arguments = { "cat" };
      
      Command test = new Command(sample, add, arguments );
      test.execute();
      System.out.println( sample.elementAt( 0));
      }
   }

Doc 9, Command, Decorator & Proxy Slide # 16

Object subclass: #PluggableCommand
   instanceVariableNames: 'receiver selector arguments '
   classVariableNames: ''
   poolDictionaries: ''
   category: 'Whitney-Examples'

receiver: anObject selector: aSymbol arguments: anArrayOrNil
   ^super new
      setReceiver: anObject 
      selector: aSymbol 
      arguments: anArrayOrNil

setReceiver: anObject selector: aSymbol arguments: anArrayOrNil
   receiver := anObject.
   selector := aSymbol.
   arguments := anArrayOrNil isNil
               ifTrue:[#( )]
               ifFalse: [anArrayOrNil]

execute
   ^receiver 
      perform: selector 
      withArguments: arguments

Doc 9, Command, Decorator & Proxy Slide # 17

| sample command |
sample := OrderedCollection new.
command := PluggableCommand
      receiver: sample
      selector: #add:
      arguments: #( 5 ).
command execute.
^sample at: 1

Doc 9, Command, Decorator & Proxy Slide # 18

Command Processor

• Contains all command objects

• Schedules the execution of commands

• May store the commands for later unto

• May log the sequence of commands for testing purposes

• Uses singleton to insure only one instance

Doc 9, Command, Decorator & Proxy Slide # 19

Structure

Doc 9, Command, Decorator & Proxy Slide # 20

Consequences

• Flexibility in the way requests are activated

Different user interface elements can generate the same kind of command object

Allows the user to configure commands performed by a user interface element

• Flexibility in the number and functionality of requests

Adding new commands and providing for a macro language comes easy

• Programming execution-related services

Commands can be stored for later replay

Commands can be logged

Commands can be rolled back

• Testability at application level

• Concurrency

Allows for the execution of commands in separate threads

Doc 9, Command, Decorator & Proxy Slide # 21

• Efficiency loss

• Potential for an excessive number of command classes

Try reducing the number of command classes by:

Grouping commands around abstractions

Unifying simple commands classes by passing the receiver object as a parameter

• Complexity

How do commands get additional parameters they need?

Doc 9, Command, Decorator & Proxy Slide # 22

Functor

• A single member function (method)

final class StudentNameComparator implements Comparator {
   
   public int compare( Object leftOp, Object rightOp ) {
      String leftName = ((Student) leftOp).name;
      String rightName = ((Student) rightOp).name;
      return leftName.compareTo( rightName );
   }
}

Doc 9, Command, Decorator & Proxy Slide # 23

• Using inheritance we can factor common code to a base class
• Same run-time flexibility as function pointer
• Lends it self to poor abstractions

Use functors when you would be tempted to use function pointers

Doc 9, Command, Decorator & Proxy Slide # 24

Decorator

Class Structure

Doc 9, Command, Decorator & Proxy Slide # 25

Motivation - Text Views

side scroll bar

Bottom scroll bar

3D border

Flat border

TextView

TextViewWithNoBorder&SideScrollbar

TextViewWithNoBorder&BottomScrollbar

TextViewWithNoBorder&Bottom&SideScrollbar

TextViewWith3DBorder

TextViewWith3DBorder&SideScrollbar

TextViewWith3DBorder&BottomScrollbar

TextViewWith3DBorder&Bottom&SideScrollbar

TextViewWithFlatBorder

TextViewWithFlatBorder&SideScrollbar

TextViewWithFlatBorder&BottomScrollbar

TextViewWithFlatBorder&Bottom&SideScrollbar

Doc 9, Command, Decorator & Proxy Slide # 26

class TextView {
   Border myBorder;
   ScrollBar verticalBar;
   ScrollBar horizontalBar;
   
   public  void draw() {
      myBorder.draw();
      verticalBar.draw();
      horizontalBar.draw();
      code to draw self
   }   
   etc.
}

Doc 9, Command, Decorator & Proxy Slide # 27

Doc 9, Command, Decorator & Proxy Slide # 28

Applicability

• To add responsibilities to individual objects dynamically and transparently

• For responsibilities that can be withdrawn

• When subclassing is impractical - may lead to too many subclasses

Windows, streams, fonts

Consequences

So checking object identification can cause problems

   if ( aComponent instanceof TextView ) blah

Doc 9, Command, Decorator & Proxy Slide # 29

Implementation Issues

• Simple forward
• Extended forward
• Override

Doc 9, Command, Decorator & Proxy Slide # 30

Examples

import java.io.*;
import sdsu.io.*;
class  ReadingFileExample
   {
   public  static  void  main( String  args[]  ) throws Exception
      {
      FileInputStream inputFile;
      BufferedInputStream bufferedFile;
      ASCIIInputStream  cin;
         
      inputFile = new FileInputStream( "ReadingFileExample.java" );
      bufferedFile = new BufferedInputStream( inputFile );
      cin = new ASCIIInputStream( bufferedFile );
   
      System.out.println(  cin.readWord()  );
   
      for  ( int  k = 1 ;  k  <  4;  k++ )
         System.out.println(  cin.readLine()  );
      }
   }
Doc 9, Command, Decorator & Proxy Slide # 31

Doc 9, Command, Decorator & Proxy Slide # 32

Proxy

Structure

Doc 9, Command, Decorator & Proxy Slide # 33

Dynamics

Doc 9, Command, Decorator & Proxy Slide # 34

public class Proxy 
   {
   Foo target;
   public float bar(int size )
      {
      preprocess here
      float answer =  target.bar( size);
      postProcess here
      return answer;
      }
   
   other methods as needed
   }

Doc 9, Command, Decorator & Proxy Slide # 35

Reasons for Object Proxies

public class HelloClient  {
   public static void main(String args[])  {
      try  {
         String server = getHelloHostAddress( args);
         Hello proxy = (Hello) Naming.lookup( server );
         String message = proxy.sayHello();
         System.out.println( message );
      } 
      catch ( Exception error) 
         {  error.printStackTrace(); }
   }
}
Doc 9, Command, Decorator & Proxy Slide # 36

• Creates/accesses expensive objects on demand

• You may wish to delay creating an expensive object until it is really accessed

• It may be too expensive to keep entire state of the object in memory at one time

• Provides different objects different level of access to original object

• Multiple local clients can share results from expensive operations: remote accesses or long computations

• Protect local clients from outside world

Doc 9, Command, Decorator & Proxy Slide # 37

• Synchronize multiple accesses to real subject

public class Table {   
   public Object elementAt( int row, int column ){ blah   }
   public void setElementAt(Object element, int row, int column )
      { blah}
}
   
public class RowLockTable {
   Table realTable;
   Integer[] locks;
   
   public RowLockTable( Table toLock) {
      realTable = toLock;
      locks = new String[ toLock.numberOfRows() ];
      for (int row = 0; row< toLock.numberOfRows(); row++ )
         locks[row] = new Integer(row);
      }
   
   public Object elementAt( int row, int column ) {
      synchronized ( locks[row] ) {
         return realTable.elementAt( row, column);
      }
   }
   public void setElementAt(Object element, int row, int column ){
      synchronized ( locks[row] )   {
         return realTable.setElementAt(element, row, column);
      }
   }
}
Doc 9, Command, Decorator & Proxy Slide # 38

Doc 9, Command, Decorator & Proxy Slide # 39

Smalltalk Proxy Tricks

doesNotUnderstand:

Doc 9, Command, Decorator & Proxy Slide # 40

Object subclass: #Proxy
   instanceVariableNames: 'target '
   classVariableNames: ''
   poolDictionaries: ''
   category: 'Whitney-Examples'

on: anObject
   ^super new target: anObject

doesNotUnderstand: aMessage 
   ^target
      perform: aMessage selector 
      withArguments: aMessage arguments

target: anObject
   target := anObject

Doc 9, Command, Decorator & Proxy Slide # 41

| wrapper |
wrapper := Proxy on: Transcript.
wrapper open.
wrapper show: 'Hi mom'.

| wrapper |
wrapper := Proxy on: 3.
wrapper + 5.

| wrapper |
wrapper := Proxy on: 'Hi '.
wrapper , ' mom'.

Doc 9, Command, Decorator & Proxy Slide # 42

• Can be hard to debug
• Is slower than regular message send

Previous    visitors since 19-Feb-04    Next