装饰器模式：让你的对象变得更强大

在日常开发中，当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。这时候，我们该怎么办呢？我们可以使用装饰器器模式来解决这个问题，本文将从以下四个方面讲解装饰器器模式。

• 简介
  
• 优缺点
  
• 应用场景
  
• Java 代码示例、
  
• Spring 代码示例
  

简介

装饰器模式（Decorator Pattern）是一种结构型设计模式，它可以在不改变现有对象的结构的情况下，动态地给对象增加一些额外的功能。装饰器模式通过创建一个包装对象（即装饰器）来包裹真实对象，并在保持真实对象的接口不变的前提下，为其提供额外的功能。装饰器模式可以在运行时根据需要选择不同的装饰器来组合和修改对象的行为。

• Component（组件接口）：所有被装饰组件及装饰器对应的接口标准，指定进行装饰的行为方法。对应本章例程中的展示接口 Showable。
  
• ConcreteComponent（组件实现）：需要被装饰的组件，实现组件接口标准，只具备自身未被装饰的原始特性。对应本章例程中的女生类 Girl。
  
• Decorator（装饰器）：装饰器的高层抽象类，同样实现组件接口标准，且包含一个被装饰的组件。
  
• ConcreteDecorator（装饰器实现）：继承自装饰器抽象类的具体子类装饰器，可以有多种实现，在被装饰组件对象的基础上为其添加新的特性。对应本章例程中的粉底类 FoundationMakeup、口红类 Lipstick。
  

推荐博主开源的 H5 商城项目waynboot-mall，这是一套全部开源的微商城项目，包含三个项目：运营后台、H5 商城前台和服务端接口。实现了商城所需的首页展示、商品分类、商品详情、商品 sku、分词搜索、购物车、结算下单、支付宝/微信支付、收单评论以及完善的后台管理等一系列功能。 技术上基于最新得 Springboot3.0、jdk17，整合了 MySql、Redis、RabbitMQ、ElasticSearch 等常用中间件。分模块设计、简洁易维护，欢迎大家点个 star、关注博主。
github 地址：https://github.com/wayn111/waynboot-mall

优缺点

装饰器模式的优点有：

• 装饰器模式是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态地给一个对象扩展功能，即插即用。
  
• 通过使用不同的装饰器及这些装饰器的排列组合，可以实现不同效果。
  
• 装饰器模式完全遵守开闭原则，可以在不修改原有代码的基础上增加新的功能。
  

装饰器模式的缺点有：

• 装饰器模式会增加许多子类，过度使用会增加程序的复杂性。
  
• 装饰器模式会增加对象之间的联系，可能会引入循环引用的问题。
  
• 装饰器模式会影响对象的标识，当使用装饰器对对象进行包装时，对象的类型和行为可能会发生变化。
  

应用场景

装饰器模式适用于以下场景：

• 当需要给一个现有的类添加附加职责，而又不能采用继承的方式时，可以使用装饰器模式。例如，在不修改原有代码的情况下给一个窗口添加滚动条或者边框等功能。
  
• 当需要动态地给一个对象增加功能，而又需要撤销该功能时，可以使用装饰器模式。例如，在电子商务系统中根据用户选择的不同优惠券来计算商品价格时，可以使用装饰器模式来实现。
  
• 当需要为一批兄弟类进行改装或加装功能时，可以使用装饰器模式。例如，在一个图形界面工具箱中为多个不同的组件提供一些公共的功能时，可以使用装饰器模式来实现。
  

java 代码示例

以下是一个实现装饰器模式的 java 示例代码

• 定义了一个抽象组件接口 Shape 和两个具体组件类 Circle 和 Rectangle，
  

1. //抽象组件接口
2. public interface Shape {
3.     void draw();
4. }
6. //具体组件类：圆形
7. public class Circle implements Shape {
8.     @Override
9.     public void draw() {
10.         System.out.println("Drawing a circle");
11.     }
12. }
14. //具体组件类：矩形
15. public class Rectangle implements Shape {
16.     @Override
17.     public void draw() {
18.         System.out.println("Drawing a rectangle");
19.     }
20. }

复制代码

• 定义一个抽象装饰器类 ShapeDecorator 和两个具体装饰器类 RedShapeDecorator 和 GreenShapeDecorator，
  

1. //抽象装饰器类
2. public abstract class ShapeDecorator implements Shape {
3.     //持有一个抽象组件对象
4.     protected Shape shape;
6.     //构造方法
7.     public ShapeDecorator(Shape shape) {
8.         this.shape = shape;
9.     }
11.     //调用被包装对象的方法
12.     @Override
13.     public void draw() {
14.         shape.draw();
15.     }
16. }
18. //具体装饰器类：红色装饰器
19. public class RedShapeDecorator extends ShapeDecorator {
20.     //构造方法
21.     public RedShapeDecorator(Shape shape) {
22.         super(shape);
23.     }
25.     //重写draw方法，在调用被包装对象的方法之前或之后添加新的功能
26.     @Override
27.     public void draw() {
28.         //调用被包装对象的方法
29.         super.draw();
30.         //添加新的功能
31.         setRedBorder();
32.     }
34.     //定义新的功能方法
35.     private void setRedBorder() {
36.         System.out.println("Setting red border");
37.     }
38. }
40. //具体装饰器类：绿色装饰器
41. public class GreenShapeDecorator extends ShapeDecorator {
42.     //构造方法
43.     public GreenShapeDecorator(Shape shape) {
44.         super(shape);
45.     }
47.     //重写draw方法，在调用被包装对象的方法之前或之后添加新的功能
48.     @Override
49.     public void draw() {
50.         //调用被包装对象的方法
51.         super.draw();
52.         //添加新的功能
53.         setGreenBorder();
54.     }
56.     //定义新的功能方法
57.     private void setGreenBorder() {
58.         System.out.println("Setting green border");
59.     }
60. }

