Decorator Pattern in Java — Avoiding Stream Type Mismatch

package io.thecodeforge.java.patterns;

// Step 1: Define the component interface
interface TextProcessor {
    String process(String text);
}

// Step 2: Concrete component
class PlainTextProcessor implements TextProcessor {
    @Override
    public String process(String text) {
        return text;
    }
}

// Step 3: Abstract decorator — holds a reference to the wrapped component
abstract class TextProcessorDecorator implements TextProcessor {
    protected final TextProcessor wrapped;
    TextProcessorDecorator(TextProcessor wrapped) { this.wrapped = wrapped; }
}

// Step 4: Concrete decorators
class UpperCaseDecorator extends TextProcessorDecorator {
    UpperCaseDecorator(TextProcessor wrapped) { super(wrapped); }
    @Override public String process(String text) {
        return wrapped.process(text).toUpperCase(); // add before/after
    }
}

class TrimDecorator extends TextProcessorDecorator {
    TrimDecorator(TextProcessor wrapped) { super(wrapped); }
    @Override public String process(String text) {
        return wrapped.process(text.trim());  // modify input
    }
}

class PrefixDecorator extends TextProcessorDecorator {
    private final String prefix;
    PrefixDecorator(TextProcessor wrapped, String prefix) {
        super(wrapped);
        this.prefix = prefix;
    }
    @Override public String process(String text) {
        return prefix + wrapped.process(text);
    }
}

public class DecoratorDemo {
    public static void main(String[] args) {
        // Compose freely at runtime
        TextProcessor simple = new PlainTextProcessor();
        TextProcessor trimmed = new TrimDecorator(simple);
        TextProcessor upper   = new UpperCaseDecorator(trimmed);
        TextProcessor tagged  = new PrefixDecorator(upper, "[RESULT] ");

        System.out.println(tagged.process("  hello world  "));
        // [RESULT] HELLO WORLD
    }
}

package io.thecodeforge.java.patterns;

import java.io.*;
import java.util.zip.GZIPInputStream;

