【设计模式】结构型：装饰器模式

不念不忘少年蓝@ 2023-01-17 03:24 133阅读 0赞

装饰者模式（Decorator Pattern）是指在不改变原有对象的基础之上，将功能附加到对象上，提供了比继承更有弹性的替代方案（扩展原有对象的功能），属于**结构型**模式。

装饰者模式在我们生活中应用也比较多如给煎饼加鸡蛋；给蛋糕加上一些水果；给房子装修等，为对象扩展一些额外的职责。

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

*  用于扩展一个类的功能或给一个类添加附加职责
 *  动态的给一个对象添加功能，这些功能可以再动态的撤销

### 1.代码示例 ###

来看一个这样的场景，上班族白领其实大多有睡懒觉的习惯，每天早上上班都是踩点，于是很多小伙伴为了多赖一会儿床都不吃早餐。那么，也有些小伙伴可能在上班路上碰到卖煎饼的路边摊，都会顺带一个到公司茶水间吃早餐。卖煎饼的大姐可以给你的煎饼加鸡蛋，也可以加香肠。

下面我们用代码还原一下码农的生活，首先创建一个煎饼 Battercake 类

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

**通过继承的方式扩展功能**

创建一个加鸡蛋的煎饼 BattercakeWithEgg 类：

public class BattercakeWithEgg extends Battercake{
        
        @Override
        protected String getMsg() {
        
            return super.getMsg() + "+1个鸡蛋";
        }
    
        @Override
        // 加一个鸡蛋加1块钱
        public int getPrice() {
        
            return super.getPrice() + 1;
        }
    }

再创建一个既加鸡蛋又加香肠的 BattercakeWithEggAndSausage 类：

public class BattercakeWithEggAndSausage extends BattercakeWithEgg{
        
        @Override
        protected String getMsg() {
        
            return super.getMsg() + "+1根香肠";
        }
    
        @Override
        // 加一个香肠加2块钱
        public int getPrice() {
        
            return super.getPrice() + 2;
        }
    }

编写客户端测试代码：

public class BattercakeTest {
        
        public static void main(String[] args) {
        
    
            Battercake battercake = new Battercake();
            System.out.println(battercake.getMsg() + ",总价格：" + battercake.getPrice());
    
            Battercake battercakeWithEgg = new BattercakeWithEgg();
            System.out.println(battercakeWithEgg.getMsg() + ",总价格：" + battercakeWithEgg.getPrice());
    
            Battercake battercakeWithEggAndSausage = new BattercakeWithEggAndSausage();
            System.out.println(battercakeWithEggAndSausage.getMsg() + ",总价格：" + battercakeWithEggAndSausage.getPrice());
        }
    
    }

结果如下：

![在这里插入图片描述][20210426214842598.png_pic_center]

运行结果没有问题。但是，如果用户需要一个加 2 个鸡蛋加 1 根香肠的煎饼，那么用我们现在的类结构是创建不出来的，也无法自动计算出价格，除非再创建一个类做定制。

如果需求再变，一直加定制显然是不科学的。那么下面我们就用装饰者模式来解决上面的问题。

**装饰器模式重构**

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

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

创建一个基本的煎饼（或者叫基础套餐）BaseBattercake

然后，再创建一个扩展套餐的抽象装饰者 BattercakeDecotator 类：

public abstract class BattercakeDecorator extends Battercake {
        
    
        // 静态代理，委派
        private Battercake battercake;
    
        public BattercakeDecorator(Battercake battercake) {
        
            this.battercake = battercake;
        }
    
        protected abstract void doSomething();
    
        @Override
        protected String getMsg() {
        
            return this.battercake.getMsg();
        }
    
        @Override
        protected int getPrice() {
        
            return this.battercake.getPrice();
        }
    }

然后，创建鸡蛋装饰者 EggDecorator 类

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

创建香肠装饰者 SausageDecorator 类

public class SausageDecorator extends BattercakeDecorator {
        
        public SausageDecorator(Battercake battercake) {
        
            super(battercake);
        }
    
        protected void doSomething() {
        
    
        }
    
