Command Design Pattern

1
Command Design Pattern

• Rick Mercer
• and Rice University

2
Command Pattern

• One object can send messages to other objects
  without knowing anything about the actual
  operation or the type of object
• Polymorphism lets us encapsulate a request for
  services as an object
• Establish a method signature name as an interface
• Vary the algorithms in the called methods

3
Java Examples

• Sun used the Command pattern to improve the event
  model in Java 1.1
• one example method signature
• public void actionPerfomed(ActionEvent e)
• JButtons and JTextFields send actionPerformed
  messages to "command" objects (the listeners)
  without knowing what will happen
• Event generators buttons, text fields, mouse
  have listener objects (actually a Vector of
  listener objects)

4
Uses

• The Command object can also be used when you need
  to tell the program to execute the command later.
• In such cases, you are saving commands as objects
  to be executed later
• You could also sending command objects over the
  network (demoed later) or save them in a
  collection class such as a Stack (undo/redo)

5
Example we saw before was Command

• Make 3 command classes
• Log instances by writing the objects to a file
• Read the objects later and execute them
• // Use these Persistence details
• String fileName "logfile"
• FileOutputStream bytesToDisk
• new FileOutputStream(fileName)
• ObjectOutputStream objectToBytes
• new ObjectOutputStream(bytesToDisk)
• // Store command as an object to exectute later
• WorkCommand command new DomesticEngineer()
• objectToBytes.writeObject(command)

6
A UML View of the Sample
7

• // Command design pattern. Decoupling producer
  from consumer
• public interface WorkCommand
• void execute()
• class DomesticEngineer implements WorkCommand,
  Serializable
• public void execute()
• System.out.println("take out the trash")
• class Politician implements WorkCommand,
  Serializable
• public void execute()
• System.out.print("take money from the rich,
  ")
• System.out.println("take votes from the
  poor")
• class Programmer implements WorkCommand,
  Serializable

8

• // Write a list of commands for later use
• String fn "logfile"
• FileOutputStream bytesToDisk new
  FileOutputStream(fn)
• ObjectOutputStream objectToBytes
• new ObjectOutputStream(bytesToDisk)
• // Imagine commands are some important logged
  transaction
• WorkCommand commandWork new
  DomesticEngineer()
• WorkCommand commandPol new Politician()
• WorkCommand commandProg new Programmer()
• // Create a list to save for later use
• ArrayList allCommands new ArrayList()
• allCommands.add(commandWork)
• allCommands.add(commandPol)
• allCommands.add(commandProg) // add more,
  mix 'em up
• // Save the list to a file for later use
• objectToBytes.writeObject(allCommands)
• objectToBytes.close()

9

• // Read a list of commands stored as objects
  // and execute them
• String fileName "logfile"
• FileInputStream diskToStreamOfBytes null
• ObjectInputStream bytesToObjects null
• List list null
• diskToStreamOfBytes new FileInputStream(file
  Name)
• bytesToObjects new ObjectInputStream(diskToS
  treamOfBytes)
• list (ArrayList) bytesToObjects.readObject()
  
• bytesToObjects.close()
• WorkCommand command null
• for (WorkCommand command list)
• command.execute()

10
Code Demo

• Can also send objects over the network
• Need these three files
• WorkCommand.java
• CommandClient.java
• CommandServer.java

11
Summary

• The Command design pattern encapsulates the
  concept of a command into an object.
• A command object could be sent across a network
  to be executed elsewhere or it could be saved as
  a log of operations.

12
References

• Adelson and Soloway B. Adelson and E. Soloway.
  The Role of Domain Experience in Software Design.
  IEEE Trans. on Software Engineering, V SE-11, N
  11, 1985, pp. 1351-1360.
• Linn and Clancy M. Linn and M. Clancy, The Case
  for Case Studies of Programming Problems.
  Communications of the ACM V 35 N 3, March 1992,
  pp. 121-132.
• Soloway and Ehrlich E. Soloway and K. Ehrlich,
  Empirical Studies of Programming Knowledge, IEEE
  Transactions on Software Engineering V SE-10, N
  5, September 1984.
• Curtis B. Curtis, Cognitive Issues in Reusing
  Software Artifacts. In Software Reusability, V
  II. ed. T. Biggerstaff and A. Perlis, Addison
  Wesley 1989, pp. 269-287.
• http//www.exciton.cs.rice.edu/JavaResources/Desig
  nPatterns/command.htm