Comment seule responsabilité Principe concerne le modèle de domaine anémique / riche?

Question

Actuellement faire une revue de code de choses repris d'une autre équipe et ont un doute sur l'application SRP et sa relation avec le modèle de domaine anémique ou riche (tel que défini par Martin Fowler). riche concept de modèle de domaine est d'avoir l'objet intelligent qui peut non seulement définir / obtenir leurs propriétés mais peut aussi effectuer une logique métier plus complexe. Je Wond comment il s'intègre SRP?

Dire que j'ai ma classe de modèle ayant des propriétés qui peuvent exposer ces accessoires et de fournir des calculs simples sur ses properies. exigence suivante est d'avoir la possibilité de stocker ces données d'objet dans un objet de stockage qui ne sont pas sous mon contrôle, comme ceci:

class MyObject {
    // get set
    // parse sth

}

méthode Entreposer dans

   storage.store(key, object);

Ne pas violer SRP si MyObject a la méthode de stockage comme ceci

public void store(Storage storage) {
    storage.store('keyOne', fieldOne);
    storage.store('keyTwo', fieldTwo);
}

Du pov de cet objet, il est un bon pense pouvoir stocker son état. Autre moyen pourrait être d'introduire sorte de service ici et faire comme ça:

public StorageService {
    private Storage;
    // constructor here
    ....
    public void store(MyObject myobj);
}

moi peut vous indiquer des liens que je peux lire sur ce problème? Je l'ai trouvé un fil sur le SO ici, mais il ne répond pas à ma question complètement.

Comment est-il résolu en DDD? Les modèles en DDD sont, par définition, riches et peuvent être considérés comme ayant trop de responsabilités.

Answer 1

Un modèle riche de domaine ( RDM ) signifie que le comportement logique gouvernant est le modèle appartient au sein du modèle, par opposition au traitement du modèle comme les données avec les getters / setters. Cela ne pas mean tout, y compris la persistance, la sécurité, comment afficher le modèle dans l'interface graphique, etc. doit être dans le modèle.

GMD et SRP vont main dans la main, ils ne sont pas en conflit les uns avec les autres.

Violer SRP / GMD:

Car {
   // possibly violates SRP
   storeInDatabase();  
   // smells like anemic domain model
   getEngineState();   
}

Après SRP / GMD:

// usings aspects to remove cross-cutting concerns from the model and follow SRP
@DatabaseSerializable 
Car {
   // rich domain model encapsulates engine state and exposes behavior
   drive();            
}

Answer 2

« Les modèles en DDD sont, par définition, riches et peuvent être considérés comme ayant trop de responsabilités » est une interprétation simpliste de DDD. Toujours est-il dépend de la qualité sont vos modèles. Vous pouvez créer de mauvais modèles utilisant DDD (par exemple la création d'objets avec un trop grand nombre ou la création de modèles responsabilities anémiques). DDD et SRP sont deux bonnes pratiques trop suivre, autant que refactoring, TDD et beaucoup d'autres, mais vous devez compléter leur utilisation avec votre expérience et le jugement (ou quelqu'un d'autre). Tout a ses avantages et ses inconvénients, ne soyez pas dogmatique sur l'application de toute pratique.

Answer 3

@Garrett Hall

I somewhat disagree with your statement "RDM and SRP go hand-in-hand, they do not conflict with each other." In my experience, when SRP is overemphasized, it leads to an anemic domain model. "No, we can't do or even help support any persistance, no, we can't do 21-CFR11, no, we can't even know what a GUI is..." and your class ends up doing nothing and just have an Anemic Domain Model.

And if RDM is overemphasized (that's the direction/error I tend to fall into) then SRP completely falls by the wayside and you eventually notice that your class has 100s of methods and is clearly doing too much.

You need to find a balance, the happy medium where both RDM and SRP are happening. And finding that balance is hard and often involves more gut-feelings and politics within your team than technical savvy or rules.

"Know thyself". If you are like me, and tend towards overly complex classes, be aware. And when you see somebody else's class that looks too complex even to you, that a big red flag. Likewise, if you know that you are pretty hardcore about SRP, and you see a class that looks anemic even by your standards, that's a major code smell.

Now, somewhat answering the OP's question about Storage, I think a lot depends on how stable, standard, and abstract Storage is. If Storage were some standard XML, CSV, or RDB abstraction, I have absolutely no problem with objects knowing how to store themselves.