इवेंट-आधारित क्लीन आर्किटेक्चर

public interface DomainEvent {
  long occurredOn();
}

public class OrderPlacedEvent implements DomainEvent {
  private final String orderId;
  private final long occurredOn;

  public OrderPlacedEvent(String orderId) {
    this.orderId = orderId;
    this.occurredOn = System.currentTimeMillis();
  }

  public String getOrderId() {
    return orderId;
  }

  @Override
  public long occurredOn() {
    return occurredOn;
  }

  public static void main(String[] args) {
    OrderPlacedEvent event = new OrderPlacedEvent("ORD-123");
    System.out.println("Order event for: " + event.getOrderId());
  }
}

public interface EventPublisher {
  void publish(DomainEvent event);
  <T extends DomainEvent> void subscribe(Class<T> eventType, EventHandler<T> handler);
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public interface DomainEvent { long occurredOn(); }
public interface EventHandler<T extends DomainEvent> { void handle(T event); }

public class OrderPlacedEvent implements DomainEvent {
  private final String orderId; private final long occurredOn;
  public OrderPlacedEvent(String orderId) {
    this.orderId = orderId; this.occurredOn = System.currentTimeMillis();
  }
  public String getOrderId() { return orderId; }
  @Override public long occurredOn() { return occurredOn; }
}

public class SimpleEventPublisher implements EventPublisher {
  private final Map<Class<? extends DomainEvent>, List<EventHandler<?>>> subscribers = new HashMap<>();

  @Override
  public void publish(DomainEvent event) {
    List<EventHandler<?>> handlers = subscribers.get(event.getClass());
    if (handlers != null) {
      for (EventHandler handler : handlers) {
        // Unchecked cast is safe due to type checking during subscription
        ((EventHandler<DomainEvent>) handler).handle(event);
      }
    }
  }

  @Override
  public <T extends DomainEvent> void subscribe(Class<T> eventType, EventHandler<T> handler) {
    subscribers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(handler);
  }

  public static void main(String[] args) {
    SimpleEventPublisher publisher = new SimpleEventPublisher();
    publisher.subscribe(OrderPlacedEvent.class, event -> {
      System.out.println("Handler 1: Order " + event.getOrderId() + " placed!");
    });
    publisher.subscribe(OrderPlacedEvent.class, event -> {
      System.out.println("Handler 2: Notifying ops for order " + event.getOrderId());
    });

    OrderPlacedEvent event = new OrderPlacedEvent("DEMO-456");
    publisher.publish(event);
  }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

// Domain Layer Interfaces & Classes
interface DomainEvent { long occurredOn(); }
class OrderPlacedEvent implements DomainEvent {
  private final String orderId; private final long occurredOn;
  public OrderPlacedEvent(String orderId) {
    this.orderId = orderId; this.occurredOn = System.currentTimeMillis();
  }
  public String getOrderId() { return orderId; }
  @Override public long occurredOn() { return occurredOn; }
}

// Application Layer Interfaces & Classes
interface EventPublisher {
  void publish(DomainEvent event);
  <T extends DomainEvent> void subscribe(Class<T> eventType, EventHandler<T> handler);
}
interface EventHandler<T extends DomainEvent> { void handle(T event); }

// Use Case (Application Layer)
class PlaceOrderUseCase {
  private final EventPublisher eventPublisher;

  public PlaceOrderUseCase(EventPublisher eventPublisher) {
    this.eventPublisher = eventPublisher;
  }

  public void execute(String orderDetails) {
    // Simulate order creation logic
    String newOrderId = "ORD-" + System.nanoTime();
    System.out.println("Order " + newOrderId + " created with details: " + orderDetails);

    // Publish domain event
    eventPublisher.publish(new OrderPlacedEvent(newOrderId));
  }
}

// Infrastructure/Interface Adapters Layer Implementation
class SimpleEventPublisher implements EventPublisher {
  private final Map<Class<? extends DomainEvent>, List<EventHandler<?>>> subscribers = new HashMap<>();

  @Override
  public void publish(DomainEvent event) {
    List<EventHandler<?>> handlers = subscribers.get(event.getClass());
    if (handlers != null) {
      for (EventHandler handler : handlers) {
        ((EventHandler<DomainEvent>) handler).handle(event);
      }
    }
  }

  @Override
  public <T extends DomainEvent> void subscribe(Class<T> eventType, EventHandler<T> handler) {
    subscribers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(handler);
  }
}

class OrderEmailNotifier implements EventHandler<OrderPlacedEvent> {
  @Override
  public void handle(OrderPlacedEvent event) {
    System.out.println("Email Notifier: Sending email for order " + event.getOrderId());
  }
}

class InventoryUpdater implements EventHandler<OrderPlacedEvent> {
  @Override
  public void handle(OrderPlacedEvent event) {
    System.out.println("Inventory Updater: Updating inventory for order " + event.getOrderId());
  }
}

public class Main {
  public static void main(String[] args) {
    SimpleEventPublisher publisher = new SimpleEventPublisher();

    // Register handlers
    publisher.subscribe(OrderPlacedEvent.class, new OrderEmailNotifier());
    publisher.subscribe(OrderPlacedEvent.class, new InventoryUpdater());

    // Create use case with publisher dependency
    PlaceOrderUseCase placeOrderUseCase = new PlaceOrderUseCase(publisher);

    // Execute use case, which publishes the event
    placeOrderUseCase.execute("Laptop, Quantity: 1");
    placeOrderUseCase.execute("Keyboard, Quantity: 2");
  }
}