        @Override
        protected String getMsg() {
        
            return super.getMsg() + "+1根香肠";
        }
    
        @Override
        protected int getPrice() {
        
            return super.getPrice() + 2;
        }
    }

编写客户端测试代码

public class BattercakeTest {
        
        public static void main(String[] args) {
        
    
            Battercake battercake;
            // 路边摊买一个煎饼
            battercake = new BaseBattercake();
            // 煎饼有点小，想再加一个鸡蛋
            battercake = new EggDecorator(battercake);
            // 再加一个鸡蛋
    	   // battercake = new EggDecorator(battercake);
            // 很饿，再加根香肠
            battercake = new SausageDecorator(battercake);
            battercake = new SausageDecorator(battercake);
            battercake = new SausageDecorator(battercake);
            battercake = new SausageDecorator(battercake);
            battercake = new SausageDecorator(battercake);
    
    
            // 跟静态代理最大区别就是职责不同
            // 静态代理不一定要满足is-a的关系
            // 静态代理会做功能增强，同一个职责变得不一样
    
            // 装饰器更多考虑是扩展
    
            System.out.println(battercake.getMsg() + ",总价：" + battercake.getPrice());
        }
    }

运行结果如下：

![在这里插入图片描述][20210426231636832.png_pic_center]

来看一下类图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center][]

### 2.源码应用 ###

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1][]

再来看一个 MVC 中的 装饰者模式 HttpHeadResponseDecorator 类：

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

最后，看看 MyBatis 中的一段处理缓存的设计 org.apache.ibatis.cache.Cache 类，找到它的包定位：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 2][]

从名字上来看其实更容易理解了。比如 FifoCache 先入先出算法的缓存；LruCache 最近 最少使用的缓存；TransactionlCache 事务相关的缓存，都是采用装饰者模式。

### 3.总结 ###

装饰器模式主要解决继承关系过于复杂的问题，通过组合来替代继承。它主要的作用是给原始类添加增强功能。这也是判断是否该用装饰器模式的一个重要的依据。除此之外，装饰器模式还有一个特点，那就是可以对原始类嵌套使用多个装饰器。为了满足这个应用场景，在设计的时候，装饰器类需要跟原始类继承相同的抽象类或者接口。

装饰者模式的优缺点

优点：

*  装饰者是继承的有力补充，比继承灵活，不改变原有对象的情况下动态地给一个对象扩展功能，即插即用
 *  通过使用不同装饰类以及这些装饰类的排列组合，可以实现不同效果
 *  装饰者完全遵守开闭原则

缺点：

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

**装饰者模式和适配器模式对比**

装饰者和适配器模式都是包装模式（Wrapper Pattern），装饰者也是一种特殊的代理模式

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>装饰者模式</th> 
   <th>适配器模式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>形式</td> 
   <td>是一种非常特别的适配器模式</td> 
   <td>没有层级关系，装饰器模式有层级关系</td> 
  </tr> 
  <tr> 
   <td>定义</td> 
   <td>装饰者和被装饰者都实现同一个接口，主要目的是为了扩展之后依旧保留 OOP 关系</td> 
   <td>适配器和被适配者没有必然的联系，通常是采用继承或代理的形式进行包装</td> 
  </tr> 
  <tr> 
   <td>关系</td> 
   <td>满足 is-a 的关系</td> 
   <td>满足 has-a 的关系</td> 
  </tr> 
  <tr> 
   <td>功能</td> 
   <td>注重覆盖、扩展</td> 
   <td>注重兼容、转换</td> 
  </tr> 
  <tr> 
   <td>设计</td> 
   <td>前置考虑</td> 
   <td>后置考虑</td> 
  </tr> 
 </tbody> 
</table>

[20210426214842598.png_pic_center]: /images/20221022/090a9acb5d4847fa8d837b3c25b1ecdb.png
[20210426231636832.png_pic_center]: /images/20221022/1860f54f19394c3ea6a9634354816b9e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/db1700a1dadc4d7ebdf5b9891e793a61.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/196e0de80a404dea9f1676639e4e0960.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221022/caef4e68f1794708ab359c7c2181dff0.png