Aggregate

As explained in Spring in Action, Sixth Edition

An aggregate is a domain-driven design cluster of related objects treated as a unit for consistency and lifecycle management.

An aggregate groups related domain objects that must be handled together. One object acts as the aggregate root: other objects belong to its context and are managed through it. section 3.1.3

A Taco Cloud order illustrates the boundaries:

• TacoOrder is the aggregate root and holds the order context. section 3.1.3
• Taco belongs to a TacoOrder and cannot exist outside that context. section 3.1.3
• Ingredient objects form separate aggregates and are referenced through IngredientRef rather than included in the order aggregate. section 3.1.3

The aggregate boundary shapes persistence. The application exposes one OrderRepository for TacoOrder, then saves its Taco objects and their IngredientRef rows as part of the same operation. The repository uses generated keys for the order and tacos, while a transaction coordinates the save. section 3.1.4

Saving an order aggregate

Saving a TacoOrder inserts the order first, obtains its database-generated ID, saves each Taco with that order ID, obtains each taco ID, and inserts IngredientRef rows linking ingredients to tacos. section 3.1.4

Figure 3.1 The tables for the Taco Cloud schema

Use the schema diagram to inspect the aggregate boundary and the separate Ingredient relationship. section 3.1.3

How Spring in Action, Sixth Edition covers it

How deep it goes

Defines membership and demonstrates multi-table saving, but defers broader domain-driven design beyond aggregates and roots.

Examples

Uses TacoOrder, Taco, Ingredient, IngredientRef, SQL tables, and a JdbcOrderRepository save operation.

What it assumes

Assumes domain objects and database tables, while introducing domain-driven design aggregates and aggregate roots.

What you can do after

Build it from scratch by defining an aggregate root, repository, schema relationships, and coordinated JDBC persistence.

How it connects

Connects domain-driven design, aggregate roots, repositories, transactions, and relational database tables.

liveBookmanning.com

Read Spring in Action, Sixth Edition on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Collaborative Software Design: How to facilitate domain modeling decisionsA consistency boundary is a boundary within which related state must satisfy business invariants as a single consistent unit.
• 

  liveBookmanning.com
  Simple Object-Oriented Design: Create clean, maintainable applicationsAn aggregate is a cluster of related domain objects treated as a consistency boundary and accessed through a designated root.

Compare how 3 books explain aggregate →

Related concepts

• domain eventproduces · A domain event is a record of a significant occurrence or state change in a business domain that may be relevant to subsequent behavior or decisions.
• business invariantaddresses · A business invariant is a condition that must remain true for a domain model to represent a valid business state.
• eventproduced by · An event is an occurrence, change, or associated record or notification recognized as significant within a system or context.
• domain layerpart of · A domain layer is an architectural part of an application that contains its domain concepts, rules, and behavior.
• domain-driven designpart of · Domain-driven design is a software design approach that centers models, structure, and terminology on the concepts, behavior, and boundaries of a problem domain.

This explainer was generated by Manning's knowledge graph from the text of Spring in Action, Sixth Edition. The section links point to the parts of the book it draws on.