Existuje elegantní řešení pro manipulaci zpětná volání z externích zařízení v čisté architektuře?

Chtěl bych vytvořit pokroku rozhraní, v případě použití vrstvy, protože to hlásí průběh případu užití.

Pak bych realizovat pokrok presenteru a předat ji k užívání věci, když je nazývá správce.

Případ užití může pak projít postup do platebního terminálu přes adaptér je rozhraní.

+------------+     +-------------------+  <<create>>  +------------+
| View Model | <-- | ProgressPresenter | <----------  | Controller |
+------------+     +---------+---------+              +------------+
                             |                              |
UI                           |                              |
=============================|==============================|==========
Use Case                     V                              V
                       +----------+                    +----------+
                       | Progress |                    | Use Case |
                       +----------+                    +----------+
                             ^                              |
                             |                              V
                             |                     +-----------------+
                             |                     | PaymentTerminal |   
                             |                     +-----------------+
                             |                              | 
=============================|==============================|==========
External                     |                              V
                             |                  +------------------------+
                             +------------------| PaymentTerminalAdapter |
                                                +------------------------+

V klientovi aplikace ViewModel je obvykle připojen k součásti uživatelského ROZHRANÍ prostřednictvím pozorovatel vztah a způsobí UI aktualizovat, když ViewModel změny. Do webové aplikace můžete buď to udělat přes nějaký websocket nebo uložit pokrok v nějaký druh úložiště (relace nebo databáze) a nechat klienta anketa hodnotu.

Jsem znovu myslel, že moje předchozí odpověď. Tam je možná lepší řešení, protože Terminal vypadá to, že jen další I/O zařízení. Pokud toto řešení je vhodné pro vás, závisí na tom, jak terminal api je určen.

Protože nevím, jak api funguje, budu předpokládat, že něco. Možná, že to vyhovuje vašim požadavkům, nebo vám dává nové nápady.

Vytvořit koncový adaptér při spuštění terminálové relace a připojení k presenteru. Můžete volat případy použití a předat jim PaymentTerminal rozhraní.

+-----------+                    
| ViewModel |
+-----------+
      ^
      |
+-----------+     +-----------------+      +------------+
| Presenter | <-- | TerminalAdapter | <--- | Controller |
+-----------+     +-----------------+      +------------+
                           ^                     |
===========================|=====================|===============
                           |                     V
                     +----------+          +----------+
                     | Terminal | <------- | Use Case |
                     +----------+          +----------+

Některé pseudo controller kód:

public void startPaymentSession(){
    PaymentModel paymentModel = .. // get the model
    PaymentPresenter paymentPresenter = new PaymentTerminalPresenter(paymentModel);

    this.paymentTerminalAdapter = new PaymentTerminalAdapter();
    this.paymentTerminalAdapter.setCallbacks(paymentPresenter);

    UseCase uc = new UseCase(this.paymentTerminalAdapter);
    uc.execute();
}

V tomto případě jsme se připojit vnější vrstva' Terminal API pomocí adaptéru (Terminal API pokrok subjekty Moderátorka pokrok subjekty) de facto obcházet případ použití vrstvy. Zda to by mohlo způsobit nějaké architektonické porušení? Každopádně, osobně se toto řešení zdá být rozumné, aby mě.

Protože já nevím terminálu api používáte, mohu jen hádat...

Pro mě to vypadá jako terminál api je míchání pohled a aplikační logiky věci. Tam je nějaký druh registrace zpětného volání používá k informování uživatele a další metody, které zpracovávají aplikační logiky. Tak bych propojit termial api UI část v presenteru a předat část aplikační logiky (jako interface) pro případ použití. V tomto případě si myslím, že to není architektonický porušení, protože část terminálu adaptér je zařízení I/O.

To by mohlo být špatně, protože je to založené na mé předpoklady. Nicméně jsem vám chtěla ukázat další způsob, jak pro situace, kdy moje předpoklady jsou pravdivé.

Nakonec myslím, že to není opravdu jedno, pokud se podíváme na terminálu api jako externí služby nebo I/O zařízení. Pro mě jeden gól architektury je důležitější - testovatelnost případy použití, moderátor a tak dále.