事件溯源

範例：追蹤船隻（C#）

以下是事件溯源的一個非常簡單的範例，用於傳達基本概念。對於這個範例，我故意極度簡化以作為一個起點 - 然後我將使用進一步的範例來探討一些更複雜的問題。

網域模型是一個簡單的模型，其中船隻載運貨物並在港口之間移動。

有四種類型的事件會影響模型

• 抵達：船隻抵達港口
• 離港：船隻離開港口
• 裝載：貨物裝載到船隻上
• 卸貨：貨物從船隻上卸下

我們來舉一個移動船隻的簡單範例。

class Tester...

  Ship kr;
  Port sfo, la, yyv;
  Cargo refact;
  EventProcessor eProc;

  [SetUp]
  public void SetUp() {
    eProc = new EventProcessor(); 
    refact = new Cargo ("Refactoring");
    kr = new Ship("King Roy");
    sfo = new Port("San Francisco", Country.US);
    la = new Port("Los Angeles", Country.US);
    yyv = new Port("Vancouver", Country.CANADA) ;
  }

[Test]
public void ArrivalSetsShipsLocation() {
  ArrivalEvent ev = new ArrivalEvent(new DateTime(2005,11,1), sfo, kr);
  eProc.Process(ev);
  Assert.AreEqual(sfo, kr.Port);
}
[Test]
public void DeparturePutsShipOutToSea() {
  eProc.Process(new ArrivalEvent(new DateTime(2005,10,1), la, kr));
  eProc.Process(new ArrivalEvent(new DateTime(2005,11,1), sfo, kr));
  eProc.Process(new DepartureEvent(new DateTime(2005,11,1), sfo, kr));
  Assert.AreEqual(Port.AT_SEA, kr.Port);    
}

為了讓這些測試運作，我們只需要抵達和離港事件。事件處理器非常簡單。

class EventProcessor...

  IList log = new ArrayList();  
  public void Process(DomainEvent e) {
    e.Process();
    log.Add(e);
  }

每個事件都有處理方法。

class DomainEvent...

  DateTime _recorded, _occurred;
  internal DomainEvent (DateTime occurred) {
    this._occurred = occurred;
    this._recorded = DateTime.Now;
  }
  abstract internal void Process();

抵達事件僅擷取資料，並有一個處理方法，該方法僅將事件轉發至適當的網域物件。

class DepartureEvent...

  Port _port;
  Ship _ship;
  internal Port Port  {get { return _port; }}
  internal Ship Ship  {get { return _ship; }}
  internal DepartureEvent(DateTime time, Port port, Ship ship) : base (time)  {
    this._port = port;
    this._ship = ship;
  }
  internal override void Process() {
    Ship.HandleDeparture(this);
  }

所以這裡的事件只執行處理選擇邏輯。處理網域邏輯是由船隻執行的。

類別 Ship...

  public Port Port;
  public void HandleDeparture(DepartureEvent ev) {
    Port = Port.AT_SEA;
  }

離港事件只會將 Ship 的港口設定為 特殊情況。您會注意到我將事件傳遞到網域物件中。這裡有一個選擇，關於事件是否應只傳遞網域物件處理所需的資料，或傳遞事件本身。透過傳遞事件，事件不需要確切知道網域邏輯所需的資料。如果事件稍後取得其他資料，就不需要更新簽章。傳遞事件的缺點是網域邏輯現在會知道事件本身。

那個簡單的測試只顯示基本事件處理如何運作。現在我將展示一點網域邏輯，看看它如何運作。我們的船隻運輸書籍，以滿足我擁有整條航運路線來運送我的書籍到世界各地的幻想。我確定您知道，透過加拿大運送書籍非常危險，因為這樣會冒著書籍被大量「eh」污染的風險。我見過幾乎每個句子都有「eh」的書籍（較長的句子可能會有兩個或三個）。

因此，我完美的書籍運送系統應該能夠偵測貨物是否已通過加拿大。

class Tester...

  [Test]
  public void VisitingCanadaMarksCargo() {
    eProc.Process(new LoadEvent(new DateTime(2005,11,1), refact, kr));
    eProc.Process(new ArrivalEvent(new DateTime(2005,11,2), yyv, kr));
    eProc.Process(new DepartureEvent(new DateTime(2005,11,3), yyv, kr ));
    eProc.Process(new ArrivalEvent(new DateTime(2005,11,4), sfo, kr));
    eProc.Process(new UnloadEvent(new DateTime(2005,11,5), refact, kr));
    Assert.IsTrue(refact.HasBeenInCanada);
  }

由於貨物可能在船隻之間移動並卸貨，因此貨物有責任知道它是否已暴露於這些北方的危險之中。幸運的是，只有在實際停靠港口時才會發生風險，只在水域中是安全的。因此，我們的抵達事件必須追蹤這一點。

類別 ArrivalEvent...

  Port _port;
  Ship _ship; 
  internal ArrivalEvent (DateTime occurred, Port port, Ship ship) : base (occurred) {
    this._port = port;
    this._ship = ship;
  } 
  internal Port Port {get {return _port;}}
  internal Ship Ship {get{return _ship;}}
  
  internal override void Process() {
    Ship.HandleArrival(this);
  }

