We argued back and forth at my workplace about using the Observer pattern for one of the problems. I somehow smell "superfluous", but open up ideas. Thus the requirement
We have a hierarchy of objects → order and several items in the order. When an order is canceled, all items must be canceled.
To do this, we created the OrderCancel class, which is the Subject in the idiom of the Observer template, and the LineItemCancel class, which is the Observer. We also have an OrderManager class with the cancelOrders (List orders) method, which creates an instance of OrderCancel and the corresponding LineItemCancel objects, and then registers them all in 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() {
}
}
, . . , , .
.