디자인 패턴 3. 데코레이터 패턴

디자인 패턴 3. 데코레이터 패턴

디자인원칙, 클래스는 확장에 대해서는 열려 있어야 하지만 코드 변경에 대해서는 닫혀 있어야 한다. (Open-Closed Principle)
기존 코드는 건드리지 않은 채로 확장을 통해서 새로운 행동을 간단하게 추가할 수 있도록 해야한다. 이렇게 하면 새로운 기능 추가가 매우 유연하여 급변하는 환경에 잘 적응하면서도 튼튼한 디자인을 만들 수 있다.
이 원칙은 어떻게 보면 모순되어 보일 수 있다. 하지만 직접 코드를 수정하지 않고 코드를 확장할 수 있게 해주는 기법들이 있다.

상속은 변경될 가능성이 높은 부분에는 적합하지 않다.
책에서는 스벅 음료 추상클래스를 상속받는 음료 메뉴들을 예로 들었다.

public abstract class Beverage {

    String description;

    String getDescription() {
        return description;
    };

    abstract int cost();
}

첫번째 잘못된 예는 모든 변경을 별도의 클래스로 만드는 것이다. 이 방법은 클래스의 수가 어마어마하게 많아지므로 실패.

public class Espresso extends Beverage { ... };
public class EspressoWithSteamedMilk extends Beverage { ... };
public class EspressoWithWhip extends Beverage { ... };
public class EspressoWithMocha extends Beverage { ... };
public class EspressoWhipAndMocha extends Beverage { ... };
public class EspressoSteamedMilkAndMocha extends Beverage { ... };
...

두번째 잘못된 예는 변경을 인스턴스 변수와 상속으로 관리하는 것이다.

public class Beverage {

    String description;
    boolean milk;
    boolean soy;
    boolean mocha;
    boolean whip;

    public void setDescription(String description) {
        this.description = description;
    }

    public boolean hasMilk() {
        return milk;
    }

    public void setMilk(boolean milk) {
        this.milk = milk;
    }

    public boolean hasSoy() {
        return soy;
    }

    public void setSoy(boolean soy) {
        this.soy = soy;
    }

    public boolean hasMocha() {
        return mocha;
    }

    public void setMocha(boolean mocha) {
        this.mocha = mocha;
    }

    public boolean hasWhip() {
        return whip;
    }

    public void setWhip(boolean whip) {
        this.whip = whip;
    }

    String getDescription() {
        return description;
    };

    int cost() {
        return (hasSoy() ? 300:0) +
                (hasMocha() ? 500:0) +
                (hasMilk() ? 500:0) +
                (hasWhip() ? 300:0);
    } 
}

각 음료 메뉴에서는 cost 메서드를 재정의하여 특정 음료에 대한 가격을 더해야 한다.

public class Espresso extends Beverage{
    @Override
    int cost() {
        return super.cost() + 4000;
    }
}

이 방법은 클래스의 수는 확실히 줄어들지만 새로운 변경 사항이 있을 때 추가적인 코드 변경은 아직 많다는 것이다. 예를들면, 새로운 첨가물 종류가 나온다거나 첨가물 가격이 변경되거나 두번 들어갈 수 있는 경우 등...
특정 첨가물이 들어가면 안되는 경우에는 해당 음료클래스에는 적합하지 않은 메서드를 상속받게 되는 문제도 있다.

---

데코레이터 패턴

데코레이터 패턴에서는 객체에 추가적인 요건을 동적으로 첨가할 수 있다. 데코레이터는 서브클래스를 만드는 것을 통해서 기능을 유연하게 확장할 수 있는 방법을 제공한다.
데코레이터는 변경 대상이 되는 클래스의 상위클래스를 상속받으며 한 객체를 여러 데코레이터로 꾸밀 수 있다.
데코레이터는 자신이 장식하고 있는 객체에게 어떤 행동을 위임하는 것 외에 원하는 추가적인 작업을 수행할 수 있다.

예시를 디자인 원칙에 맞게 코딩하기 위해서 데코레이터 패턴을 사용했다. 예시의 변경사항을 데코레이터 객체로 만드는 것이다.

public abstract class CondimentDecorator extends Beverage{
    public abstract String getDescription();
}

이 예시에서 데코레이터는 장식하고 있는 객체에 가격을 구하는 작업 및 음료 이름을 리턴하는 작업을 위임한다.

//데코레이터는 자신이 장식할 구성요소와 같은 인터페이스 또는 추상클래스를 구현한다.
public class Mocha extends CondimentDecorator{
    //데코레이터에는 장식하고 있는 컴포넌트를 위한 인스턴스 변수가 있다.
    private Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    public Beverage getBeverage() {
        return beverage;
    }

    @Override
    int cost() {
        return 400 + beverage.cost();
    }

    @Override
    public String getDescription() {
        return this.description = beverage.getDescription() + " 모카";
    }
}

데코레이터 패턴은 추상 컴포넌트 형식을 바탕으로 돌아가는 코드에 대해 적용해야 제대로 된 효과를 얻을 수 있다. 콘크리트 컴포넌트를 바탕으로 돌아가는 코드에는 데코레이터 패턴이 부적합하다.

---

자바 I/O를 데코레이터 패턴의 대표적인 예로 소개했다.
InputStream : 추상 구성요소
FileInputStream, StringBufferInputStream, ByteArrayInputStream, ... : 데코레이터로 포장 될 구상 구성요소
FilterInputStream : 추상 데코레이터
BufferedInputStream, DataInputStream, ... : 구상 데코레이터

추상 데코레이터 FilterInputStream를 상속받아서 새로운 데코레이터 클래스를 만들 수도 있다.
다음은 InputStream의 모든 대문자를 소문자로 바꿔주는 데코레이터이다.

import java.io.*;

public class LowerCaseInputStream extends FilterInputStream {
    InputStream inputStream;

    public LowerCaseInputStream(InputStream in) {
        super(in);
    }

    @Override
    public int read() throws IOException {
        int c = super.read();
        return (c == -1 ? c : Character.toLowerCase((char) c));
    }

    @Override
    public int read(byte[] b) throws IOException {
        int result = super.read(b, 0, b.length);
        for (int i = 0; i < result; i++) {
            b[i] = (byte) Character.toLowerCase((char) b[i]);
        }
        return result;
    }

    public static void main(String[] args) {
        int c;
        try (InputStream in = new LowerCaseInputStream(new BufferedInputStream(new FileInputStream("test.txt")))) {
            while ((c = in.read()) >= 0) {
                System.out.print((char) c);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}