public class IODecorators {
    public static void main(String[] args) throws Exception {
        // Each wrapper adds behaviour without modifying the inner class:
        // FileReader: reads characters from a file
        // BufferedReader: adds buffering (reads in chunks, not char by char)
        // — both implement Reader

        try (BufferedReader reader = new BufferedReader(
                new FileReader("data.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }

        // Stack more decorators for more behaviour:
        // FileInputStream → GZIPInputStream → InputStreamReader → BufferedReader
        try (BufferedReader gzipReader = new BufferedReader(
                new InputStreamReader(
                    new GZIPInputStream(
                        new FileInputStream("data.gz"))))) {
            System.out.println(gzipReader.readLine());
        }
        // No class was modified — behaviour added by wrapping
    }
}

// Inheritance approach — explosion of subclasses
class BufferedFileReader extends FileReader { ... }
class BufferedGzipFileReader extends FileReader { ... }
class BufferedEncryptedFileReader extends FileReader { ... }
// ...8 classes total

// Decorator approach — 3 wrappers
BufferedReader reader = new BufferedReader(
    new EncryptionDecorator(
        new GzipDecompressor(
            new FileReader("file.gz.enc"))));

// WRONG: decorator doesn't delegate — chain broken
class BrokenDecorator extends TextProcessorDecorator {
    @Override
    public String process(String text) {
        // BUG: forgot to call wrapped.process()
        return text.toUpperCase();  // PlainTextProcessor's behaviour lost
    }
}

// CORRECT:
class CorrectDecorator extends TextProcessorDecorator {
    @Override
    public String process(String text) {
        return wrapped.process(text).toUpperCase();
    }
}

+--------------------------------+--------------------------------+
|         Advantages              |         Disadvantages         |
+--------------------------------+--------------------------------+
| 1. Runtime behaviour composi-  | 1. Many small objects         |
|    tion without modifying       |    (increased memory & GC)    |
|    existing code.               |                                |
+--------------------------------+--------------------------------+
| 2. Avoids subclass explosion    | 2. Complex chains can be      |
|    (2^N problem).               |    hard to debug              |
+--------------------------------+--------------------------------+
| 3. Follows Open/Closed Principle| 3. Order dependency can lead  |
|    - classes open for extension,|    to subtle bugs             |
|    closed for modification.     |                                |
+--------------------------------+--------------------------------+
| 4. Each decorator is loosely    | 4. Instantiation overhead     |
|    coupled and independently   |    per decorated object       |
|    testable.                    |                                |
+--------------------------------+--------------------------------+
| 5. Supports single responsibility|5. Extra indirection may affect|
|    - each decorator handles one |    readability for simple cases|
|    concern.                     |                                |
+--------------------------------+--------------------------------+

+----------------------+---------------------------+---------------------------+---------------------------+
| Aspect               | Decorator                 | Proxy                     | Adapter                   |
+----------------------+---------------------------+---------------------------+---------------------------+
| Intent               | Adds new behaviour        | Controls access           | Converts interface        |
+----------------------+---------------------------+---------------------------+---------------------------+
| Interface            | Same as wrapped           | Same as wrapped           | Different from wrapped    |
+----------------------+---------------------------+---------------------------+---------------------------+
| Example (TextProc.)  | UpperCaseDecorator wraps  | LazyInitProxy wraps       | XmlToTextAdapter wraps    |
|                      | PlainTextProcessor.       | PlainTextProcessor.       | XmlProcessor.             |
+----------------------+---------------------------+---------------------------+---------------------------+
| Behaviour Change     | Extends (adds features)   | May restrict or defer     | No behaviour change,      |
|                      |                           |                           | only interface translation|
+----------------------+---------------------------+---------------------------+---------------------------+
| JDK Example          | BufferedReader            | Collections.unmodifiable  | InputStreamReader         |
|                      |                           | List                      | (InputStream→Reader)     |
+----------------------+---------------------------+---------------------------+---------------------------+
| Transparency         | Caller may not know       | Caller may be blocked     | Caller expects the        |
|                      | decorators exist          | (exception thrown)        | adapted interface         |
+----------------------+---------------------------+---------------------------+---------------------------+

// Rough benchmark of decorator overhead (nanoseconds per operation)
// Measured on a typical JVM with C2 compilation
// Plain component: ~2 ns
// 1 decorator: ~5 ns
// 3 decorators: ~12 ns
// 5 decorators: ~20 ns
// These numbers include JIT warmup.
// In I/O-bound code, the disk/network latency (>1ms) far outweighs this overhead.

// Proxy example: Controls access, no new behaviour
class LazyProxy implements TextProcessor {
    private TextProcessor real;
    @Override
    public String process(String text) {
        if (real == null) real = new PlainTextProcessor();
        return real.process(text);
    }
}

// Adapter example: Converts interface
// InputStreamReader adapts InputStream to Reader – different interface

// Composite example: Not applicable here – composite deals with aggregation, not single wrapper

// Unit test for UpperCaseDecorator
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class UpperCaseDecoratorTest {
    @Test
    void shouldUppercaseOutput() {
        TextProcessor mock = text -> "hello";  // mock
        UpperCaseDecorator decorator = new UpperCaseDecorator(mock);
        assertEquals("HELLO", decorator.process(""));
    }
}

// Integration test: chain order matters
@Test
void trimThenUppercaseChain() {
    TextProcessor chain = new UpperCaseDecorator(
                             new TrimDecorator(
                                 new PlainTextProcessor()));
    assertEquals("HELLO", chain.process("  hello  "));
}

@Test
void uppcaseThenTrimChain() {
    TextProcessor chain = new TrimDecorator(
                             new UpperCaseDecorator(
                                 new PlainTextProcessor()));
    // Different result! UpperCaseDecorator sees spaces before trim
    assertEquals("  HELLO  ", chain.process("  hello  "));
}

// Exercise 1: Pizza Ordering
// Create a Pizza interface with getDescription() and getCost().
// Implement PlainPizza. Then create decorators: Cheese, Pepperoni, Mushroom.
// Ensure stacking works: new Mushroom(new Pepperoni(new Cheese(new PlainPizza()))).
// Expected: Description = "Plain Pizza, Cheese, Pepperoni, Mushroom", Cost = 8.50 (base 5 + 1.50 + 1.00 + 1.00).

// Exercise 2: Logging HTTP Calls
// Assume an HttpClient interface with send(Request) method.
// Implement a LoggingDecorator that logs request and response timestamps.
// The decorator should not modify the actual HTTP call behavior.

// Exercise 3: Caching Decorator
// Create a DataService interface with fetchData(String key).
// Implement a CachingDecorator that caches results in a HashMap.
// The decorator should delegate to the wrapped service on cache miss.

// Exercise 4: Encryption Decorator for File I/O
// Use the existing TextProcessor pattern. Create an EncryptionDecorator
// that Base64-encodes the text before delegating and decodes after.
// Test with round-trip: encrypt then decrypt should yield original.

// Exercise 5: Decorator with State
// Create a CountingDecorator that counts how many times process() is called.
// Expose a getCount() method on the decorator (not on the interface).
// This shows how decorators can add new methods, but clients must know
// the concrete decorator type to access them.