| |
JAVA
DESIGN PATTERNS
Behavioral
Patterns - Command Pattern
This
is another of the data-driven pattern. The client
invokes a particular module using a command.
The client passes a request, this request gets
propagated as a command. The command request
maps to particular modules. According to the
command, a module is invoked.
This pattern is different from the Chain of
Responsibility in a way that, in the earlier
one, the request passes through each of the
classes before finding an object that can take
the responsibility. The command pattern however
finds the particular object according to the
command and invokes only that one.
It’s like there is a server having a lot of
services to be given, and on Demand (or on command),
it caters to that service for that particular
client.
A classic example of this is a restaurant. A
customer goes to restaurant and orders the food
according to his/her choice. The waiter/ waitress
takes the order (command, in this case) and
hands it to the cook in the kitchen. The cook
can make several types of food and so, he/she
prepares the ordered item and hands it over
to the waiter/waitress who in turn serves to
the customer.
Let’s have a look at this example with Java
code.
First thing is the Order. The order is made
of command which the customer gives the waiter.
Order.java
| package
bahavioral.command;
/**
* Order.java
* This is the command. The customer orders
and
* hands it to the waiter.
*/
public class Order {
|
| |
private String command;
public Order(String command) {
this.command = command;
} |
| }//
End of class |
The
other thing is the waiter who takes the order
and forwards it to the cook.
Waiter.java
| package
bahavioral.command;
/**
* A waiter is associated with multiple
customers and multiple orders
*/
public class Waiter {
|
| |
public Food takeOrder(Customer cust, Order
order) {
Cook cook = new Cook();
Food food = cook.prepareOrder(order, this);
return food;
} |
| }//
End of class |
The
waiter calls the prepareFood method of the cook
who in turn cooks.
Cook.java
| package
bahavioral.command;
public
class Cook {
|
| |
public Food prepareOrder(Order order, Waiter
waiter) {
Food food = getCookedFood(order);
return food;
}
public
Food getCookedFood(Order order) {
Food food = new Food(order);
return food;
}
|
| }//
End of class |
Now,
here, the waiter takes command and wraps it
in an order, the order is associated to a particular
customer. For, the cook, the order is associated
to a cook and also Food is associated to the
Order.
The
order is an object which depends on the command.
The food item will change as soon as the command
changes. This is loose-coupling between the
client and the implementation.
|
|
