[Design Patterns] 08. 데코레이터와 컴포지트: 재귀적 아름다움

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 재귀의 수학적 아름다움 예시: 피보나치 수열
int fibonacci(int n) {
    if (n <= 1) return n;                    // 기저 조건
    return fibonacci(n-1) + fibonacci(n-2);  // 재귀적 정의
}

// 팩토리얼: 또 다른 재귀의 예
int factorial(int n) {
    if (n <= 1) return 1;                    // 기저 조건
    return n * factorial(n-1);               // 재귀적 정의
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 현실에서 마주치는 문제 상황
public class TextProcessor {
    public String processText(String text) {
        // 문제: 텍스트 처리 기능을 동적으로 조합하고 싶음
        
        // 요구사항들:
        // 1. 대문자 변환
        // 2. HTML 태그 제거
        // 3. 공백 정규화
        // 4. 암호화
        // 5. 압축
        // 6. 로깅
        
        // 하지만 모든 조합이 항상 필요한 것은 아님
        // 어떤 때는 1+3+6만, 어떤 때는 2+4+5만 필요
        // 상속으로는 불가능한 조합의 폭발...
        
        String result = text;
        if (needsUpperCase) result = result.toUpperCase();
        if (needsHtmlStrip) result = stripHtml(result);
        if (needsNormalization) result = normalizeWhitespace(result);
        if (needsEncryption) result = encrypt(result);
        if (needsCompression) result = compress(result);
        if (needsLogging) log(result);
        
        return result;
        // 문제: 조합이 복잡해질수록 if문이 폭발적으로 증가
        // 새로운 기능 추가 시마다 기존 코드 수정 필요
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105

// 텍스트 처리의 기본 인터페이스
interface TextProcessor {
    String process(String text);
}

// 기본 구현체 (ConcreteComponent)
class PlainTextProcessor implements TextProcessor {
    @Override
    public String process(String text) {
        return text; // 아무 처리도 하지 않음
    }
}

// Decorator의 기본 클래스
abstract class TextProcessorDecorator implements TextProcessor {
    protected final TextProcessor wrapped;
    
    protected TextProcessorDecorator(TextProcessor processor) {
        this.wrapped = processor;
    }
    
    @Override
    public String process(String text) {
        return wrapped.process(text); // 기본 동작은 위임
    }
}

// 구체적인 Decorator들
class UpperCaseDecorator extends TextProcessorDecorator {
    public UpperCaseDecorator(TextProcessor processor) {
        super(processor);
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text); // 먼저 이전 처리 수행
        return result.toUpperCase();           // 추가 기능 적용
    }
}

class HtmlStripDecorator extends TextProcessorDecorator {
    public HtmlStripDecorator(TextProcessor processor) {
        super(processor);
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text);
        return result.replaceAll("<[^>]*>", ""); // HTML 태그 제거
    }
}

class WhitespaceNormalizeDecorator extends TextProcessorDecorator {
    public WhitespaceNormalizeDecorator(TextProcessor processor) {
        super(processor);
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text);
        return result.replaceAll("\\s+", " ").trim(); // 공백 정규화
    }
}

class EncryptionDecorator extends TextProcessorDecorator {
    private final String key;
    
    public EncryptionDecorator(TextProcessor processor, String key) {
        super(processor);
        this.key = key;
    }
    
    @Override
    public String process(String text) {
        String result = wrapped.process(text);
        return encrypt(result, key); // 암호화 적용
    }
    
    private String encrypt(String text, String key) {
        // 간단한 암호화 (실제로는 더 복잡한 알고리즘 사용)
        return Base64.getEncoder().encodeToString(text.getBytes());
    }
}

class LoggingDecorator extends TextProcessorDecorator {
    private final String loggerName;
    
    public LoggingDecorator(TextProcessor processor, String loggerName) {
        super(processor);
        this.loggerName = loggerName;
    }
    
