【设计模式】装饰器模式

装饰器模式

以生活中的场景来举例，一个蛋糕胚，给它涂上奶油就变成了奶油蛋糕，再加上巧克力和草莓，它就变成了巧克力草莓蛋糕。

像这样在不改变原有对象的基础之上，将功能附加到原始对象上的设计模式就称为装饰模式(Decorator模式)，属于结构型模式。

装饰器模式中主要有四个角色:
Component : 定义被装饰对象的接口，装饰器也需要实现一样的接口
ConcreteComponent: 具体的装饰对象,实现了Component接口,通常就是被装饰的原始对象
Decorator: 所有装饰器的抽象父类,需要定义与Component一致的接口，并且持有一个被装饰的Component对象
ConcreteDecorator: 具体装饰器对象
​​​​​​​​

代码示例

假设我们需要设计一个奖金的系统,目前一个工作人员的奖金包含三部分:

本月销售额的奖金 : 当月销售额的3%

累计销售额的奖金 : 累计销售额的0.1%

团队销售额的奖金 : 团队销售额的1%，只有经理才有

使用装饰模式的实现如下 ： 定义一个所有奖金的抽象接口，然后定义一个BasicPrize的初始奖金对象，不同的人奖金的组成不同，就为其添加不同的装饰器

public abstract class Component {

    abstract double calPrize(String userName);
}

public class BasicPrize extends Component {

    //保存了一个员工与销售额的对应关系的map
    public static Map<String,Double> saleMoney = new HashMap<String,Double>();

    static {
        saleMoney.put("小明",9000.0);
        saleMoney.put("小陈",20000.0);
        saleMoney.put("小王",30000.0);
        saleMoney.put("张经理",55000.0);
    }

    public double calPrize(String userName) {
        return 0;
    }
}

/**
 *
 * 所有装饰器的抽象父类,持有一个被装饰对象
 */
public abstract class Decorator extends Component {
    protected Component component;

    public Decorator(Component component){
        this.component = component;
    }

    public abstract double calPrize(String userName);
}

/**
 * 
 * 当月奖金计算规则
 */
public class MonthPrizeDecorator extends  Decorator{

    public MonthPrizeDecorator(Component component) {
        super(component);
    }

    public double calPrize(String userName)  {
        //先计算被装饰对象的奖金(就是在加上本奖金之前的奖金)
        double money = this.component.calPrize(userName);
        //计算本奖金  对应员工的业务额的3%
        double prize = BasicPrize.saleMoney.get(userName)*0.03;
        System.out.println(userName+"当月 业务奖金:"+prize);
        return money + prize;
    }

}

/**
 * 累计奖金
 */
public class SumPrizeDecorator extends Decorator {
    public SumPrizeDecorator(Component component) {
        super(component);
    }


    public double calPrize(String userName)  {
        //先计算被装饰对象的奖金(就是在加上本奖金之前的奖金)
        double money = this.component.calPrize(userName);
        //计算本奖金  累计业务额的0.1% 假设是100000
        double prize = 100000*0.001;
        System.out.println(userName+"当月 累计奖金:"+prize);
        return money + prize;
    }

}

/**
 * 团队奖金
 */
public class GroupPrizeDecorator extends Decorator {
    public GroupPrizeDecorator(Component component) {
        super(component);
    }

    public double calPrize(String userName)  {
        //先计算被装饰对象的奖金(就是在加上本奖金之前的奖金)
        double money = this.component.calPrize(userName);
        //计算本奖金  本团队的业务额的1%
        double sumSale = 0;
        for(double sale: BasicPrize.saleMoney.values()){
            sumSale += sale;
        }
        double prize = sumSale*0.01;
        System.out.println(userName+"当月 团队奖金:"+prize);
        return money + prize;
    }


}

/**
 * @Description
 */
public class Client {
    public static void main(String[] args) throws FileNotFoundException {
        //基础对象 奖金0
        Component basePrice = new BasicPrize();
        //当月奖金
        Component salePrize = new MonthPrizeDecorator(basePrice);
        //累计奖金
        Component sumPrize = new SumPrizeDecorator(salePrize);
        //团队奖金
        Component groupPrize = new GroupPrizeDecorator(sumPrize);
 
        //普通员工的奖金由两部分组成
        double d1 = sumPrize.calPrize("小明");
        System.out.println("========================小明总奖金:"+d1);
        double d2 = sumPrize.calPrize("小陈");
        System.out.println("========================小陈总奖金:"+d2);
        double d3 = sumPrize.calPrize("小王");
        System.out.println("========================小王总奖金:"+d3);
        //王经理的奖金由三部分组成
        double d4 = groupPrize.calPrize("张经理");
        System.out.println("========================张经理总奖金:"+d4);

       
    }
}

输出结果如下:
​​
这里我们使用装饰器模式，主要是为了方便组合和复用。在一个继承的体系中，子类往往是互斥的，比方在一个奶茶店，它会有丝袜奶茶，红茶，果茶等，用户想要一杯饮料，一般都会在这些种类中选一种,不能一杯饮料既是果茶又是奶茶。然后用户可以根据自己的喜好添加任何想要的decorators,珍珠，椰果，布丁等，这些添加物对所有茶类饮品都是相互兼容的，并且是可以被允许反复添加的(同样的装饰器是否允许在同一个对象上装饰多次，视情况而定，像上面的奖金场景显然是不被允许的)

jdk中的装饰器模式

java.io包是用于输入输出的包，这里使用了大量的装饰器模式，我们再来体会一下装饰器模式的优点。