复制代码

• 编写装饰器模式测试代码，main 函数中创建了不同的组件和装饰器对象，并调用了它们的方法，
  

1. //测试类
2. public class DecoratorPatternDemo {
3.     public static void main(String[] args) {
4.         //创建一个圆形对象
5.         Shape circle = new Circle();
6.         //创建一个矩形对象
7.         Shape rectangle = new Rectangle();
8.         //创建一个红色装饰器对象，包装圆形对象
9.         Shape redCircle = new RedShapeDecorator(circle);
10.         //创建一个绿色装饰器对象，包装矩形对象
11.         Shape greenRectangle = new GreenShapeDecorator(rectangle);
13.         //调用各个对象的方法，展示不同的效果
14.         System.out.println("Normal circle:");
15.         circle.draw();
16.         System.out.println("Normal rectangle:");
17.         rectangle.draw();
18.         System.out.println("Red circle:");
19.         redCircle.draw();
20.         System.out.println("Green rectangle:");
21.         greenRectangle.draw();
22.     }
23. }

复制代码

输出结果如下：

1. Normal circle:
2. Drawing a circle
3. Normal rectangle:
4. Drawing a rectangle
5. Red circle:
6. Drawing a circle
7. Setting red border
8. Green rectangle:
9. Drawing a rectangle
10. Setting green border

复制代码

Spring 代码示例

要想再 Spring 项目中应用装饰器模式，只需对以上代码进行简单改造即可，

• 给具体组件类 Circle、Rectangle 添加 @Component 注解，
  

1. @Component
2. public class Rectangle implements Shape {
3.     @Override
4.     public void draw() {
5.         System.out.println("Drawing a rectangle");
6.     }
7. }
9. @Component
10. public class Rectangle implements Shape {
11.     @Override
12.     public void draw() {
13.         System.out.println("Drawing a rectangle");
14.     }
15. }

复制代码

• 给具体装饰器类 RedShapeDecorator 和 GreenShapeDecorator 类添加 @Component 注解，
  

1. @Component
2. public class GreenShapeDecorator extends ShapeDecorator {
3.     // 构造方法
4.     public GreenShapeDecorator(@Qualifier("rectangle") Shape shape) {
5.         super(shape);
6.     }
8.     // 重写draw方法，在调用被包装对象的方法之前或之后添加新的功能
9.     @Override
10.     public void draw() {
11.         // 调用被包装对象的方法
12.         super.draw();
13.         // 添加新的功能
14.         setGreenBorder();
15.     }
17.     // 定义新的功能方法
18.     private void setGreenBorder() {
19.         System.out.println("Setting green border");
20.     }
21. }
23. @Component
24. public class RedShapeDecorator extends ShapeDecorator {
25.     // 构造方法
26.     public RedShapeDecorator(@Qualifier("circle") Shape shape) {
27.         super(shape);
28.     }
30.     // 重写draw方法，在调用被包装对象的方法之前或之后添加新的功能
31.     @Override
32.     public void draw() {
33.         // 调用被包装对象的方法
34.         super.draw();
35.         // 添加新的功能
36.         setRedBorder();
37.     }
39.     // 定义新的功能方法
40.     private void setRedBorder() {
41.         System.out.println("Setting red border");
42.     }
43. }

复制代码

• 编写 Spring 项目测试代码，
  

1. @SpringBootTest
2. @RunWith(SpringRunner.class)
3. public class DecoratorTest {
5.     // 从Spring容器中获取Context对象
6.     @Autowired
7.     private RedShapeDecorator redCircle;
8.     @Autowired
9.     private GreenShapeDecorator greenRectangle;
11.     @Test
12.     public void test() {
13.         System.out.println("Red circle:");
14.         redCircle.draw();
15.         System.out.println("Green rectangle:");
16.         greenRectangle.draw();
17.     }
18. }

复制代码

输出结果如下：

1. Red circle:
2. Drawing a circle
3. Setting red border
4. Green rectangle:
5. Drawing a rectangle
6. Setting green border

复制代码

总结

装饰器模式可以将不同功能的单个模块规划至不同的装饰器类中，各装饰器类独立自主，各司其职。客户端可以根据自己的需求自由搭配各种装饰器，每加一层装饰就会有新的特性体现出来，巧妙的设计让功能模块层层叠加，装饰之上套装饰，最终使原始对象的特性动态地得到增强。

关注公众号【waynblog】每周分享技术干货、开源项目、实战经验、国外优质文章翻译等，您的关注将是我的更新动力！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！