Design Patterns

Named, reusable solutions to recurring object-oriented design problems, catalogued by the Gang of Four in 1994 into creational, structural and behavioural families. They give teams a shared vocabulary (“wrap it in a decorator”) and encode proven trade-offs. Apply them when you feel the pain they remove — not pre-emptively.

• Singleton — default bean scope
• Factory — BeanFactory, FactoryBean, @Bean methods
• Proxy — AOP for @Transactional, @Async, @Cacheable, security
• Template Method — JdbcTemplate, RestTemplate, TransactionTemplate
• Observer — ApplicationEventPublisher / @EventListener
• Strategy — PasswordEncoder, HandlerMethodArgumentResolver, injected List/Map of implementations
• Chain of Responsibility — security filter chain, interceptors
• Adapter — HandlerAdapter in Spring MVC
• Front Controller — DispatcherServlet

1. Enum singleton — simplest, thread-safe, resistant to reflection and serialization.
2. Initialization-on-demand holder — a static nested class holds the instance; the JVM’s class initialisation makes it lazy and thread-safe.
3. Double-checked locking with a volatile field.
4. Eager static final field — simple if laziness doesn’t matter.

public enum Config { INSTANCE; }

• Reflection — calling the private constructor: throw if an instance already exists.
• Serialization — deserialising creates a new object: implement readResolve() to return the instance.
• Cloning — don’t implement Cloneable (or throw from clone).
• Multiple class loaders — each loader gets its own instance.

The enum form is immune to the first three.

It’s global mutable state in disguise: hidden dependencies, tight coupling, hard to mock, and order-dependent tests. In DI frameworks, let the container manage a single instance (Spring’s singleton scope) and inject it through constructors instead.

Factory Method creates one product through a method that subclasses override (or a static factory that chooses an implementation). Abstract Factory is an object with several factory methods that create a family of related products guaranteed to work together (e.g. AWS storage + AWS queue). Adding a new family is easy; adding a new product type changes every factory.

For objects with many parameters, especially optional ones (telescoping constructors are unreadable), when you want immutability with readable construction, and to validate cross-field rules in one place (build()). JDK and Spring examples: StringBuilder, HttpRequest.newBuilder(), UriComponentsBuilder, RestClient.builder(). Lombok’s @Builder generates one.

Prototype creates objects by copying a configured instance. Cloneable/Object.clone() is broken by design: no clone() on the interface, a protected method returning Object, a checked exception, shallow copies, constructors bypassed, and conflicts with final fields. Prefer copy constructors or copy factory methods, and make deep copies of mutable fields.

java.io: new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(file)))) — each wrapper implements the same stream abstraction and adds buffering, character decoding or decompression. Also Collections.unmodifiableList and synchronizedMap.

Compose objects into trees where leaves and composites share one interface, so clients treat a single item and a group uniformly (size() of a file or a directory). Used for file systems, UI component trees (Swing’s Container), the DOM, ASTs and menus.

A class explosion when two independent dimensions vary — UrgentSmsNotification, RegularEmailNotification… (M × N classes). Bridge splits them into two hierarchies — abstraction (urgency) and implementation (channel) — joined by composition (M + N classes). JDBC (API vs drivers) and SLF4J (API vs logging backends) are bridges.

Sharing immutable intrinsic state across many fine-grained objects to save memory, with extrinsic state passed in. JDK examples: Integer.valueOf caching -128..127, the String pool, enum constants. It’s why Integer a = 127, b = 127; a == b is true but fails for 128 — always compare boxed values with equals.

Same structure (a context holding an interface), different intent. Strategy: the client chooses an interchangeable algorithm, usually fixed once configured, and strategies don’t know each other. State: the object’s behaviour changes with its internal state, and states trigger transitions to other states themselves.

Replace conditional with polymorphism: an interface per behaviour (Strategy) with one implementation per case, registered in a Map — in Spring, inject List<PaymentStrategy> and index it by a method() key. Adding a case becomes adding a class. Alternatively, for a closed set of types, a sealed interface + exhaustive switch keeps the logic in one place with compiler-checked completeness.

Template Method fixes an algorithm’s skeleton in a base class and lets subclasses override steps — inheritance, chosen at compile time. Strategy swaps the whole algorithm via composition at runtime. Spring’s JdbcTemplate is a hybrid: a template method that takes callbacks (tiny strategies) as lambdas.

A subject notifies registered observers of events without knowing who they are — a one-to-many dependency. Spring: ApplicationEventPublisher.publishEvent(event) and @EventListener / @TransactionalEventListener methods. Watch for listener failures, memory leaks from never-unregistered listeners, and synchronous execution in the publisher’s thread by default. java.util.Observable is deprecated.

It turns a request into an object holding the action and its parameters. That enables queuing, scheduling, logging, retrying and undo/redo (commands capture state to reverse themselves). Runnable/Callable submitted to an executor, job queues and CQRS commands are examples.

A request passes along a chain of handlers; each handles it, passes it on, or stops the chain. Servlet filters and the Spring Security filter chain, Spring MVC interceptors, Spring Cloud Gateway filters, logging handler hierarchies, and approval workflows.

Choosing behaviour based on the runtime types of two objects. Java dispatches only on the receiver, so Visitor uses two calls: element.accept(visitor) dispatches on the element’s type, then visitor.visitCircle(this) dispatches on the visitor’s type. In Java 21, sealed interfaces with pattern-matching switch give the same exhaustive, type-safe dispatch with far less code.

Command with inverse operations stores small commands that know how to reverse themselves — memory-efficient but you must write each inverse. Memento stores snapshots of state before each change — simple and generic but memory-hungry. Real editors combine them: commands, with mementos or diffs for complex steps, plus periodic snapshots.

Observer is one-way broadcast from a subject to subscribers that don’t coordinate. Mediator centralises two-way coordination among peers that would otherwise reference each other (a dialog coordinating widgets, a chat room). Event buses blur the two: publishers and listeners are decoupled through the mediator-like infrastructure.