BigPug
BAN USERSorry I hit the Submit button too soon. Here is the complete answer.
Another way to design this using an Event Driven Architecture. The difference from the Observer pattern is that EDA asynchronously delivers message/event to the Subscriber. As a subscriber you subscribe to a central Event Keeper - EventDispatcher - in this case; and maybe go ahead and do other tasks. When the dispatch is done, the Event will be sent to you later.
import java.util.Date;
public class Order {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Date getDate() {
return new Date();
}
public Order (int id) {
this.id = id;
}
}
public interface Event {
Class<? extends Event> getType();
}
public interface Handler<E extends Event> {
public void onEvent(E event);
}
public class DeliveryBoy {
private String name;
public DeliveryBoy(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
}
public abstract class AbstractEvent implements Event {
public Class<? extends Event> getType() {
return getClass();
}
}
import java.util.HashMap;
import java.util.Map;
public class EventDispatcher {
private Map<Class<? extends Event>, Handler<? extends Event>> handlers;
public EventDispatcher() {
handlers = new HashMap<>();
}
public <E extends Event> void registerHandler(Class<E> eventType, Handler<E> handler) {
handlers.put(eventType, handler);
}
public <E extends Event> void dispatch(E event) {
Handler<E> handler = (Handler<E>) handlers.get(event.getClass());
if (handler != null) {
handler.onEvent(event);
}
}
}
public class OrderReceivedEvent extends AbstractEvent {
private Order order;
public OrderReceivedEvent(Order order) {
this.order = order;
}
public Order getOrder() {
return this.order;
}
}
public class UserAssignedEvent extends AbstractEvent {
private DeliveryBoy boy;
private Order order;
public UserAssignedEvent(DeliveryBoy boy, Order order) {
this.boy = boy;
this.order = order;
}
public DeliveryBoy getDeliveryBoy() {
return this.boy;
}
public Order getOrder() { return this.order; }
}
public class OrderPickedUpEvent extends AbstractEvent {
private Order order;
public OrderPickedUpEvent(Order order) {
this.order = order;
}
public Order getOrder() {
return this.order;
}
}
public class OrderDeliveredEvent extends AbstractEvent {
private Order order;
private DeliveryBoy boy;
public OrderDeliveredEvent(DeliveryBoy boy, Order order) {
this.order = order;
this.boy = boy;
}
public Order getOrder() {
return this.order;
}
public DeliveryBoy getDeliveryBoy() {
return this.boy;
}
}
public class OrderReceivedEventHandler implements Handler<OrderReceivedEvent> {
@Override
public void onEvent(OrderReceivedEvent event) {
System.out.println("Order ID - " + event.getOrder().getId() + " - Received on Date - " + event.getOrder().getDate());
}
}
public class UserAssignedEventHandler implements Handler<UserAssignedEvent> {
@Override
public void onEvent(UserAssignedEvent event) {
System.out.println("Delivery boy - " + event.getDeliveryBoy().getName() + " - is assigned to the Order ID - " + event.getOrder().getId());
}
}
public class OrderPickedUpEventHandler implements Handler<OrderPickedUpEvent> {
@Override
public void onEvent(OrderPickedUpEvent event) {
System.out.println("Order ID - " + event.getOrder().getId() + " - picked up on Date - " + event.getOrder().getDate());
}
}
public class OrderDeliveredEventHandler implements Handler<OrderDeliveredEvent> {
@Override
public void onEvent(OrderDeliveredEvent event) {
System.out.println("Order ID - " + event.getOrder().getId() + " - delivered on Date - " + event.getOrder().getDate() + " - by Delivery Boy - " + event.getDeliveryBoy().getName());
System.out.println();
}
}
public class TestEvent {
public static void main(String[] args) {
Queue<String> deliveryBoys = new LinkedList<>();
String[] nameOfDeliveryBoys = {"Tom", "Dick", "Harry", "Gordon", "Leon", "Michael"};
for (int i = 0; i < 10; i ++) {
deliveryBoys.add(nameOfDeliveryBoys[(int)(Math.random() * nameOfDeliveryBoys.length)]);
}
Queue<Order> orders = new LinkedList<>();
for (int j = 1; j <= 10; j++) {
orders.add(new Order(j));
}
EventDispatcher dispatcher = new EventDispatcher();
dispatcher.registerHandler(OrderReceivedEvent.class, new OrderReceivedEventHandler());
dispatcher.registerHandler(UserAssignedEvent.class, new UserAssignedEventHandler());
dispatcher.registerHandler(OrderPickedUpEvent.class, new OrderPickedUpEventHandler());
dispatcher.registerHandler(OrderDeliveredEvent.class, new OrderDeliveredEventHandler());
while(!orders.isEmpty()) {
DeliveryBoy deliveryBoy = new DeliveryBoy(deliveryBoys.poll());
Order currentOrder = orders.poll();
dispatcher.dispatch(new OrderReceivedEvent(currentOrder));
dispatcher.dispatch(new UserAssignedEvent(deliveryBoy, currentOrder));
dispatcher.dispatch(new OrderPickedUpEvent(currentOrder));
dispatcher.dispatch(new OrderDeliveredEvent(deliveryBoy, currentOrder));
}
}
}
Another to design this using an Event driven architecture. The difference from the Observer pattern is that EDA asynchronously delivers message/event to the Subscriber.
import java.util.Date;
public class Order {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Date getDate() {
return new Date();
}
public Order (int id) {
this.id = id;
}
}
Repethelsizer, SDET at ADP
I am Ethel , creative news writer with 5+ years of experience. Have great storytelling skills , wrote and delivered high quality ...
- BigPug February 02, 2018