Tag: structural

Wrap a database table or view in a class where an instance is tied to a single row, and the class provides methods for CRUD operations directly on the object.

Convert the interface of a class into another interface clients expect. A structural design pattern for interface compatibility.

Use the Adapter pattern to normalize responses from external REST APIs into a consistent internal model without leaking third-party formats into your domain

Decouple an abstraction from its implementation so both can vary independently. A structural design pattern for platform independence.

Map a coarse-grained entity to multiple database tables by composing dependent objects, reducing the number of fine-grained remote calls in EJB and distributed systems.

Compose objects into tree structures to represent part-whole hierarchies. A structural design pattern for treating individual objects and compositions uniformly.

Abstract and encapsulate all access to a data source by exposing a clean interface while hiding persistence details from business logic.

Separate in-memory domain objects from the database by delegating persistence to a dedicated mapper layer, keeping models framework-agnostic.

Add new functionality to objects dynamically by wrapping them. A structural design pattern for flexible behavior extension.

Use the Decorator pattern to compose cross-cutting concerns like logging, metrics, and retries into HTTP request pipelines without modifying core logic

Load related data in a single query rather than multiple round-trips, preventing the N+1 problem and improving read performance.

Compose entities from pure data components and process them with systems, enabling high-performance and flexible game object architecture without deep inheritance.

Provide a simplified interface to a complex subsystem. A structural pattern that hides implementation details behind a clean API.

Share objects to support large numbers of fine-grained objects efficiently. A structural design pattern for memory optimization.

Route all incoming requests through a single handler that dispatches to the appropriate page command, centralizing request processing and security.

Ensure each object is loaded only once per transaction by caching instances by their primary key, preventing duplicate in-memory representations of the same database row.

Use empty interfaces as metadata tags to signal properties or capabilities at compile time and runtime, enabling type-safe checks without modifying class behavior.

Add reusable behavior to classes without inheritance by composing methods from shared objects into a target class.

Separate presentation logic from the view by introducing a presenter that intermediates between the model and a passive view, enabling testable UI code.

Bind UI components declaratively to a ViewModel that exposes data and commands, enabling automatic synchronization between view and state.

Encapsulate private state and behavior inside a self-contained unit with a public API. A structural pattern for organizing code into reusable, scope-safe modules.

Use a dedicated controller object for each logical page in a web application, handling the request and populating the view for that specific page.

Split a single class definition across multiple source files to separate auto-generated code from hand-written code, or to organize large classes by concern.

Provide a surrogate or placeholder for another object to control access to it. A structural design pattern for access control, lazy loading, and logging.

How to implement a caching proxy that intercepts API calls and stores responses to reduce latency and avoid redundant network requests

Centralize access to shared services and objects via a lookup table. A structural pattern that decouples consumers from concrete implementations.

Encapsulate business rules for selecting objects as reusable, composable predicate objects that can be combined with logical operators.

Provide an alternative to multiple inheritance by linking two separate classes through mutual references, allowing them to delegate methods to each other as needed.

Define game object types as runtime data rather than hard-coding them as classes, enabling designers to create new entity variants without recompiling the codebase.

Track changes to in-memory objects during a business transaction and commit all updates atomically to the database, ensuring consistency.

A guide to selecting and applying the right design pattern for common software engineering problems.