【设计模式】告别继承噩梦：用装饰者模式简化代码结构 ...

概述

我们先来看一个快餐店的例子。
快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，固然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。

利用继承的方式存在的问题：

• 扩展性不好：如果要再加一种配料（火腿肠），我们就会发现需要给FriedRice和FriedNoodles分别定义一个子类。如果要新增一个快餐品类（炒河粉）的话，就需要定义更多的子类。
  
• 产生过多的子类
  

定义：指在不改变现有对象结构的环境下，动态地给该对象增加一些职责（即增加其额外功能）的模式。
结构

装饰（Decorator）模式中的角色：

• 抽象构件（Component）角色 ：定义一个抽象接口以规范准备吸收附加责任的对象。
  
• 详细构件（Concrete Component）角色 ：实现抽象构件，通过装饰角色为其添加一些职责。
  
• 抽象装饰（Decorator）角色 ： 继承或实现抽象构件，并包含详细构件的实例，可以通过其子类扩展详细构件的功能。
  
• 详细装饰（ConcreteDecorator）角色 ：实现抽象装饰的相干方法，并给详细构件对象添加附加的责任。
  

案例

我们利用装饰者模式对快餐店案例进行改进，体会装饰者模式的精华。
类图如下：

代码如下：

1. //快餐接口
2. public abstract class FastFood {
3.     private float price;
4.     private String desc;
6.     public FastFood() {
7.     }
9.     public FastFood(float price, String desc) {
10.         this.price = price;
11.         this.desc = desc;
12.     }
14.     public void setPrice(float price) {
15.         this.price = price;
16.     }
18.     public float getPrice() {
19.         return price;
20.     }
22.     public String getDesc() {
23.         return desc;
24.     }
26.     public void setDesc(String desc) {
27.         this.desc = desc;
28.     }
30.     public abstract float cost();  //获取价格
31. }
33. //炒饭
34. public class FriedRice extends FastFood {
36.     public FriedRice() {
37.         super(10, "炒饭");
38.     }
40.     public float cost() {
41.         return getPrice();
42.     }
43. }
45. //炒面
46. public class FriedNoodles extends FastFood {
48.     public FriedNoodles() {
49.         super(12, "炒面");
50.     }
52.     public float cost() {
53.         return getPrice();
54.     }
55. }
57. //配料类
58. public abstract class Garnish extends FastFood {
60.     private FastFood fastFood;
62.     public FastFood getFastFood() {
63.         return fastFood;
64.     }
66.     public void setFastFood(FastFood fastFood) {
67.         this.fastFood = fastFood;
68.     }
70.     public Garnish(FastFood fastFood, float price, String desc) {
71.         super(price,desc);
72.         this.fastFood = fastFood;
73.     }
74. }
76. //鸡蛋配料
77. public class Egg extends Garnish {
79.     public Egg(FastFood fastFood) {
80.         super(fastFood,1,"鸡蛋");
81.     }
83.     public float cost() {
84.         return getPrice() + getFastFood().getPrice();
85.     }
87.     @Override
88.     public String getDesc() {
89.         return super.getDesc() + getFastFood().getDesc();
90.     }
91. }
93. //培根配料
94. public class Bacon extends Garnish {
96.     public Bacon(FastFood fastFood) {
98.         super(fastFood,2,"培根");
99.     }
101.     @Override
102.     public float cost() {
103.         return getPrice() + getFastFood().getPrice();
104.     }
106.     @Override
107.     public String getDesc() {
108.         return super.getDesc() + getFastFood().getDesc();
109.     }
110. }
112. //测试类
113. public class Client {
114.     public static void main(String[] args) {
115.         //点一份炒饭
116.         FastFood food = new FriedRice();
117.         //花费的价格
118.         System.out.println(food.getDesc() + " " + food.cost() + "元");
120.         System.out.println("========");
121.         //点一份加鸡蛋的炒饭
122.         FastFood food1 = new FriedRice();
124.         food1 = new Egg(food1);
125.         //花费的价格
126.         System.out.println(food1.getDesc() + " " + food1.cost() + "元");
128.         System.out.println("========");
129.         //点一份加培根的炒面
130.         FastFood food2 = new FriedNoodles();
131.         food2 = new Bacon(food2);
132.         //花费的价格
133.         System.out.println(food2.getDesc() + " " + food2.cost() + "元");
134.     }
135. }

复制代码

好处：

• 装饰者模式可以带来比继承更加灵活性的扩展功能，利用更加方便，可以通过组合不同的装饰者对象来获取具有不同举动状态的多样化的结果。装饰者模式比继承更具精良的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
  
• 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
  

利用场景

• 当不能采用继承的方式对体系进行扩充大概采用继承不利于体系扩展和维护时。不能采用继承的环境主要有两类：
  
  
  
  • 第一类是体系中存在大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长；
    
  • 第二类是由于类定义不能继承（如final类）
    
  
  
• 在不影响其他对象的环境下，以动态、透明的方式给单个对象添加职责。
  
• 当对象的功能要求可以动态地添加，也可以再动态地撤销时。
  

源码解析 - IO流包装类

IO流中的包装类利用到了装饰者模式。BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter。
我们以BufferedWriter举例来阐明，先看看如何利用BufferedWriter

1. public class Demo {
2.     public static void main(String[] args) throws Exception{
3.         //创建BufferedWriter对象
4.         //创建FileWriter对象
5.         FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
6.         BufferedWriter bw = new BufferedWriter(fw);
8.         //写数据
9.         bw.write("hello Buffered");
11.         bw.close();
12.     }
13. }

复制代码

利用起来感觉确实像是装饰者模式，接下来看它们的结构：

小结：BufferedWriter利用装饰者模式对Writer子实现类进行了增强，添加了缓冲区，提高了写数据的效率。
代理和装饰者的区别

静态代理和装饰者模式的区别：

• 雷同点：
  
  
  
  • 都要实现与目的类雷同的业务接口
    
  • 在两个类中都要声明目的对象
    
  • 都可以在不修改目的类的前提下增强目的方法
    
  
  
• 不同点：
  
  
  
  • 目的不同装饰者是为了增强目的对象静态代理是为了保护和隐藏目的对象
    
  • 获取目的对象构建的地方不同装饰者是由外界通报进来，可以通过构造方法通报静态代理是在代理类内部创建，以此来隐藏目的对象
    
  
  

往期推荐

• 《SpringBoot》EasyExcel实现百万数据的导入导出
  
• 《SpringBoot》史上最全SpringBoot相干注解介绍
  
• Spring框架IoC核心详解
  
• 万字长文带你窥探Spring中所有的扩展点
  
• 如何实现一个通用的接口限流、防重、防抖机制
  
• 万字长文带你深入Redis底层数据结构
  
• volatile关键字最全原理剖析
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。