Seni Bina Bersih & Corak Reka Bentuk dalam Amalan · Pelajaran

Seni Bina Bersih Dipacu Peristiwa

Sepadukan corak dipacu peristiwa ke dalam Seni Bina Bersih dengan menggunakan peristiwa domain untuk meningkatkan pengasingan dan kebolehskalaan.

Pelajaran 2 daripada 412 langkah

Seni Bina Bersih Dipacu Peristiwa ialah pelajaran Seni Bina Bersih & Corak Reka Bentuk dalam Amalan percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Seni Bina Bersih & Corak Reka Bentuk dalam Amalan, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Seni Bina Bersih & Corak Reka Bentuk dalam Amalan merangkumi sejumlah 4 pelajaran.

Pengenalan kepada Seni Bina Bersih Dipacu Peristiwa

Selamat datang ke Seni Bina Bersih Dipacu Peristiwa! Dalam sistem yang kompleks, bahagian-bahagian tertentu sering perlu bertindak balas terhadap perkara yang berlaku di tempat lain tanpa gandingan yang ketat.

Pelajaran ini meneroka cara mengintegrasikan corak dipacu peristiwa ke dalam Seni Bina Bersih anda, dengan menggunakan peristiwa domain untuk meningkatkan pengasingan dan kebolehskalaan, sambil mematuhi Peraturan Kebergantungan dengan ketat.

Apakah Peristiwa Domain?

Peristiwa Domain ialah sesuatu yang berlaku dalam domain dan penting kepada pakar domain. Ia merupakan fakta tidak berubah, iaitu rekod sesuatu kejadian, seperti 'Pesanan Dibuat' atau 'Pengguna Didaftarkan'.

Peristiwa ini mewakili perubahan dalam keadaan domain.
Peristiwa ini biasanya dinamakan dalam kala lampau, contohnya OrderPlaced.
Peristiwa ini sepatutnya berupa struktur data ringkas yang hanya mengandungi maklumat berkaitan tentang peristiwa tersebut.

Peristiwa dan Peraturan Kebergantungan

Dalam Seni Bina Bersih, Peraturan Kebergantungan menyatakan bahawa kebergantungan mestilah mengalir ke arah dalam. Peristiwa domain amat sesuai dengan peraturan ini:

Entiti boleh mencetuskan peristiwa tetapi tidak mengetahui siapa yang mengendalikannya.
Kes Penggunaan menyelaraskan entiti dan boleh menerbitkan peristiwa selepas sesuatu operasi.
Penyesuai Antara Muka, contohnya pembentang dan get laluan perkhidmatan luaran, boleh melanggan serta mengendalikan peristiwa daripada lapisan dalaman.

Ini mengekalkan pengasingan yang ketat kerana lapisan dalaman kekal tidak mengetahui butiran khusus lapisan luaran.

Melaksanakan Peristiwa Domain

Peristiwa domain pada asasnya ialah objek pemindahan data (DTO) yang membawa maklumat tentang perkara yang berlaku. Amalan yang baik ialah menyediakan antara muka umum untuk semua peristiwa domain.

Berikut ialah antara muka Java yang ringkas:

public interface DomainEvent {
  long occurredOn();
}

Kod: Peristiwa Domain Konkrit

Mari kita cipta peristiwa domain khusus: OrderPlacedEvent. Peristiwa ini menyimpan orderId dan cap masa ketika peristiwa itu berlaku.

Cuba jalankan takrif ringkas ini:

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());
  }
}

Penerbit Peristiwa

Untuk menerbitkan peristiwa, kita memerlukan Penerbit Peristiwa, yang juga dikenali sebagai Penghantar Peristiwa atau Bas Peristiwa. Komponen ini menerima peristiwa domain dan menghantarnya kepada semua pengendali yang berdaftar.

Komponen ini bertindak sebagai pengantara yang mengasingkan sumber peristiwa daripada penggunanya. Kes Penggunaan akan bergantung pada antara muka penerbit ini, bukannya pada pengendali tertentu.

Kod: Antara Muka Penerbit Peristiwa

Berikut ialah antara muka untuk EventPublisher kita. Kita juga memerlukan cara untuk pengendali mendaftarkan diri.

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

