设计模式之装饰者模式

场景：

有家买煎饼的小店，煎饼可以附加几种其他的佐料，比如香肠，鸡蛋，等等，我们假定这家小店现在只有两种附加的佐料

煎饼有两个属性：

1. 价格
2. 描述(煎饼套餐名称，价格)

用普通的继承来实现各种煎饼

1. 基础的煎饼

package com.tangbaobao.design.pattern.struct.decorate.v1;

/**
 * @author tangxuejun
 * @version 2019-04-24 08:43
 */
public class Battercake {
    protected String getDesc() {
        return "煎饼";
    }

    protected int cost() {
        return 8;
    }
}

2. 加一根香肠的煎饼：

package com.tangbaobao.design.pattern.struct.decorate.v1;

/**
 * @author tangxuejun
 * @version 2019-04-24 08:46
 */
public class BatterCakeWithAgeSausage extends BatterCakeWithEgg {
    @Override
    public String getDesc() {
        return super.getDesc() + "加一根香肠";
    }

    @Override
    public int cost() {
        return super.cost() + 2;
    }
}

3. 加一个鸡蛋再加一个香肠的煎饼

package com.tangbaobao.design.pattern.struct.decorate.v1;

/**
 * @author tangxuejun
 * @version 2019-04-24 08:46
 */
public class BatterCakeWithAgeSausage extends BatterCakeWithEgg {
    @Override
    public String getDesc() {
        return super.getDesc() + "加一根香肠";
    }

    @Override
    public int cost() {
        return super.cost() + 2;
    }
}

上面两种可能是常用的套餐组合，但是有的顾客很饿，想加两个鸡蛋，想加两根香肠，上述的类不能满足需求，但是如果真的想要增加各种套餐，用上述的方法可能引起类爆炸，因为一种套餐需要一个类来实现，有没有好的方式来组合更多的套餐呢？肯定有，那就是装饰者模式。。

装饰者模式：

定义: 在不改变原有对象的基础上，将功能附加在对象上
提供了比继承更有弹性的替代方案(扩展原有对象的功能)
类型: 结构型

适用场景：

1. 扩展一个类的功能或者给一个类添加附加职责
2. 动态的给一个对象添加功能，这些功能可以动态撤销

优点：

1. 是继承的灵活补充，比继承灵活，不改变原有对象那个的情况下给一个对象扩展功能
2. 通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同的效果
3. 符合开闭原则

缺点：

1. 会出现更多的代码，更多的类，增加程序的复杂性
2. 动态装饰时，多层装饰时会更复杂

用装饰者模式实现煎饼小店各种可能的组合

1. 将煎饼抽象出来：

package com.tangbaobao.design.pattern.struct.decorate.v2;
/**
 * @author tangxuejun
 * @version 2019-04-24 08:56
 */
public abstract class ABatterCake {
	//煎饼的附加佐料
    protected abstract String getDesc();
    //煎饼的价格
    protected abstract int cost();
}

2. 基础煎饼实现抽象煎饼

package com.tangbaobao.design.pattern.struct.decorate.v2;

/**
 * @author tangxuejun
 * @version 2019-04-24 08:58
 */
public class BatterCake extends ABatterCake {

    @Override
    protected String getDesc() {
        return "煎饼";
    }
    @Override
    protected int cost() {
        return 8;
    }
}

3. 将煎饼的其他属性抽象成一个装饰器，并实现抽象煎饼

package com.tangbaobao.design.pattern.struct.decorate.v2;

/**
 * @author tangxuejun
 * @version 2019-04-24 08:59
 */
public class AbstractDecorate extends ABatterCake{

    private ABatterCake aBatterCake;
    //构造器传入的是抽象煎饼，这个实现其实是委托抽象煎饼去给被装饰者装饰相关属性
    public AbstractDecorate(ABatterCake aBatterCake) {
        this.aBatterCake = aBatterCake;
    }

    @Override
    protected String getDesc() {
        return this.aBatterCake.getDesc();
    }

    @Override
    protected int cost() {
        return this.aBatterCake.cost();
    }
}

4. 鸡蛋装饰器

package com.tangbaobao.design.pattern.struct.decorate.v2;

/**
 * @author tangxuejun
 * @version 2019-04-24 09:01
 */
public class EggDecorate extends AbstractDecorate {


    public EggDecorate(ABatterCake aBatterCake) {
        super(aBatterCake);
    }

    @Override
    public String getDesc() {
        return super.getDesc()+"加一个鸡蛋";
    }

    @Override
    public int cost() {
        return super.cost() + 1;
    }
}

5. 香肠装饰器：

package com.tangbaobao.design.pattern.struct.decorate.v2;

/**
 * @author tangxuejun
 * @version 2019-04-24 09:02
 */
public class SausageDecorate extends AbstractDecorate {
    public SausageDecorate(ABatterCake aBatterCake) {
        super(aBatterCake);
    }

    @Override
    protected String getDesc() {
        return super.getDesc()+"加一根香肠";
    }

    @Override
    protected int cost() {
        return super.cost()+2;
    }
}

香肠和鸡蛋装饰器之所以要实现抽象煎饼，是因为需要将佐料装饰器传入给抽象装饰器，委托抽象装饰器完成对被装饰者的装饰

使用装饰者模式完成各种煎饼

package com.tangbaobao.design.pattern.struct.decorate.v2;

/**
 * @author tangxuejun
 * @version 2019-04-24 08:54
 */
public class MainTest {

    public static void main(String[] args) {
        ABatterCake aBatterCake;
        aBatterCake = new BatterCake();
        //加两个鸡蛋，一个香肠，不用新建很多套餐类，只需给基础煎饼进行装饰即可
        aBatterCake = new EggDecorate(aBatterCake);
        aBatterCake = new EggDecorate(aBatterCake);
        aBatterCake = new SausageDecorate(aBatterCake);
        System.out.println(aBatterCake.getDesc() + "   销售价格" + aBatterCake.cost());
    }
}

装饰者模式UML图:

我们可以直观的看出来，不论是装饰者还是被装饰者都继承最终的抽象被装饰者，

总结

我理解的装饰者模式的最终作用其实是装饰者委托抽象装饰器对被装饰者作出一系列动作
装饰者模式在很多开源框架中也有很多应用，比如JDK中的流相关的操作，inputstream
BufferedReader，Mybatis中的Cache等等。。