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.

Patterns
Creational Patterns
Factory Pattern
Abstract Factory Pattern
Singleton Pattern
Builder Pattern
Prototype Pattern
Structural Patterns
Adapter Pattern
Bridge Pattern
Composite Pattern
Decorator Pattern
Facade Pattern
Flyweight Pattern
Proxy Pattern
Behavioral Patterns
Chain of Responsibility Pattern
Command Pattern
Interpreter Pattern
Iterator Pattern
Mediator Pattern
Momento Pattern
Observer Pattern

State Pattern
Strategy Pattern
Template Pattern

Visitor Pattern
Use of this website constitutes acceptance of the AllAppLabs.com Terms and Conditions