Decorator Pattern

The Decorator pattern attaches additional responsibilities to an object dynamically.

Core Structure

┌──────────────────────────┐
│   Component (interface)  │
├──────────────────────────┤
│ + operation(): Result    │
└──────────┬───────────────┘
           │
     ┌─────┴─────────────┐
     │                   │
┌────┴──────┐    ┌───────┴───────┐
│  Concrete  │    │  Decorator    │
│  Component │    │  (abstract)   │
└───────────┘    ├───────────────┤
                 │ - wrapped:     │
                 │   Component   │
                 ├───────────────┤
                 │ + operation() │
                 └───────┬───────┘
                         │
                   ┌─────┴──────┐
                   │            │
              ┌────┴────┐ ┌────┴────┐
              │ConcreteA│ │ConcreteB│
              │Decorator│ │Decorator│
              └─────────┘ └─────────┘

Component Interface

public interface DataSource {
    void writeData(String data);
    String readData();
}

// Core implementation
public class FileDataSource implements DataSource {
    private String filename;
    
    public FileDataSource(String filename) {
        this.filename = filename;
    }
    
    @Override
    public void writeData(String data) {
        // Write to file
    }
    
    @Override
    public String readData() {
        // Read from file
    }
}

Base Decorator

public abstract class DataSourceDecorator implements DataSource {
    protected DataSource wrapped;
    
    public DataSourceDecorator(DataSource source) {
        this.wrapped = source;
    }
    
    @Override
    public void writeData(String data) {
        wrapped.writeData(data);
    }
    
    @Override
    public String readData() {
        return wrapped.readData();
    }
}

Why Decorator Over Inheritance

Concrete decorators add specific behavior to the wrapped component.

Compression Decorator

public class CompressionDecorator extends DataSourceDecorator {
    public CompressionDecorator(DataSource source) {
        super(source);
    }
    
    @Override
    public void writeData(String data) {
        String compressed = compress(data);
        wrapped.writeData(compressed);
    }
    
    @Override
    public String readData() {
        String data = wrapped.readData();
        return decompress(data);
    }
    
    private String compress(String data) {
        // Compression logic
        return Base64.getEncoder().encodeToString(data.getBytes());
    }
    
    private String decompress(String data) {
        // Decompression logic
        return new String(Base64.getDecoder().decode(data));
    }
}

Encryption Decorator

public class EncryptionDecorator extends DataSourceDecorator {
    private final SecretKey key;
    
    public EncryptionDecorator(DataSource source, SecretKey key) {
        super(source);
        this.key = key;
    }
    
    @Override
    public void writeData(String data) {
        String encrypted = encrypt(data);
        wrapped.writeData(encrypted);
    }
    
    @Override
    public String readData() {
        String data = wrapped.readData();
        return decrypt(data);
    }
    
    private String encrypt(String data) {
        // Encryption logic using key
        return Base64.getEncoder().encodeToString(data.getBytes());
    }
    
    private String decrypt(String data) {
        // Decryption logic using key
        return new String(Base64.getDecoder().decode(data));
    }
}

Buffering Decorator

public class BufferingDecorator extends DataSourceDecorator {
    private final List<String> buffer = new ArrayList<>();
    private final int bufferSize;
    
    public BufferingDecorator(DataSource source, int bufferSize) {
        super(source);
        this.bufferSize = bufferSize;
    }
    
    @Override
    public void writeData(String data) {
        buffer.add(data);
        if (buffer.size() >= bufferSize) {
            flush();
        }
    }
    
    @Override
    public String readData() {
        flush(); // Ensure buffer is written
        return wrapped.readData();
    }
    
    private void flush() {
        String combined = String.join("\n", buffer);
        wrapped.writeData(combined);
        buffer.clear();
    }
}

Logging Decorator

public class LoggingDecorator extends DataSourceDecorator {
    private final Logger logger;
    
    public LoggingDecorator(DataSource source, Logger logger) {
        super(source);
        this.logger = logger;
    }
    
    @Override
    public void writeData(String data) {
        logger.info("Writing data: {} bytes", data.length());
        wrapped.writeData(data);
        logger.info("Write complete");
    }
    
    @Override
    public String readData() {
        logger.info("Reading data");
        String data = wrapped.readData();
        logger.info("Read complete: {} bytes", data.length());
        return data;
    }
}

Decorators can be stacked to combine multiple behaviors.

Stacking Example

// File + Compression + Encryption + Logging
DataSource source = new LoggingDecorator(
    new EncryptionDecorator(
        new CompressionDecorator(
            new FileDataSource("data.txt")
        ),
        secretKey
    ),
    logger
);

// Read flow:
// LoggingDecorator.readData()
//   → EncryptionDecorator.readData()
//     → CompressionDecorator.readData()
//       → FileDataSource.readData()
//     ← decompress
//   ← decrypt
// ← log

source.writeData("Hello, World!");
// 1. Log: "Writing data: 13 bytes"
// 2. Encrypt: "SGVsbG8sIFdvcmxkIQ=="
// 3. Compress: "U0dWc2JHOD0="
// 4. Write to file

Java I/O as Decorators

// Java streams use the Decorator pattern
InputStream is = new FileInputStream("data.txt");           // Base
BufferedInputStream bis = new BufferedInputStream(is);       // Buffering
DataInputStream dis = new DataInputStream(bis);               // Data types
GZIPInputStream gzis = new GZIPInputStream(dis);             // Decompression

// Each wraps the previous, adding behavior

Dynamic Decorator Stacking

public class DataSourceBuilder {
    private DataSource source;
    
    public DataSourceBuilder(String filename) {
        this.source = new FileDataSource(filename);
    }
    
    public DataSourceBuilder withCompression() {
        source = new CompressionDecorator(source);
        return this;
    }
    
    public DataSourceBuilder withEncryption(SecretKey key) {
        source = new EncryptionDecorator(source, key);
        return this;
    }
    
    public DataSourceBuilder withLogging(Logger logger) {
        source = new LoggingDecorator(source, logger);
        return this;
    }
    
    public DataSourceBuilder withBuffering(int size) {
        source = new BufferingDecorator(source, size);
        return this;
    }
    
    public DataSource build() {
        return source;
    }
}

// Usage
DataSource source = new DataSourceBuilder("data.txt")
    .withCompression()
    .withEncryption(key)
    .withLogging(logger)
    .build();

Order of Decorators

┌─────────────────────────────────────────────────────┐
│  Order Matters!                                      │
├─────────────────────────────────────────────────────┤
│                                                      │
│  Logging → Encryption → Compression → File           │
│  (Outer)                        (Inner)              │
│                                                      │
│  vs                                                  │
│                                                      │
│  Compression → Encryption → Logging → File           │
│  (Outer)                        (Inner)              │
│                                                      │
│  Different order = different behavior!               │
│                                                      │
└─────────────────────────────────────────────────────┘

Common Stacking Patterns