We have been arguing back and forth at my work place about the use of the Observer pattern for one of the problems. I somehow smell "overuse" but am open to ideas. So the requirement is
We have a hierarchy of objects -> an order and multiple line items in the order. When the order is cancelled, all the line items need to cancelled.
To do this, we have created a OrderCancel class which is the Subject in the Observer pattern idiom and LineItemCancel class which is the Observer. We also have a OrderManager class with a cancelOrders(List orders) method which instantiates the OrderCancel and the corresponding LineItemCancel objects and then registers them all in the OrderCancel. The code is as follows.
public class OrderManager {
public void cancelOrders(List<Order> orders){
for(Order order :orders){
OrderCancel orderCancel = new OrderCancel(order);
Listener listener = new LineItemCancel(order);
orderCancel.addListeners(listener);
orderCancel.cancel();
}
}
}
public class OrderCancel implements Subject {
private List<Listener> listeners = new ArrayList<Listener>();
private Order order;
public OrderCancel(Order order) {
this.order = order;
}
@Override
public void addListeners(Listener listener) {
listeners.add(listener);
}
@Override
public void notifyListeners() {
for(Listener listener : listeners){
listener.update();
}
}
public void cancel() {
notifyListeners();
cancelOrder();
}
private void cancelOrder() {
}
}
public class LineItemCancel implements Listener {
private Order order;
public LineItemCancel(Order order) {
this.order = order;
}
@Override
public void update() {
cancelLineItem();
}
private void cancelLineItem() {
}
}
I am convinced this is improper usage. But I am not able to convince the designers of this class. I am trying to figure out myself if this is right as the designer is one of the architects at work.
Looking forward to hear your thoughts.
