Java Design Pattern: Decorator Pattern

1. Pattern definition

Decorator modebelongStructural design pattern, allowed to passDynamic packaging objectThe way to objectAdd new features, provides a more flexible way to expand than inheritance. This pattern is inherited by combining alternatives, followingOpening and closing principle(Open for extensions, closed for modifications).

2. Core roles

1. Component (Component Interface)

   • Define the public interface for the decorated object

2. ConcreteComponent (specific component)

   • Specific categories that implement basic functions

3. Decorator (Decorator base class)

   • Hold Component references and implement Component interface

4. ConcreteDecorator (specific decorator)

   • Add specific decorative functions to implement

3. Classic implementation (coffee shop order system)

// 1. Component interface
 public interface Coffee {
     String getDescription();
     double cost();
 }

 // 2. Specific components
 public class SimpleCoffee implements Coffee {
     @Override
     public String getDescription() {
         return "Simple Coffee";
     }

     @Override
     public double cost() {
         return 1.0;
     }
 }

 // 3. Decorators base category
 public abstract class CoffeeDecorator implements Coffee {
     protected final Coffee decoratedCoffee;

     public CoffeeDecorator(Coffee coffee) {
          = coffee;
     }

     @Override
     public String getDescription() {
         return ();
     }

     @Override
     public double cost() {
         return ();
     }
 }

 // 4. Specific decorators
 public class MilkDecorator extends CoffeeDecorator {
     public MilkDecorator(Coffee coffee) {
         super(coffee);
     }

     @Override
     public String getDescription() {
         return () + ", Milk";
     }

     @Override
     public double cost() {
         return () + 0.5;
     }
 }

 public class MochaDecorator extends CoffeeDecorator {
     public MochaDecorator(Coffee coffee) {
         super(coffee);
     }

     @Override
     public String getDescription() {
         return () + ", Mocha";
     }

     @Override
     public double cost() {
         return () + 0.7;
     }
 }

 // 5. Client usage
 public class CoffeeShop {
     public static void main(String[] args) {
         Coffee order = new SimpleCoffee();
         (() + " $" + ());

         order = new MilkDecorator(order);
         (() + " $" + ());

         order = new MochaDecorator(order);
         (() + " $" + ());
     }
 }

IV. Pattern structure UML

           _________________________
          |        Component        |
          |-------------------------|
          | + getDescription()      |
          | + cost()                |
          |_________________________|
                     ▲
          ___________|___________
         |                       |
 _________▼_________       ______▼_______
| ConcreteComponent |     |   Decorator  |
|-------------------|     |--------------|
| + getDescription()|     | - component  |
| + cost()          |     |______________|
|___________________|              ▲
                           _________|_________
                          |                   |
                   _______▼_______     _______▼_______
                  | ConcreteDecoratorA |   | ConcreteDecoratorB |
                  |--------------------|   |--------------------|
                  | + addedBehavior()  |   | + addedBehavior()  |
                  |____________________|   |____________________|

V. Analysis of model advantages and disadvantages

Advantages:

• Dynamic expansion function, more flexible than inheritance
• Comply with the principle of opening and closing, no need to modify existing code
• Supports multi-layer nesting decoration
• Different decorations can be combined freely

Disadvantages:

• Multi-layer decoration increases code complexity
• Decoration order affects the final result
• May generate a large number of minor categories
• Difficulty in debugging (need to check the decoration layer by layer)

6. Application scenarios

1. Dynamically extend object functions
   (For example, add borders and scroll bars to graphical interface components)
2. Undo function implementation
   (Record operation history through decoration)
3. Data flow processing
   (Buffering and encryption processing in Java I/O)
4. Permission control
   (Add permission verification layer by decoration)
5. Logging
   (Add log decorating to business logic)

7. Java standard library application

Typical Java I/O stream implementation:

// Multi-layer decorative example
 InputStream in = new FileInputStream("");
 in = new BufferedInputStream(in); // Add buffering function
 in = new GZIPInputStream(in); // Add decompression function
 in = new Base64InputStream(in); // Add Base64 decoding

 // Custom Decorator Example
 class UppercaseInputStream extends FilterInputStream {
     public UppercaseInputStream(InputStream in) {
         super(in);
     }

     @Override
     public int read() throws IOException {
         int c = ();
         return (c == -1) ? c : (c);
     }
 }

8. Advanced application skills

Transparency control
Maintain decorative transparency through interface inheritance:

interface Window {
     void draw();
 }

 class BasicWindow implements Window { /*...*/ }

 abstract class WindowDecorator implements Window {
     protected Window window;
     // No additional methods are exposed
 }

Decoration sequence control
Manage the decor sequence using builder mode:

public class CoffeeBuilder {
    private Coffee coffee = new SimpleCoffee();
    
    public CoffeeBuilder addMilk() {
        coffee = new MilkDecorator(coffee);
        return this;
    }
    
    public Coffee build() {
        return coffee;
    }
}

Dynamically remove decorations
Implement decorative stack management:

public class UndoableCoffee implements Coffee {
     private Deque<Coffee> stack = new ArrayDeque<>();
    
     public UndoableCoffee(Coffee coffee) {
         (coffee);
     }
    
     public void addDecorator(CoffeeDecorator decorator) {
         (decorator);
     }
    
     public void undo() {
         if (() > 1) {
             ();
         }
     }
    
     // Implement the Coffee interface method...
 }

9. Best Practice Suggestions

1. Keep component interfaces simple
   Avoid decorators need to implement too many irrelevant methods
2. Control the depth of the decoration level
   It is recommended to decorate no more than 4 layers
3. Priority to use transparent decoration
   Keep the front and rear interfaces consistent
4. Pay attention to thread safety issues
   For variable state decorators, use synchronous control
5. Use it with caution in performance-sensitive scenarios
   Multi-layer decoration may affect performance (recommendation of object pools)