下图是jdk 输出流的一部分类图，很明显是一个装饰模式的类图，OutputStream是顶层父类，FileOutputStream和ObjectOutputStream是具体的被装饰类，FilterOutputStream是所有输出流装饰器的抽象父类

使用的代码如下:

	InputStream in = new FileInputStream("/user/wangzheng/test.txt");
	InputStream bin = new BufferedInputStream(in);
	byte[] data = new byte[128];
	while (bin.read(data) != -1) {
		//...
	}

为什么Java IO设计的时候要使用装饰器模式, 而J不设计⼀个继承 FileInputStream 并且⽀持缓存的 BufferedFileInputStream 类呢?

如果InputStream 只有⼀个⼦类 FileInputStream 的话，那我们在 FileInputStream 基础之上，再设计⼀个孙⼦类BufferedFileInputStream，也是可以接受的。但实际上，继承 InputStream 的⼦类有很多。我们需要给每⼀个 InputStream 的⼦类，
再继续派⽣⽀持缓存读取的⼦类。
除此之外，我们还需要对功能进⾏其他⽅⾯的增强，⽐如下⾯的DataInputStream 类，⽀持按照基本数据类型（int、boolean、long 等）来读取数据。这种情形下，使用继承的方式的话类的继承结构变得⽆⽐复杂，代码维护起来也比较费劲。

按照装饰器模式的结构，我们可以继承FilterOutputStream实现自定义的装饰器,并且在使用的时候可以和jdk自带的装饰器对象任意组合。

我们可以实现一个简单的复制输出内容的OutputStream装饰器

public class DuplicateOutputStream2 extends FilterOutputStream {
    /**
     * Creates an output stream filter built on top of the specified
     * underlying output stream.
     *
     * @param out the underlying output stream to be assigned to
     *            the field <tt>this.out</tt> for later use, or
     *            <code>null</code> if this instance is to be
     *            created without an underlying stream.
     */
    public DuplicateOutputStream2(OutputStream out) {
        super(out);
    }

    //将所有的内容复制一份输出 ab 变成aabb
    public void write(int b) throws IOException {
        super.write(b);
        super.write(b);
    }
}

装饰器类是否可以直接实现Component父类?

以输出流为例，如果直接继承OutputStream来实现自定义装饰器

public class DuplicateOutputStream extends OutputStream {
 
    private OutputStream os;
 
    public DuplicateOutputStream(OutputStream os){
        this.os = os;
    }
 
    //将所有的内容复制一份输出 ab 变成aabb
    public void write(int b) throws IOException {
        os.write(b);
        os.write(b);
    }
}

public class ClientTest {
    public static void main(String[] args) throws IOException {
 
        DataOutputStream dataOutputStream = new DataOutputStream(new BufferedOutputStream(new DuplicateOutputStream2(new FileOutputStream("1.txt"))));
        testOutputStream(dataOutputStream);
 
        DataOutputStream dataOutputStream1 = new DataOutputStream(new BufferedOutputStream(new DuplicateOutputStream(new FileOutputStream("1.txt"))));
        testOutputStream(dataOutputStream1);
 
    }
 
    public static void testOutputStream(DataOutputStream dataOutputStream) throws IOException {
        DataInputStream dataInputStream = new DataInputStream(new FileInputStream("1.txt"));
        dataOutputStream.write("bdsaq".getBytes());
        dataOutputStream.close();
        System.out.println(dataInputStream.available());
        byte[] bytes3 = new byte[dataInputStream.available()];
        dataInputStream.read(bytes3);
        System.out.println("文件内容:"+new String(bytes3));
    }
}

输出结果:

乍一看好像没什么区别，但是如果把BufferedOutputStream装饰器和自定义的装饰器互换。

DataOutputStream dataOutputStream2 = new DataOutputStream(new DuplicateOutputStream2(new BufferedOutputStream(new FileOutputStream("1.txt"))));
testOutputStream(dataOutputStream2);

DataOutputStream dataOutputStream3 = new DataOutputStream(new DuplicateOutputStream(new BufferedOutputStream(new FileOutputStream("1.txt"))));
testOutputStream(dataOutputStream3);

输出结果:

使用了实现OutputStream的DuplicateOutputStream会出现没有正常输出数据，这是因为我们使用了BufferedOutputStream这个带缓存区的输出流，缓存区的输出流在缓存区没有满的情形下是不会进行输出操作的。一般情形下我们在调用jdk的DataOutputStream的close方法的时候会调用其传入的输出流的flush()方法,并且向下传递调用，BufferedOutputStream里的数据会正常输出。

在使用DuplicateOutputStream2的时候其调用关系是这样的:

dataOutputStream.close()–>duplicateOutputStream2.flush()–>bufferedOutputStream.flush()

使用DuplicateOutputStream的时候由于DuplicateOutputStream继承的OutputStream的flush()方法是空实现，所以不会继续往下调用bufferedOutputStream的flush()方法，故而最后没有得到输出内容

所以装饰器类需要继承Decorator抽象父类，而不是直接继承Component抽象类，我认为是为了在Decorator里实现一些共性的代码，以便在使用装饰器的时候能够更加自由，无视其组合顺序 (当然如果你的Decorator里没有任何逻辑代码，在合适的场景下你可以不定义抽象装饰器类)

总结

装饰器模式主要用于解决继承关系过于复杂的问题，通过组合来替代继承。
它主要的作⽤是给原始类添加增强功能。

除此之外，装饰器模式还有⼀个特点，那就是可以对原始类嵌套使⽤多个装饰器。为了满⾜这个应⽤场景，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接⼝。