Command Design Pattern
Agenda
* What is the Command Desgn Pattern (CDP) * Object Interaction and Command Object Hierarchy * Command Pattern generic UML * Recorded demonstration * Java example code * What are the benefits/drawbacks of the CDP
The intent of this presentation is to provide a walk through and recorded demonstration of the command design pattern.
What is the Command Design Pattern? * A Behavioral design pattern * An object is utilized to represent and encapsulate information * The information includes method name, object owning method, and method value parameters * The information can be called immediately or at a later time
The command pattern is a behavioral design pattern in which an object is utilized to represent and encapsulate information (Banas, 2012). The interesting thing about the command design pattern is that it can allow one to store lists of commands which can be called immediately or at a later time.
What is the Command Design Pattern? * Client specifies which command to run when the execute() method is invoked on one of the encapsulated methods * An object named “Invoker” transfers the Command to a separate object named “Receiver” which executes the correct code
The command pattern allows the client to determine which command to run when the execute method is invoked in the command interface (Kuchana, 2004). After the command is “invoked” to execute, he concrete command that is identified transfers the command to the receiver to execute the correct command (Kuchana, 2004). This will all be demonstrated in upcoming slides.
Core Object Interaction and Command Object Hierarchy

Both UML designs in this slide are taken from the e-book “Software Architecture Design Patterns in Java”, figures 30.1 and 30.2 respectively (Kuchana, 2004).
The first (top) design is intended to demonstrate object interaction prior to implementing the command design pattern. In this object oriented design, an application uses different objects to handle requirements (Kuchana, 2004). Implementation of the application relies on appointed objects whch will “invoke methods on these objects by passing required data as arguments” (chapter 30, p. 1)
The second (bottom) design is intended to demonstrate the command object hierarchy. In this figure the command object is the abstraction in which the method declaration is “execute” which (in the case of this UML design) is implemented by the two implementor (command) concrete classes (Kuchana, 2004).

Command Pattern UML

Putting it all together…
The UML diagram (Kuschana, 2004, figure 30.3) above demonstrates the combination of the core object interaction and the command object hierarchy. In this example I use a Device as the Receiver. A device could be a light, a television, a computer, or a radio, basically anything with an on/off switch, up/down volume or anything else which has a command that can undo or redo. The client sends instructions through the main method. The invoker is the control button which could be on a remote control. The Command Interface executes the commands upon the Invoker action, which in this case is a button click. The concrete commands are DeviceOn and DeviceOff which are self-explanatory. Many more commands could be added such as turn volume up/down, resize picture, or even undo last command. This takes us back to the receiver which is the device and after the commands are executed the device will respond accordingly.
Demonstrating the Remote Control
Java example code * Device on/off, volume up/down * Please review the code sample embedded
As demonstrated in the recorded example of implementing the command design pattern, the code was copied and pasted on a Word document which is embedded in this slide for your review. I added volume up and down concrete command classes in the code examples as well. This required an addition to the device class as well.
//Client class public class Client {

public static void main(String[] args) { ControlButton controlButton = new ControlButton();

Device aDevice = new Device();

Command deviceOn = new DeviceOnCommand(aDevice); Command deviceOff = new DeviceOffCommand(aDevice);

//switch on controlButton.setCommand(deviceOn); controlButton.clickButton(); System.out.println("Device is on");

//switch off controlButton.setCommand(deviceOff); controlButton.clickButton(); System.out.println("Device is off"); }
}

-------------------------------------------------------------------------------------------------------------------------------------
//Invoker class public class ControlButton { private Command command; public void setCommand (Command command) { this.command = command; } public void clickButton() { command.execute(); }
}

-------------------------------------------------------------------------------------------------------------------------------------

//Receiver class public class Device {

private int volume = 0; private boolean on; public void turnOn() { on = true; } public void turnOff() { on = false; } public void volumeUp(){ volume++; System.out.println("Device volume is at " + volume); } public void volumeDown() { volume--; System.out.println("Device volume is at " + volume); }

}

-------------------------------------------------------------------------------------------------------------------------------------
//Command Interface public interface Command { public void execute();

} -------------------------------------------------------------------------------------------------------------------------------------
//Concrete command class 1 public class DeviceOnCommand implements Command{

Device device; public DeviceOnCommand(Device device) { this.device = device; } public void execute() { device.turnOn(); }
}

-------------------------------------------------------------------------------------------------------------------------------------

//Concrete command class 2 public class DeviceOffCommand implements Command{

Device device; public DeviceOffCommand(Device device) { this.device = device; } public void execute() { device.turnOff(); }

}

//Concrete command 3

public class TurnDeviceUp implements Command {

Device aDevice; public TurnDeviceUp(Device newDevice){ aDevice = newDevice; } @Override public void execute() { aDevice.volumeUp(); } }

//Concrete command 4

public class TurnDeviceDown implements Command {

Device aDevice; public TurnDeviceDown(Device newDevice){ aDevice = newDevice; } @Override public void execute() { aDevice.volumeDown(); } }
What are the ‘benefits’ of the Command Design Pattern? * Allows a list of commands to be set aside for later use * Classes are excellent place to store executable procedures * Undo procedures for past commands can be implemented * If a history of requests is needed
What are the ‘drawbacks’ of the Command Design Pattern? * Many small classes must be created to store list of commands which can make the design seem very cluttered * Adding more operations leads to more concrete command classes * As many commands are added, determining which Command to use may lead to possible maintenance issues for the central controller
Summary
During the briefing we discussed: * What is the Command Desgn Pattern (CDP) * Object Interaction and Command Object Hierarchy * Command Pattern generic UML * Gave a Live demonstration * Java example code * What are the benefits/drawbacks of the CDP
Questions
* Please ask any questions by replying to my Command Pattern Design Presentation thread
References
Banas, D. (2012). Command pattern design tutorial. Newthinktank.com. Retrieved from: http://www.newthinktank.com/2012/09/command-design-pattern-tutorial/
Grand, M (2002) Patterns in java, volume 1: A catalog of reusable design patterns illustrated with UML, second edition. John Wiley & Sons. Retrieved from: http://library.books24x7.com.ezproxy.umuc.edu/assetviewer.aspx?bookid=5397&chunkid=403736962&rowid=722&noteMenuToggle=0&leftMenuState=1 James (2011). Design patterns uncovered: The command pattern. JamesSurge. Retrieved from: http://www.jamessugrue.ie/design/design-patterns-uncovered-the-command-pattern Kuchana, P. (2004) Software architecture design patterns in Java. Auerbach Publications. Retrieved from: http://library.books24x7.com.ezproxy.umuc.edu/assetviewer.aspx?bookid=9696&chunkid=925134648&rowid=837 Sierra, K., Robson, E., Bates, B., Freeman, E. (2004). Head first design patterns. SafariBooks. Retrieved from: https://www.safaribooksonline.com/library/view/head-first-design/0596007124/ch06.html