    @Override
    public String process(String text) {
        long startTime = System.currentTimeMillis();
        System.out.println("[" + loggerName + "] Processing started: " + text.substring(0, Math.min(50, text.length())));
        
        String result = wrapped.process(text);
        
        long endTime = System.currentTimeMillis();
        System.out.println("[" + loggerName + "] Processing completed in " + (endTime - startTime) + "ms");
        
        return result;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

public class DecoratorExample {
    public static void main(String[] args) {
        // 기본 텍스트
        String htmlText = "<html><body><h1>Hello World!</h1>  <p>This is   a   test.</p></body></html>";
        
        // 1. 단순한 처리
        TextProcessor simple = new PlainTextProcessor();
        System.out.println("Simple: " + simple.process(htmlText));
        
        // 2. HTML 태그 제거 + 공백 정규화
        TextProcessor htmlStrip = new WhitespaceNormalizeDecorator(
            new HtmlStripDecorator(
                new PlainTextProcessor()
            )
        );
        System.out.println("HTML Strip + Normalize: " + htmlStrip.process(htmlText));
        
        // 3. 완전한 체인: HTML 제거 → 공백 정규화 → 대문자 변환 → 암호화 → 로깅
        TextProcessor fullChain = new LoggingDecorator(
            new EncryptionDecorator(
                new UpperCaseDecorator(
                    new WhitespaceNormalizeDecorator(
                        new HtmlStripDecorator(
                            new PlainTextProcessor()
                        )
                    )
                ), "secret-key"
            ), "FullProcessor"
        );
        System.out.println("Full Chain: " + fullChain.process(htmlText));
        
        // 4. 다른 순서의 체인: 대문자 변환 → HTML 제거 → 공백 정규화
        TextProcessor differentOrder = new WhitespaceNormalizeDecorator(
            new HtmlStripDecorator(
                new UpperCaseDecorator(
                    new PlainTextProcessor()
                )
            )
        );
        System.out.println("Different Order: " + differentOrder.process(htmlText));
    }
}

/*
출력 결과:
Simple: <html><body><h1>Hello World!</h1>  <p>This is   a   test.</p></body></html>

HTML Strip + Normalize: Hello World! This is a test.

[FullProcessor] Processing started: <html><body><h1>Hello World!</h1>  <p>This is
[FullProcessor] Processing completed in 2ms
Full Chain: SEVMTE8gV09STEQhIFRISVMgSVMgQSBURVNULg==

Different Order: HELLO WORLD! THIS IS A TEST.
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

// 함수형 스타일의 Decorator 구현
@FunctionalInterface
interface TextTransformer extends Function<String, String> {
    
    // 체이닝을 위한 헬퍼 메서드
    default TextTransformer then(TextTransformer after) {
        return text -> after.apply(this.apply(text));
    }
    
    // 조건부 적용
    default TextTransformer when(Predicate<String> condition) {
        return text -> condition.test(text) ? this.apply(text) : text;
    }
}

// 함수형 변환기들
public class TextTransformers {
    
    public static final TextTransformer TO_UPPER = String::toUpperCase;
    public static final TextTransformer TO_LOWER = String::toLowerCase;
    public static final TextTransformer STRIP_HTML = text -> text.replaceAll("<[^>]*>", "");
    public static final TextTransformer NORMALIZE_WHITESPACE = text -> text.replaceAll("\\s+", " ").trim();
    public static final TextTransformer REVERSE = text -> new StringBuilder(text).reverse().toString();
    
    public static TextTransformer encrypt(String key) {
        return text -> Base64.getEncoder().encodeToString(text.getBytes());
    }
    
    public static TextTransformer addPrefix(String prefix) {
        return text -> prefix + text;
    }
    
    public static TextTransformer addSuffix(String suffix) {
        return text -> text + suffix;
    }
    
    public static TextTransformer log(String loggerName) {
        return text -> {
            System.out.println("[" + loggerName + "] Processing: " + text);
            return text;
        };
    }
}

// 함수형 스타일 사용법
public class FunctionalDecoratorExample {
    public static void main(String[] args) {
        String htmlText = "<html><body><h1>Hello World!</h1></body></html>";
        
        // 1. 체이닝을 통한 조합
        TextTransformer pipeline1 = TextTransformers.STRIP_HTML
            .then(TextTransformers.NORMALIZE_WHITESPACE)
            .then(TextTransformers.TO_UPPER)
            .then(TextTransformers.addPrefix(">>> "))
            .then(TextTransformers.addSuffix(" <<<"));
        
        System.out.println("Pipeline 1: " + pipeline1.apply(htmlText));
        
        // 2. 조건부 적용
        TextTransformer conditionalPipeline = TextTransformers.STRIP_HTML
            .then(TextTransformers.TO_UPPER.when(text -> text.length() < 50))
            .then(TextTransformers.REVERSE.when(text -> text.contains("HELLO")));
        
        System.out.println("Conditional: " + conditionalPipeline.apply(htmlText));
        
        // 3. Stream과의 조합
        List<String> texts = Arrays.asList(
            "<p>First text</p>",
            "<div>Second text</div>",
            "<span>Third text</span>"
        );
        
        TextTransformer batchProcessor = TextTransformers.STRIP_HTML
            .then(TextTransformers.TO_UPPER)
            .then(TextTransformers.addPrefix("Processed: "));
        
        List<String> processed = texts.stream()
            .map(batchProcessor)
            .collect(Collectors.toList());
        
        processed.forEach(System.out::println);
    }
}

/*
출력:
Pipeline 1: >>> HELLO WORLD! <<<
Conditional: !DLROW OLLEH
Processed: FIRST TEXT
Processed: SECOND TEXT
Processed: THIRD TEXT
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// Java I/O는 Decorator 패턴의 교과서적 예시
public class JavaIODecoratorExample {
    
    public void demonstrateIODecorators() throws IOException {
        // 1. 기본 파일 읽기
        try (InputStream basicInput = new FileInputStream("data.txt")) {
            // 기본 기능만 사용
        }
        
        // 2. 버퍼링 추가 (성능 향상)
        try (InputStream bufferedInput = new BufferedInputStream(
                new FileInputStream("data.txt")
        )) {
            // 버퍼링으로 성능 개선
        }
        
        // 3. 압축 해제 추가
        try (InputStream compressedInput = new GZIPInputStream(
                new FileInputStream("data.gz")
        )) {
            // GZIP 압축 파일 읽기
        }
        
        // 4. 완전한 체인: 파일 → GZIP 해제 → 버퍼링 → 데이터 스트림
        try (DataInputStream dataInput = new DataInputStream(
                new BufferedInputStream(
                    new GZIPInputStream(
                        new FileInputStream("data.gz")
                    )
                )
        )) {
            // 압축된 파일에서 구조화된 데이터 읽기
            int value = dataInput.readInt();
            String text = dataInput.readUTF();
        }
        
        // 5. 네트워크 + 암호화 + 버퍼링
        try (InputStream networkInput = new BufferedInputStream(
                new CipherInputStream(
                    new URL("https://example.com/data").openStream(),
                    createDecryptCipher()
                )
        )) {
            // 네트워크에서 암호화된 데이터를 버퍼링하며 읽기
        }
    }
    
    // 사용자 정의 Decorator 추가
    public static class LoggingInputStream extends FilterInputStream {
        private final String name;
        private int bytesRead = 0;
        
        public LoggingInputStream(InputStream in, String name) {
            super(in);
            this.name = name;
        }
        
        @Override
        public int read() throws IOException {
            int result = super.read();
            if (result != -1) {
                bytesRead++;
                if (bytesRead % 1024 == 0) {
                    System.out.println("[" + name + "] Read " + bytesRead + " bytes");
                }
            }
            return result;
        }
    }
    
    // 체인에 로깅 추가
    public void useCustomDecorator() throws IOException {
        try (InputStream loggingInput = new LoggingInputStream(
                new BufferedInputStream(
                    new GZIPInputStream(
                        new FileInputStream("large-data.gz")
                    )
                ), "DataReader"
        )) {
            byte[] buffer = new byte[1024];
            while (loggingInput.read(buffer) != -1) {
                // 데이터 처리
            }
        }
    }
    
    private Cipher createDecryptCipher() {
        // 암호화 설정 구현
        return null;
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

// 수학 표현식 계산기 - Composite의 완벽한 예시
abstract class Expression {
    public abstract double evaluate();
    public abstract String toString();
    
    // Composite 전용 메서드들 (기본 구현)
    public void add(Expression expression) {
        throw new UnsupportedOperationException("Leaf node cannot add children");
    }
    
    public void remove(Expression expression) {
        throw new UnsupportedOperationException("Leaf node cannot remove children");
    }
    
    public List<Expression> getChildren() {
        throw new UnsupportedOperationException("Leaf node has no children");
    }
}

// Leaf - 숫자
class Number extends Expression {
    private final double value;
    
    public Number(double value) {
        this.value = value;
    }
    
    @Override
    public double evaluate() {
        return value;
    }
    
    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

// Composite - 연산자
abstract class BinaryOperation extends Expression {
    protected Expression left;
    protected Expression right;
    protected final String operator;
    
    public BinaryOperation(Expression left, Expression right, String operator) {
        this.left = left;
        this.right = right;
        this.operator = operator;
    }
    
    @Override
    public String toString() {
        return "(" + left.toString() + " " + operator + " " + right.toString() + ")";
    }
    
    @Override
    public List<Expression> getChildren() {
        return Arrays.asList(left, right);
    }
}

class Addition extends BinaryOperation {
    public Addition(Expression left, Expression right) {
        super(left, right, "+");
    }
    
    @Override
    public double evaluate() {
        return left.evaluate() + right.evaluate();
    }
}

class Multiplication extends BinaryOperation {
    public Multiplication(Expression left, Expression right) {
        super(left, right, "*");
    }
    
    @Override
    public double evaluate() {
        return left.evaluate() * right.evaluate();
    }
}

class Division extends BinaryOperation {
    public Division(Expression left, Expression right) {
        super(left, right, "/");
    }
    
    @Override
    public double evaluate() {
        double rightValue = right.evaluate();
        if (rightValue == 0) {
            throw new ArithmeticException("Division by zero");
        }
        return left.evaluate() / rightValue;
    }
}

// 사용 예시: (3 + 4) * (2 / 1)
public class ExpressionExample {
    public static void main(String[] args) {
        // 복잡한 수식 구성
        Expression expr = new Multiplication(
            new Addition(new Number(3), new Number(4)),     // (3 + 4)
            new Division(new Number(2), new Number(1))      // (2 / 1)
        );
        
        System.out.println("Expression: " + expr);           // (3.0 + 4.0) * (2.0 / 1.0)
        System.out.println("Result: " + expr.evaluate());    // 14.0
        
        // 더 복잡한 중첩 구조
        Expression complex = new Addition(
            new Multiplication(
                new Number(2),
                new Addition(new Number(3), new Number(4))
            ),
            new Division(
                new Number(10),
                new Number(2)
            )
        );
        
        System.out.println("Complex: " + complex);          // (2.0 * (3.0 + 4.0)) + (10.0 / 2.0)
        System.out.println("Result: " + complex.evaluate()); // 19.0
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

// GUI 컴포넌트 시스템
abstract class UIComponent {
    protected String name;
    protected int x, y, width, height;
    protected boolean visible = true;

    public UIComponent(String name, int x, int y, int width, int height) {
        this.name = name;
        this.x = x; this.y = y; this.width = width; this.height = height;
    }

    // 모든 컴포넌트가 구현해야 하는 기본 메서드들
    public abstract void render(Graphics g);
    public abstract void handleEvent(Event event);
    public abstract Rectangle getBounds();

    // Composite 전용 메서드 - 투명한 Composite이므로 Leaf는 런타임에 거부한다
    public void add(UIComponent component) {
        throw new UnsupportedOperationException("Cannot add children to leaf component");
    }

    public void remove(UIComponent component) {
        throw new UnsupportedOperationException("Cannot remove children from leaf component");
    }

    public List<UIComponent> getChildren() {
        return Collections.emptyList();
    }

    public void setVisible(boolean visible) { this.visible = visible; }
    public boolean isVisible() { return visible; }
    public String getName() { return name; }
}

// Leaf: 자식을 가질 수 없는 최종 노드의 대표 예시
class Button extends UIComponent {
    private String text;
    private Runnable clickHandler;

    public Button(String name, int x, int y, String text) {
        super(name, x, y, 100, 30);
        this.text = text;
    }

    @Override
    public void render(Graphics g) {
        if (!visible) return;
        g.drawRect(x, y, width, height);
        g.drawString(text, x + 10, y + 20);
    }

    @Override
    public void handleEvent(Event event) {
        if (!visible) return;
        boolean inBounds = event.getX() >= x && event.getX() <= x + width
                && event.getY() >= y && event.getY() <= y + height;
        if (event.getType() == EventType.CLICK && inBounds && clickHandler != null) {
            clickHandler.run();
        }
    }

    @Override
    public Rectangle getBounds() { return new Rectangle(x, y, width, height); }

    public void setClickHandler(Runnable handler) { this.clickHandler = handler; }
}
// Label은 Button과 동일한 구조에서 render()가 텍스트만 그리고 handleEvent()는 비워둔 형태다 — 지면상 생략.

// Composite: 자식을 담고 렌더링·이벤트 처리를 재귀적으로 위임하는 대표 예시
class Panel extends UIComponent {
    private final List<UIComponent> children = new ArrayList<>();
    private Color backgroundColor;

    public Panel(String name, int x, int y, int width, int height) {
        super(name, x, y, width, height);
    }

    @Override
    public void add(UIComponent component) { children.add(component); }

    @Override
    public void remove(UIComponent component) { children.remove(component); }

    @Override
    public List<UIComponent> getChildren() { return new ArrayList<>(children); }

    @Override
    public void render(Graphics g) {
        if (!visible) return;
        if (backgroundColor != null) {
            g.setColor(backgroundColor);
            g.fillRect(x, y, width, height);
        }
        g.drawRect(x, y, width, height);
        for (UIComponent child : children) {
            child.render(g); // 재귀 호출 - child가 다시 Panel이어도 동일하게 동작한다
        }
    }

    @Override
    public void handleEvent(Event event) {
        if (!visible) return;
        for (UIComponent child : children) {
            child.handleEvent(event); // 이벤트도 동일한 방식으로 재귀 전파된다
        }
    }

    @Override
    public Rectangle getBounds() { return new Rectangle(x, y, width, height); }

    public void setBackgroundColor(Color color) { this.backgroundColor = color; }
}
// Window는 Panel과 동일한 add/remove/render 골격에 타이틀 바 렌더링과 minimize() 상태만 추가된다 — 지면상 생략.
// 중요한 점은 Window 역시 UIComponent이므로 다른 Window나 Panel의 자식이 될 수 있다는 것이다(재귀 구조의 핵심).

// 복잡한 GUI 구조 생성 예시
public class GUIExample {
    public static void main(String[] args) {
        Window mainWindow = new Window("mainWindow", 100, 100, 400, 300, "My Application");

        Panel topPanel = new Panel("topPanel", 10, 35, 380, 50);
        topPanel.add(new Button("saveBtn", 10, 10, "Save"));
        topPanel.add(new Button("loadBtn", 120, 10, "Load"));

        Panel centerPanel = new Panel("centerPanel", 10, 95, 380, 150);
        centerPanel.add(new Label("titleLabel", 10, 10, "Document Title:"));

        mainWindow.add(topPanel);
        mainWindow.add(centerPanel);

        Graphics mockGraphics = new MockGraphics();
        mainWindow.render(mockGraphics);                                   // 트리 전체를 재귀적으로 렌더링
        mainWindow.handleEvent(new Event(EventType.CLICK, 120, 110));      // 이벤트도 트리 전체에 재귀적으로 전파
    }
}

// 재귀적 구조 순회 유틸리티 - countComponents/maxDepth 모두 "자신 + 자식들의 결과를 합산"하는 동일한 재귀 골격을 따른다.
// findByName, printTree 같은 다른 순회도 이 골격에서 종료 조건과 결합 방식만 바꾸면 된다.
public class CompositeUtils {
    public static int countComponents(UIComponent root) {
        return 1 + root.getChildren().stream()
                .mapToInt(CompositeUtils::countComponents)
                .sum();
    }

    public static int maxDepth(UIComponent root) {
        if (root.getChildren().isEmpty()) {
            return 1;
        }
        return 1 + root.getChildren().stream()
                .mapToInt(CompositeUtils::maxDepth)
                .max()
                .orElse(0);
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109

// 순수 함수형 Decorator 구현
@FunctionalInterface
public interface Processor<T> extends Function<T, T> {
    
    // 함수 합성 (g ∘ f)(x) = g(f(x))
    default Processor<T> compose(Processor<T> before) {
        return input -> this.apply(before.apply(input));
    }
    
    // 체이닝 (f ∘ g)(x) = f(g(x))
    default Processor<T> andThen(Processor<T> after) {
        return input -> after.apply(this.apply(input));
    }
    
    // 조건부 적용
    default Processor<T> when(Predicate<T> condition) {
        return input -> condition.test(input) ? this.apply(input) : input;
    }
    
    // 로깅 기능 추가
    default Processor<T> withLogging(String description) {
        return input -> {
            System.out.println("Before " + description + ": " + input);
            T result = this.apply(input);
            System.out.println("After " + description + ": " + result);
            return result;
        };
    }
}

// 함수형 프로세서들의 라이브러리
public class Processors {
    
    // 기본 변환들
    public static final Processor<String> TRIM = String::trim;
    public static final Processor<String> TO_UPPER = String::toUpperCase;
    public static final Processor<String> TO_LOWER = String::toLowerCase;
    public static final Processor<String> REVERSE = s -> new StringBuilder(s).reverse().toString();
    
    // 파라미터화된 변환들
    public static Processor<String> replace(String target, String replacement) {
        return s -> s.replace(target, replacement);
    }
    
    public static Processor<String> addPrefix(String prefix) {
        return s -> prefix + s;
    }
    
    public static Processor<String> addSuffix(String suffix) {
        return s -> s + suffix;
    }
    
    public static Processor<String> truncate(int maxLength) {
        return s -> s.length() > maxLength ? s.substring(0, maxLength) + "..." : s;
    }
    
    // 고차 함수를 이용한 조합
    public static <T> Processor<T> repeat(Processor<T> processor, int times) {
        return input -> {
            T result = input;
            for (int i = 0; i < times; i++) {
                result = processor.apply(result);
            }
            return result;
        };
    }
    
    // 병렬 처리
    public static <T> Processor<List<T>> parallel(Processor<T> processor) {
        return list -> list.parallelStream()
                .map(processor)
                .collect(Collectors.toList());
    }
}

// 아름다운 함수 합성 예시
public class FunctionalCompositionExample {
    public static void main(String[] args) {
        // 복잡한 텍스트 처리 파이프라인
        Processor<String> pipeline = Processors.TRIM
            .andThen(Processors.TO_LOWER)
            .andThen(Processors.replace("  ", " "))
            .andThen(Processors.addPrefix("📝 "))
            .andThen(Processors.addSuffix(" [processed]"))
            .andThen(Processors.truncate(50))
            .withLogging("text-processing");
        
        String input = "  HELLO   WORLD  WITH   SPACES  ";
        String result = pipeline.apply(input);
        System.out.println("Final result: " + result);
        
        // 조건부 처리
        Processor<String> conditionalPipeline = Processors.TRIM
            .andThen(Processors.TO_UPPER.when(s -> s.length() < 10))
            .andThen(Processors.REVERSE.when(s -> s.contains("HELLO")));
        
        System.out.println("Conditional: " + conditionalPipeline.apply("hello"));
        
        // 반복 적용
        Processor<String> doubleReverse = Processors.repeat(Processors.REVERSE, 2);
        System.out.println("Double reverse: " + doubleReverse.apply("hello")); // "hello"
        
        // 리스트 처리
        List<String> texts = Arrays.asList("  hello  ", "  WORLD  ", "  java  ");
        Processor<String> itemProcessor = Processors.TRIM.andThen(Processors.TO_UPPER);
        List<String> processed = Processors.parallel(itemProcessor).apply(texts);
        System.out.println("Processed list: " + processed);
    }
}