= Domain Driven Design (DDD) =
 * https://en.wikipedia.org/wiki/Domain-driven_design
 * https://martinfowler.com/bliki/DDD_Aggregate.html
 * https://techbeacon.com/app-dev-testing/get-your-feet-wet-domain-driven-design-3-guiding-principles.
{{{
the essence of DDD is profoundly simple: 
  capture the domain model in domain terms, 
  embed the model in the code, 
  and protect it from corruption. 
}}}
 * Understand the business, business logic independently of the tech used
 * Capture the domain model, in domain terms, through interactions with domain experts.
 * Embed the domain terminology in the code.
 * Protect the domain knowledge from corruption by other domains, technical subdomains, etc.

== EvansClassification ==
https://martinfowler.com/bliki/EvansClassification.html

=== Entity ===
Objects that have a distinct identity that runs through time and different representations. You also hear these called '''"reference objects"'''.
 * Note: not the same as entities in ORM's (exception @Entity in JPA)

=== Value Object ===
Objects that matter only as the combination of their attributes. Two value objects with the same values for all their attributes are considered equal. I also describe value objects in P of EAA.
 * Note: Only constructor and getters. Immutable ! 

One important rule to follow is that '''value objects should be immutable'''. To change a value (such as my height) you don't change the height object, you replace it with a new one.

One clear division between entities and values is that values override the equality method (and thus hash) while entities usually don't.

=== Service ===
A standalone operation within the context of your domain. A Service Object collects one or more services into an object. Typically you will have only one instance of each service object type within your execution context.
 * Note: business logic and business rules

'''Service objects''' are often implemented by using global variables, class fields (monostates in Robert Martin's terminology) or '''singletons'''.

== Springboot2 - hexagonal architecture ==
 * https://www.baeldung.com/hexagonal-architecture-ddd-spring
 * application divided into three layers: 
  * application (outside) 
  * domain (inside) 
  * infrastructure (outside):

== application layer ==
 * interaction with the application
 * has stuff like interfaces, RESTful controllers, and JSON serialization libraries
 * coordinates the execution of domain logic.

== domain layer ==
 * code that implements business logic
 * define the API to communicate with external parts, like the database

== infrastructure layer ==
 * app dependencies required to run the app 
 * database configuration and Spring configuration.

== DDD aggregates ==
 * https://www.baeldung.com/spring-persisting-ddd-aggregates
An aggregate is a '''group of business objects''' which always need to be consistent. Therefore, we save and update aggregates as a whole inside a transaction.

An aggregate root is a class which works as an entry point to our aggregate. 

All business operations should go through the root. 

== Java JPA and DDD ==
 * @Entity, is the same as the Entity in DDD and it '''has an identity'''
 * @Embeddable, is the same as a value object or value type, '''doesn't have an identity'''


== Repository ==
 * https://martinfowler.com/eaaCatalog/repository.html

A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. 

Conceptually, a Repository encapsulates the set of objects persisted in a data store and the operations performed over them, providing a more object-oriented view of the persistence layer.

 * https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/infrastructure-persistence-layer-design

Repositories are classes or components that encapsulate the logic required to access data sources.