OOAD & Architecture gives JavaOmnibus a design lens, not just a version lens.

Create related objects without hard-coding their concrete classes.

Assemble complex objects step by step with readable construction logic.

Let subclasses decide which concrete product to create.

Create new objects by copying an existing configured instance.

Ensure only one instance exists for a shared service or coordinator.

Translate one interface into another that the client expects.

Separate abstraction from implementation so both can vary independently.

Treat individual objects and groups uniformly in tree-like structures.

Add behavior to an object dynamically without changing its core type.

Provide a simpler entry point to a complicated subsystem.

Share intrinsic state so many similar objects use less memory.

Stand in for another object to control access or add indirection.

Pass a request through handlers until one processes it.

Encapsulate an action as an object.

Represent and evaluate a small language or expression grammar.

Traverse a collection without exposing its internal structure.

Centralize complex interactions between collaborators.

Capture and restore object state without exposing internals.

Notify dependents automatically when state changes.

Change behavior by switching state objects instead of conditionals.

Swap algorithms behind a stable interface.

Define the workflow skeleton and let subclasses fill in specific steps.

Add operations across a structure without changing element classes.

Run reusable request processing steps before the core handler.

Route all web requests through one central entry point.

Keep presentation-specific formatting and lookup logic near the view layer.

Assemble a page from reusable view fragments.

Use a controller to gather model data, then forward to a rendering view.

Centralize control flow, invoke business services, then forward to a view.

Choose commands and views based on application-level navigation rules.

Hide remote service or business-tier lookup details from clients.

Centralize service lookup and caching in one place.

Expose coarse-grained business operations to reduce chatty calls.

Encapsulate persistence logic behind a focused data-access interface.

Move grouped data across layers in one serializable package.

Build richer transfer objects from multiple domain sources.

Manage large result lists with paging and efficient navigation.

Bundle request-scoped data so collaborators can share execution context cleanly.

Represent a coarse-grained entity composed of dependent persistent parts.

Shield the application from external web-service protocol details.