Kod: Penerbit Peristiwa Dalam Memori

Ini ialah pelaksanaan mudah dalam memori untuk tujuan demonstrasi. Dalam aplikasi sebenar, pelaksanaan ini mungkin menggunakan baris gilir mesej, contohnya Kafka atau RabbitMQ, untuk ketekalan dan pengedaran.

Jalankan ini untuk melihat penerbit asas berfungsi:

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);
  }
}

Mengintegrasikan Kes Penggunaan dan Pengendali

Kini, mari kita lihat bagaimana Kes Penggunaan menerbitkan peristiwa dan bagaimana Pengendali Peristiwa, yang berada contohnya dalam lapisan Penyesuai Antara Muka, bertindak balas terhadapnya. Kes Penggunaan kekal terpisah daripada pengendali.

Reka bentuk ini membolehkan pengendali baharu ditambahkan tanpa mengubah suai Kes Penggunaan.

Kod: Aliran Dipacu Peristiwa Lengkap

Contoh ini menunjukkan PlaceOrderUseCase menerbitkan OrderPlacedEvent, yang kemudiannya dikendalikan oleh OrderEmailNotifier.

Perhatikan bahawa PlaceOrderUseCase hanya bergantung pada EventPublisher, bukannya pada pemberitahu tertentu.

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");
  }
}

Semakan Pantas: Peristiwa Domain

Apabila mengintegrasikan peristiwa domain ke dalam Seni Bina Bersih, apakah manfaat utama Kes Penggunaan menerbitkan peristiwa berbanding memanggil perkhidmatan lain secara terus?

Jawab dalam pelajaran interaktif

Imbas Kembali: Seni Bina Bersih Dipacu Peristiwa

Dalam pelajaran ini, kami meneroka Seni Bina Bersih Dipacu Peristiwa. Anda telah mempelajari bahawa:

Peristiwa Domain ialah fakta tidak berubah yang mewakili kejadian penting.
Peristiwa ini membolehkan pengasingan, dengan membenarkan Kes Penggunaan menerbitkan peristiwa tanpa mengetahui pelanggannya.
Penerbit Peristiwa menjadi pengantara penghantaran peristiwa kepada Pengendali Peristiwa.
Corak ini menyokong kebolehskalaan dan kebolehkembangan, lalu memudahkan sistem berkembang sambil mematuhi Peraturan Kebergantungan.

Dengan memanfaatkan peristiwa domain, Seni Bina Bersih anda boleh menjadi lebih kukuh dan mudah disesuaikan.

Percuma untuk bermula

Pelajari Seni Bina Bersih & Corak Reka Bentuk dalam Amalan dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Seni Bina Bersih Dipacu Peristiwa” percuma?

Ya — teks penuh “Seni Bina Bersih Dipacu Peristiwa” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Seni Bina Bersih & Corak Reka Bentuk dalam Amalan, tingkat taraf kepada CoddyKit PRO. Kursus Seni Bina Bersih & Corak Reka Bentuk dalam Amalan merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Seni Bina Bersih Dipacu Peristiwa”?

Sepadukan corak dipacu peristiwa ke dalam Seni Bina Bersih dengan menggunakan peristiwa domain untuk meningkatkan pengasingan dan kebolehskalaan. Anda berlatih Seni Bina Bersih & Corak Reka Bentuk dalam Amalan menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Seni Bina Bersih & Corak Reka Bentuk dalam Amalan?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Seni Bina Bersih & Corak Reka Bentuk dalam Amalan di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Seni Bina Bersih Dipacu Peristiwa” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Seni Bina Bersih & Corak Reka Bentuk dalam Amalan ini?

Ya. Setiap pelajaran Seni Bina Bersih & Corak Reka Bentuk dalam Amalan menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Mengendalikan Kebimbangan Merentas Lapisan
Seni Bina Bersih Dipacu Peristiwa
Seni Bina Bersih dalam Perkhidmatan Mikro
CQRS dalam Seni Bina Bersih

← Kembali ke Seni Bina Bersih & Corak Reka Bentuk dalam Amalan