處理常式再次是 Ship 物件。

類別 Ship...

  IList cargo;
  public void HandleArrival (ArrivalEvent ev) {
    Port = ev.Port;
    foreach (Cargo c in cargo) c.HandleArrival(ev);
  }

船隻不負責追蹤加拿大行程，因此它會將抵達通知傳遞到貨物。

類別 Cargo...

  public bool HasBeenInCanada = false;
  public void HandleArrival(ArrivalEvent ev) {
    if (Country.CANADA == ev.Port.Country) 
      HasBeenInCanada = true;
  }

考慮事件處理方法持有網域邏輯的替代方案 - 隨著網域邏輯變得更複雜，它需要對網域模型有大量的知識。在此方法中，網域物件會將事件傳遞到相關物件，以便它們可以處理它，以執行它們需要執行的回應。

範例：更新外部系統 (C#)

事件來源 的一大特點是您可以盡可能地重新處理事件。但是，如果處理事件會導致與外部系統互動，那麼這是一件壞事。最好的情況是他們會厭倦您所有的垃圾郵件事件。

協助處理此問題的簡單方法是確保您的系統透過閘道器呼叫外部系統，這些閘道器可以設定為確保在您「實際」處理事件之前不會發出任何訊息。

我將使用船隻和港口（這次沒有貨物）的簡單範例來說明這一點。讓我們假設每當船隻進入港口時，都必須通知當地海關當局。我們可以在事件處理網域邏輯中做到這一點。

class Port...

  public void HandleArrival (ArrivalEvent ev) {
    ev.Ship.Port = this;
    Registry.CustomsNotificationGateway.Notify(ev.Occurred, ev.Ship, ev.Port);
  }

請注意，這段程式碼只會在閘道物件上呼叫通知，它不關心這是否為真正的處理或某種重播。此處的一般原則是，網域邏輯不應關心事件執行的背景。

閘道負責找出是否實際傳送訊息。由於這個案例相當簡單，它只需透過連結到事件處理器並檢查處理器是否處於活動狀態即可做到這一點。

class CustomsEventGateway...

  EventProcessor processor;
  public void Notify (DateTime arrivalDate, Ship ship, Port port) {
    if (processor.isActive) 
      SendToCustoms(BuildArrivalMessage(arrivalDate, ship, port));
  }

事件處理器在執行常規處理時會讓自己保持活動狀態。

class EventProcessor...

  public void Process(DomainEvent e) {
    isActive = true;
    e.Process();
    isActive = false;
    log.Add(e);
  }

雖然這個案例非常簡單，但基本原則是一樣的。閘道決定是否傳送外部訊息，而不是網域邏輯。閘道根據他們收集的關於處理背景的資訊來決定這一點。在這個案例中，處理器的簡單布林狀態就足夠了。

範例：還原事件 (C#)

在這裡，我們將採用運輸範例，並了解如何還原事件。我們需要還原的關鍵是確保我們可以準確計算由於事件而變更狀態的任何物件的先前狀態。

儲存此先前資料的理想位置是在事件本身，這與範例中傳遞事件到網域物件的方法相當契合。由於網域物件可以處理事件，因此它們可以輕鬆地將資訊儲存在事件中。

載入事件是一個簡單的範例。事件載有下列來源資料。

class LoadEvent...

  int _shipCode;
  string _cargoCode;
  internal LoadEvent(DateTime occurred, string cargo, int ship) : base(occurred){
    this._shipCode = ship;
    this._cargoCode = cargo;
  }
  internal Ship Ship {get { return Ship.Find(_shipCode); }}
  internal Cargo Cargo {get { return Cargo.Find(_cargoCode); }}

處理會交給貨物物件，它需要儲存作為貨物先前位置的港口。

class LoadEvent...

  internal override void Process() {
    Cargo.HandleLoad(this);
  }

internal Port priorPort;

類別 Cargo...

  internal void HandleLoad(LoadEvent ev) {
    ev.priorPort = _port;
    _port = null;
    _ship = ev.Ship;
    _ship.HandleLoad(ev);
  }

若要反轉事件，我們會新增一個反轉方法，用來反映處理方法，在網域物件上呼叫反轉方法。

class LoadEvent...

  internal override void Reverse() {
    Cargo.ReverseLoad(this);
  }

類別 Cargo...

  public void ReverseLoad(LoadEvent ev) {
    _ship.ReverseLoad(ev);
    _ship = null;
    _port = ev.priorPort;
  }

在此情況下，事件會採用許多可變動的先前資料，這些資料是其處理資料的一部分。在類似情況下，簡單欄位就已足夠。其他情況可能需要更精密的資料結構。當貨物處理到達事件時，會追蹤它是否在加拿大。它可以使用簡單的布林值欄位來執行此動作。若要在事件上儲存先前值，需要的就不只是簡單欄位，因為許多貨物可能會受到到達事件影響。因此，在此情況下，我會使用由貨物索引的地圖。

類別 Cargo...

  public void HandleArrival(ArrivalEvent ev) {
    ev.priorCargoInCanada[this] = _hasBeenInCanada;
    if ("CA" == ev.Port.Country) 
      _hasBeenInCanada = true;
  }
  private bool _hasBeenInCanada = false;
  public bool HasBeenInCanada {get { return _hasBeenInCanada;}}

類別 ArrivalEvent...

  internal Port priorPort;
  internal IDictionary priorCargoInCanada = new Hashtable();

接著反轉

類別 Cargo...

  public void ReverseArrival(ArrivalEvent ev) {
    _hasBeenInCanada = (bool) ev.priorCargoInCanada[this];
  }

這個範例清楚說明事件上的來源資料和錯誤處理如何影響我們執行反轉的方式。對於載入事件，我們需要儲存貨物載入時的港口。如果事件在其來源資料中包含此資訊，我們就不需要執行此動作。一些額外的來源資料可以消除新增先前資料的需要。這並非適用於所有情況：到達事件無法找出其貨物的先前加拿大狀態。

被視為正確處理的內容也可能造成差異。在此系統中，我們同時有船隻的到達事件和離港事件。假設所有運作都正確，我們應該始終交錯取得這些事件。因此，船隻可以透過將其港口欄位設定為 Port.OUT_TO_SEA 來反轉到達事件。如果我們連續收到兩個到達事件，會發生什麼事？若要反轉此動作，我們需要在船隻上儲存先前港口。我們的替代方案是將沒有離港的第二次到達宣告為錯誤，我們不需要執行此儲存動作。

範例：外部查詢（C#）

即使對於基本的 事件溯源，外部查詢也很尷尬，因為如果你想要重建應用程式狀態，你需要使用過去所做的外部查詢回應來執行此動作。

讓我們想像一個情況，其中一艘船隻必須在進入港口時決定其貨物的價值。此估值是由外部服務完成。如果一艘船隻在 11 月 3 日進入港口，而我立即處理事件，我將取得該貨物在 11 月 3 日的價值。如果我在 12 月 5 日重建我的應用程式狀態，我將需要貨物的相同價值，即使其價值在此期間已變更。

對於此範例，我將展示一種處理此問題的方法，方法是保留外部查詢的記錄，並在重新處理事件時使用這些記錄來提供值。在許多方面，這與你用於外部更新的方法類似，將互動轉換為系統邊界的事件，並使用事件記錄來記住發生了什麼事。

使用與我在這些範例中其他地方使用的事件處理類似樣式，我們將事件傳遞給網域物件來處理。在此情況下，貨物會發起對外部系統的呼叫並儲存值。（我們假設我們將對此值執行某些有用的操作，但這與此範例無關。）

類別 Cargo...

  public void HandleArrival(ArrivalEvent ev) {
    declaredValue = Registry.PricingGateway.GetPrice(this);
  }
  private Money declaredValue;

依我的習慣，我會透過我控制的 閘道 封裝所有外部系統存取。基本閘道只會將呼叫轉換成外部互動所需的任何內容。為了支援重播事件，我只要用一個會記錄這些查詢的類別將其包覆起來即可。

圖 6：用記錄閘道包覆閘道，以支援從事件正確重建。

記錄閘道會檢查每個呼叫，以查看是否有與其相符的舊要求，如果沒有，它會提出新的要求。

class LoggedPricingGateway...

  public Money GetPrice(Cargo cargo) {
    GetPriceRequest oldReq = oldRequest(cargo);
    if (null != oldReq) return (Money) oldReq.Result; 
    else return newRequest(cargo);
  }

如果要求是新的，它會將要求轉換成事件物件，呼叫外部查詢，並將其儲存在記錄中。

class LoggedPricingGateway...

  private Money newRequest(Cargo cargo) {
    GetPriceRequest request = new GetPriceRequest(cargo);
    request.Result = gateway.GetPrice(cargo);
    log.Store(request);
    return (Money) request.Result;
  }

private class GetPriceRequest : QueryEvent {
  private Cargo cargo;
  public GetPriceRequest(Cargo cargo) : base() {
    this.cargo = cargo;
  }

class QueryEvent...

  DomainEvent _eventBeingProcessed;
  Object result;
  public QueryEvent() {
    _eventBeingProcessed = Registry.EventProcessor.CurrentEvent;
  }
  public object Result {
    get { return result; }
    set { result = value; }
  }
  public DomainEvent EventBeingProcessed {
    get { return _eventBeingProcessed; }
  }
}

因此，若要尋找舊要求，它會搜尋其記錄。

class LoggedPricingGateway...

  private GetPriceRequest oldRequest(Cargo cargo) {
    IList candidates =
      log.FindBy(EventProcessor.CurrentEvent, typeof (GetPriceRequest));
    foreach (GetPriceRequest request in candidates) {
      if (request.Cargo.RegistrationCode == cargo.RegistrationCode)
        return request;
    }
    return null;
  }

查詢記錄是通用的，因此我們可以使用已處理的 網域事件 和要求類型，發出查詢以取得一些項目。這會提供給我們一個小型的集合，需要以閘道特定方式進一步檢查。

要求記錄需要以與 網域事件 記錄相同的方式持續存在，因為需要它來重建應用程式狀態。