八：装饰器模式详解

装饰器模式在我们生活中应用也比较多如给煎饼加鸡蛋加香肠，代码如下

public class Pancake {
    public String getMeg(){
        return "煎饼";
    }
    public int getPrice(){
        return 5;
    }
}

public class PancakeWithEgg extends Pancake {
    @Override
    public String getMeg(){
        return super.getMeg()+"鸡蛋";
    }
    @Override
    public int getPrice(){
        return super.getPrice()+1;
    }

}

public class PancakeWithEggAndSausage extends PancakeWithEgg{
    @Override
    public String getMeg(){
        return super.getMeg()+"香肠";
    }
    @Override
    public int getPrice(){
        return super.getPrice()+2;
    }
}

public class SimpleTest {
    public static void main(String[] args) {
        Pancake pancake = new Pancake();
        System.out.println(pancake.getMeg()+",价格："+pancake.getPrice());
        PancakeWithEgg pancakeWithEgg = new PancakeWithEgg();
        System.out.println(pancakeWithEgg.getMeg()+",价格："+pancakeWithEgg.getPrice());
        PancakeWithEggAndSausage pancakeWithEggAndSausage = new PancakeWithEggAndSausage();
        System.out.println(pancakeWithEggAndSausage.getMeg()+",价格："+pancakeWithEggAndSausage.getPrice());
    }
}

但是，如果用户需要一个加2个鸡蛋加1根香肠的煎饼，那么用我们现在的类
结构是创建不出来的，也无法自动计算出价格，除非再创建一个类做定制。如果需求再变，一直加定制
显然是不科学的。那么下面我们就用装饰器模式来解决上面的问题。

创建一个建煎饼的抽象Battercake类：

public abstract class Battercake {
    protected abstract String getMsg();

    protected abstract int getPrice();
}

创建一个基本的煎饼基础套餐BaseBattercake：

public class BaseBattercake extends Battercake {
    @Override
    protected String getMsg() {
        return "煎饼";
    }
    @Override
    protected int getPrice() {
        return 5;
    }
}

创建一个扩展套餐的抽象装饰器BattercakeDecotator类：

public class BattercakeDecotator extends Battercake {
    private Battercake battercake;

    public BattercakeDecotator(Battercake battercake) {
        this.battercake = battercake;
    }
    @Override
    protected String getMsg() {
        return battercake.getMsg();
    }
    @Override
    protected int getPrice() {
        return battercake.getPrice();
    }
}

创建鸡蛋装饰器EggDecorator类

public class EggDecorator extends BattercakeDecotator {
    public EggDecorator(Battercake battercake) {
        super(battercake);
    }
    @Override
    protected String getMsg(){ return super.getMsg() + "1个鸡蛋";}

    @Override
    protected int getPrice(){ return super.getPrice() + 1;}
}

创建香肠装饰器SausageDecorator类：

public class SausageDecorator extends BattercakeDecotator {
    public SausageDecorator(Battercake battercake) {
        super(battercake);
    }
    @Override
    protected String getMsg(){ return super.getMsg() + "1根香肠";}
    @Override
    protected int getPrice(){ return super.getPrice() + 2;}
}
测试一下：

public class DecoratorTest {
    public static void main(String[] args) {
        //路边摊买一个煎饼
        Battercake battercake = new BaseBattercake();
        System.out.println(battercake.getMsg() + ",总价" + battercake.getPrice());
        //加一个鸡蛋
        battercake = new EggDecorator(battercake);
        System.out.println(battercake.getMsg() + ",总价" + battercake.getPrice());
        //加一个鸡蛋
        battercake = new EggDecorator(battercake);
        System.out.println(battercake.getMsg() + ",总价" + battercake.getPrice());
        //加根香肠
        battercake = new SausageDecorator(battercake);
        System.out.println(battercake.getMsg() + ",总价" + battercake.getPrice());
    }
}

装饰器在代码程序中适用于以下场景：

1、用于扩展一个类的功能或给一个类添加附加职责。

2、动态的给一个对象添加功能，这些功能可以再动态的撤销。

3、需要为一批的兄弟类进行改装或加装功能。

装饰器模式在源码中也应用得非常多，在 JDK 中体现最明显的类就是 IO 相关的类，如BufferedReader、InputStream、OutputStream，看一下常用的InputStream的类结构图：

 

在Spring 中的 TransactionAwareCacheDecorator类我们也可以来尝试理解一下，这个类主要是用来处理事务缓存的

public class TransactionAwareCacheDecorator implements Cache {
    private final Cache targetCache;

    public TransactionAwareCacheDecorator(Cache targetCache) {
        Assert.notNull(targetCache, "Target Cache must not be null");
        this.targetCache = targetCache;
    }

    public Cache getTargetCache() {
        return this.targetCache;
    }
    ...
}

TransactionAwareCacheDecorator就是对Cache的一个包装

再看HttpHeadResponseDecorator类

public class HttpHeadResponseDecorator extends ServerHttpResponseDecorator {
    public HttpHeadResponseDecorator(ServerHttpResponse delegate) {
        super(delegate);
    }
    ...
}

装饰器模式和代理模式对比

从代码实现上看，代
理模式的确与装饰器模式是一样的（其实装饰器模式就是代理模式的一个特殊应用），但是这两种设计模式所面向的功能扩展面是不一样的：

装饰器模式强调自身功能的扩展。Decorator所做的就是增强ConcreteComponent的功能（也有可能减弱功能），主体对象为ConcreteComponent，着重类功能的变化；

代理模式强调对代理过程的控制。Proxy 完全掌握对 RealSubject的访问控制，因此，Proxy 可以决定对RealSubject 进行功能扩展，功能缩减甚至功能散失（不调用RealSubject方法），主体对象为Proxy；

装饰器模式的优缺点

优点：

1、装饰器是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象扩展功能，即插即用。

2、通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果。

3、装饰器完全遵守开闭原则。

缺点：

1、会出现更多的代码，更多的类，增加程序复杂性。

2、动态装饰时，多层装饰时会更复杂。