Comment la transacalité est-elle mise en œuvre dans les applications DDD?
Je cherche et je regarde récemment à propos de DDD et, jusqu'à présent, je pense que j'ai compris ses fondements.
Si j'ai bien compris, l'architecture est similaire à celle-ci:
Database <--SQL--> DAO/ORM <--CRUD--> Repository/Aggreagtes <--Business--> **¿?** <-- Controller --> Internet/Client/UI
Mon doute tourne autour du ¿? Gap. Je le remplis habituellement avec des services.
Mes services sont souvent la première preuve d'un fichier Modèle de domaine anémique, car toute la logique commerciale est à ces services (et leurs implémentations sont assez procédurales). En conséquence, mon modèle de domaine est un simple ensemble de pojos.
Mon intention est de se déplacer progressivement mon projet actuel à un modèle de domaine plus riche et à une couche de service plus mince. Cependant, je suis préoccupé par la transaction et la couche.
Recherche sur la façon de remplir ce qui précède Gap, j'ai trouvé cela question
Suivre le lien et la réponse vérifiée, je suppose que:
Il y a toujours des services dans DDD. Ces services effectuent des opérations commerciales via des référentiels (et des racines globales).
Les services sont censés couvrir les besoins de l'entreprise qui ne peuvent pas être couverts par des racines et/ou des référentiels d'agrégation.
Les services exécutent des transactions commerciales via UnitOfwork (UOW) . Un UOW pourrait impliquer une gamme de racines et de référentiels plus agrégés.
Question: Est-ce le moyen de mettre en œuvre la couche d'entreprise et la transacalité dans le DDD? Service app -> UOW -> référentiel)
Si oui
[Question bonus]: Comment les événements de l'application et les gestionnaires correspondent à une telle architecture? Les services sont-ils traduits en manutentionnaires? (gestionnaire -> UOW -> référentiel)?
Je suis reconnaissant pour tout type d'entrée. Je me sens un peu confus avec la manière dont les couches DDD sont liées ou comment les attacher avec moins de couplage possibles.
Un UOW pourrait impliquer une gamme de racines et de référentiels plus agrégés.
Non, absolument pas. Qui manque le point entier. Nous changeons toujours un agrégat à la fois (une par transaction).
Les transactions sont généralement une coordination entre le composant d'application et le composant de persistance. L'application commence une transaction (UOW, si vous le souhaitez), lit l'agrégat cible, modifie l'agrégat, l'enregistre et s'engage.
Si ce commit réussit, il n'y a pas eu d'écrit en conflit à cet agrégat et le commandement lui-même a réussi. S'il y a des écrivies contradictoires, le commit échoue et le composant d'application permet de déterminer la stratégie de récupération (fusionner, remédier à la commande d'un nouveau point de départ, signalez l'échec de l'appelant, etc.).
Si je dois modifier 2 agrégats dans une transaction est probablement causé par une mauvaise conception de racines agrégées.
Cela, ou un échec de comprendre les exigences réelles de l'entreprise. C'est un modèle relativement courant pour supposer que deux changements doivent être étroitement couplés lorsque le véritable cas d'affaires a beaucoup plus de flexibilité. Exemple classique: supposer qu'un solde de compte ne doit jamais tomber en dessous de zéro, lorsque l'entreprise est heureuse d'accéder aux pénalités de découvert.
Tous les invariants ne peuvent pas être satisfaits simplement en le traitement des données au sein d'un agrégat. Je suggérerais parfois que vous auriez besoin d'une transaction au niveau du service pour les opérations de paquet, au moins dans le même contexte délimité.
Un exemple de ceci transférerait des fonds entre comptes. Si une transaction réussit, tandis que l'autre échoue, vous avez des problèmes. L'alternative serait de mettre en œuvre une manœuvre de flux de travail/un contrôle de l'état qui complique vraiment la logique à une telle degré que je dirais que vous avez vaincu le but d'un modèle de domaine riche.