How is Decorator different from Adapter?

Both wrap another object, but Adapter changes an object's interface to match what a client expects, while Decorator keeps the same interface and adds new behavior — the wrapped object remains usable anywhere the original interface is expected.

Are Python decorators the same as the GoF Decorator pattern?

They're closely related in spirit — both wrap something to add behavior — but Python's `@decorator` syntax is a language feature for wrapping functions or classes, whereas the GoF pattern is specifically about wrapping objects that share a common interface at runtime.

Why not just use subclassing to add features?

Subclassing adds behavior statically to all instances of a class and can require a new subclass for every combination of features, whereas Decorator adds behavior per-instance at runtime and lets features be combined by composing wrappers instead of multiplying subclasses.

What's a real-world library built on Decorator?

Java's `java.io` stream classes are a canonical example — base streams are wrapped with decorators like `BufferedInputStream` or `GZIPInputStream` to layer on buffering or decompression without modifying the underlying stream class.

Does HTTP middleware use the Decorator pattern?

Yes, conceptually — frameworks like Express.js or ASGI/WSGI middleware wrap the request-handling pipeline in layers, each adding behavior (logging, auth, compression) before passing control to the next layer, mirroring Decorator's wrap-and-delegate structure.

Programming

Decorator Pattern

IntermediateTechnique6K learners

The Decorator pattern is a structural design pattern that attaches additional responsibilities to an object dynamically by wrapping it in one or more decorator objects that share the same interface as the original.

#DecoratorPattern #Programming#Technique#Intermediate#AdapterPattern #StrategyPattern #DesignPatterns #Middleware #SoftwareDevelopment#Glossary#SkillVeris

Definition

Overview

The Decorator pattern, catalogued by the Gang of Four, solves the problem of adding behavior to individual objects without altering the behavior of other instances of the same class and without resorting to a combinatorial explosion of subclasses for every possible combination of features. A decorator implements the same interface as the object it wraps, holds a reference to that wrapped object, and forwards calls to it while adding its own behavior before or after the delegation. Because decorators implement the same interface as the component they wrap, they can be layered — a decorator can wrap another decorator, which wraps another, forming a chain — and the resulting composite object is used interchangeably with an undecorated one anywhere the shared interface is expected. This is distinct from subclassing, which adds behavior statically at compile time to all instances of a class; Decorator adds behavior dynamically, at runtime, to specific object instances, and different instances of the same base class can be wrapped with entirely different combinations of decorators. A canonical textbook example is a text- or stream-processing pipeline: a base `InputStream` might be wrapped by a `BufferedInputStream` decorator, which is wrapped by a `GZIPInputStream` decorator, each adding one capability (buffering, decompression) without the base class needing to know about either. Decorator appears throughout real-world software: Java's I/O library (`java.io`) is a well-known example built almost entirely from layered decorators; Python's function decorators (the `@decorator` syntax) implement a closely related idea at the language level, wrapping functions with additional behavior; web middleware chains (Express.js middleware, ASP.NET middleware, WSGI/ASGI middleware in Python) apply the same wrapping principle to HTTP request handling, where each middleware layer can inspect, modify, or short-circuit the request/response before passing it to the next layer. The tradeoff is that long decorator chains can make debugging and reasoning about the final composed behavior harder, since behavior is spread across many small wrapping layers rather than one place.

Key Concepts

Wraps an object to add behavior dynamically without modifying its class
Decorator implements the same interface as the component it wraps
Decorators can be layered/chained, each adding one discrete responsibility
Avoids a combinatorial explosion of subclasses for every feature combination
Adds behavior per-instance at runtime, unlike subclassing which applies statically to all instances
Underlies stream/I/O libraries, HTTP middleware chains, and language-level function decorators
Composed objects remain interchangeable with undecorated ones via the shared interface
Long decorator chains can complicate debugging of the final composed behavior

Use Cases

Layering I/O stream capabilities (buffering, compression, encryption)

HTTP middleware pipelines that add logging, auth, or compression per request

Adding cross-cutting behavior (caching, retries, logging) around service calls

Python/JavaScript function decorators for memoization, timing, or access control

UI component libraries that let widgets be wrapped with borders, scrollbars, or shadows

Adding optional features to objects without bloating a base class with flags

Frequently Asked Questions

From the Blog

Programming

Python Decorators: A Practical Guide for Beginners

Decorators are one of Python's most powerful features — they let you wrap functions with reusable logic without modifying the original. This guide explains how they work from first principles, builds several practical decorators (timing, caching, authentication), and covers class-based decorators and decorator factories.