Please enable JavaScript.

Coggle requires JavaScript to display documents.

Domain-Driven Design (Software :keyboard: (Goal (Enhance a specific domain…

- - - - Limited view of manufacturing
        
        Vision
        
        Specification
        
        Design
        
        Testing
        
        Production
      - Workers producing parts :nut_and_bolt:
      - Car manufacturing :factory:
    - - Approaches
        
        Agile
        
        Waterfall
    - - Design Patterns
      - Express Model first
  - - - Suitable because based on the same paradigm
      - Direct mappings between model objects
    - - Do not offer constructs to implement components of a model
      - The code is not explicit about objects
      - Specific domains, like mathematics
- - - - Common layers
        
        Application :male-office-worker:
        
        Coordinates the application activity
        
        Application tasks progress
        
        Examples :bookmark:
        
        Invokes relevant methods on domain objects
        
        UI asks to book a flight
        
        Domain :<3:
        
        Heart of the business software
        
        Infrastructure :wrench:
        
        Communication
        
        Persistence
        
        Support libraries
        
        Examples :bookmark:
        
        Application service persists the objects
        
        Application tier fetches domain objects
        
        UI :desktop_computer:
        
        Presenting information to the user
        
        Interpreting user commands
      - Domain objects are free of the responsibility of displaying themselves, storing themselves
      - Loose coupling to the layers
    - - Services :construction_worker:
        
        Definition
        
        Verbs of the language become part of the behavior of objects
        
        Nouns of the language are easily mapped to objects
        
        Some verbs do not seem to belong to any object
        
        Adding behavior to an object would make it stand for functionality which does not belong to it
        
        Does not have an internal state
        
        Examples :bookmark:
        
        Should transfering money from one account to another be in the sending account or the receiving account?
        
        Spring Service
        
        Services in Domain/Application/Infrastructure
        
        Domain Service to retrieve a report HTML template based on id
        
        Uses the file infrastructure Service to retrieve the template from the disk
        
        Design
        
        Interfaces which provide operations
        
        Point of connection for many objects
        
        Decoupling
        
        We should not create a Service for every operation needed
      - Entities :key:
        
        Examples :bookmark:
        
        Bank account
        
        Social Security number
        
        JPA Entity
        
        Id is not a memory location
        
        JPA Id
        
        Design
        
        Start modeling with entities
        
        Id remains the same throughout the states of the software
        
        Id remains the same no matter what representation entity takes
        
        Definition
        
        Object is distinguished by its identity, rather than its attributes
      - Value Objects :one:
        
        Examples :bookmark:
        
        Point in drawing application
        
        The only thing that matters is its coordinates
        
        Lombok Value
        
        Definition
        
        Does not have identity
        
        We are not interested which object, but what attributes
        
        Describe certain aspects of a domain
        
        Design
        
        Garbage collector takes care of the object
        
        Immutable
        
        Simplifies the design a lot
        
        Cheap creation
        
        Effective Java, Item 17: Minimize mutability
    - - Aggregates :fire_engine:
        
        Design
        
        Software mechanism to enforce the invariants
        
        Definition
        
        Associated objects which are considered as one unit with regard to data changes
        
        Has one Entity root
        
        The only object accessible from outside
        
        Examples :bookmark:
        
        JPA OneToOne
        
        JPA OneToMany
        
        JPA ManyToMany
        
        A car and its engine
        
        Spring Data JDBC
      - Factories :factory:
        
        Design
        
        Contradiction with what often happens in the domain
        
        Creating the object involves a lot of knowledge about the internal structure / the relationships
        
        Breaks encapsulation of Aggregate / domain objects
        
        Use it to create Aggregates
        
        Definition
        
        Encapsulates the process of complex object creation
        
        Encapsulates the knowledge necessary for object creation
        
        Examples :bookmark:
        
        Electronics get created in on assembly lines / the printer build itself :explode:
      - Repositories
        
        Examples :bookmark:
        
        Spring Data Repository
        
        Spring Repository
  - - - SImplicity
      - Small amount of logic
      - Little overhead in performance or in understanding
    - - Hardly any behavior on "domain" objects
      - Bags of getters and setters
      - Set of service objects which capture all the domain logic
- - - - Idea versus reality
      - Generalization
      - Hiding
        
        Should not care about eye color
        
        Banking software keeps track of accounts
    - - Writing :spiral_note_pad:
      - Graphical :chart_with_upwards_trend:
      - Language :tongue:
        
        Problem :no_entry:
        
        Technical team discuss in terms of design :desktop_computer:
        
        Domain experts use jargon :fountain_pen:
        
        Solution :bulb:
        
        Use a language based on the model
        
        Use the language consistently in all communications and in code
        
        Ubiquitous Language :yin_yang:
        
        Refactor the code, renaming classes, methods, and modules
        
        A change in the language becomes a change to the model
        
        Create classes for the corresponding model concepts
        
        Discover key domain concepts which should be used in the model