聊一聊装饰者模式

是你，还是你，一切都有你！—— 装饰者模式

一、概述

装饰者模式（Decorator Pattern）允许向一个现有的对象扩展新的功能，同时不改变其结构。主要解决直接继承下因功能的不断横向扩展导致子类膨胀的问题，无需考虑子类的维护。
装饰者模式有4种角色：

• 抽象构件角色（Component）：具体构件类和抽象装饰者类的共同父类。
  
• 具体构件角色（ConcreteComponent）：抽象构件的子类，装饰者类可以给它增加额外的职责。
  
• 装饰角色（Decorator）：抽象构件的子类，具体装饰类的父类，用于给具体构件增加职责，但在子类中实现。
  
• 具体装饰角色（ConcreteDecorator）：具体装饰类，定义了一些新的行为，向构件类添加新的特性。
  
  

二、入门案例

2.1、类图


2.2、基础类介绍

1. // 抽象构件角色
2. public interface Component {
4.     void doSomeThing();
5. }
7. // 具体构件角色
8. public class ConcreteComponent implements Component {
10.     @Override
11.     public void doSomeThing() {
12.         System.out.println("处理业务逻辑");
13.     }
14. }
16. // 装饰者类
17. public abstract class Decorator implements Component {
19.     private Component component;
21.     public Decorator(Component component) {
22.         this.component = component;
23.     }
25.     @Override
26.     public void doSomeThing() {
27.         // 调用处理业务逻辑
28.         component.doSomeThing();
29.     }
30. }
32. // 具体装饰类
33. public class ConcreteDecorator extends Decorator {
35.     public ConcreteDecorator(Component component) {
36.         super(component);
37.     }
39.     @Override
40.     public void doSomeThing() {
41.         System.out.println("业务逻辑功能扩展");
42.         super.doSomeThing();
43.     }
44. }

复制代码

当然，如果需要扩展更多功能的话，可以再定义其他的ConcreteDecorator类，实现其他的扩展功能。
如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。
三、应用场景

如风之前在一家保险公司干过一段时间。其中保险业务员也会在自家产品注册账号，进行推销。不过在这之前，他们需要经过培训，导入一张展业资格证书。然后再去推销保险产品供用户下单，自己则通过推销产生的业绩，参与分润，拿对应的佣金。
对于上面导证书这个场景，实际上是会根据不同的保险产品，导入不同的证书的。并且证书的类型也不同，对应的解析、校验、执行的业务场景都是不同的。如何去实现呢？当然if-else确实也是一种不错的选择。下面放一段伪代码

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022/11/17 11:32
5. * @description
6. */
7. @RestController
8. @RequestMapping("/certificate")
9. public class CertificateController {
11.     @Resource
12.     private CommonCertificateService certificateService;
14.     @PostMapping("/import")
15.     public Result<Integer> importFile(@RequestParam MultipartFile file, @RequestParam String productCode) {
16.         return Result.success(certificateService.importCertificate(file, productCode));
17.     }
18. }
20. /**
21. * @author 往事如风
22. * @version 1.0
23. * @date 2022/11/17 13:25
24. * @description
25. */
26. @Service
27. public class CommonCertificateService {
29.     public Integer importCertificate(MultipartFile file, String productCode) {
30.         // 1、参数非空校验
31.         // 2、通过file后缀判断file类型，支持excel和pdf
32.         // 3、解析file文件，获取数据，统一封装到定义的CertificatePojo类中
33.         // 4、根据产品类型判断导入之前的业务逻辑
34.         if (productCode.equals(DecorateConstants.PRODUCT_A)) {
35.             // 重新计算业绩逻辑
36.             // 重新算业绩类型逻辑
37.             // 一坨坨代码去实现....
38.         }
39.         else if (productCode.equals(DecorateConstants.PRODUCT_B)) {
40.             // 导入证书的代理人自己以及上级身份晋升逻辑
41.             // 业绩计算逻辑
42.             // 一坨坨代码去实现...
43.         } else if (productCode.equals(DecorateConstants.PRODUCT_C)) {
44.             // c产品下的业务逻辑
45.             // 一坨坨代码去实现...
46.         } else {
47.             // 默认的处理逻辑
48.             // 一坨坨代码去实现...
49.         }
50.         // 5、证书数据保存
51.         // 6、代理人信息保存
52.         // 7、相关流水数据保存
53.         // 返回代理人id
54.         Integer agentId = Integer.MAX_VALUE;
55.         return agentId;
56.     }
57. }

复制代码

从上面的伪代码看到，所有的业务逻辑是在一起处理的，通过productCode去处理对应产品的相关逻辑。这么一看，好像也没毛病，但是还是被技术大佬给否决了。好吧，如风决定重写。运用装饰者模式，重新处理下了下这段代码。
1、一切再从注解出发，自定义Decorate注解，这里定义2个属性，scene和type

• scene：标记具体的业务场景
  
• type：表示在该种业务场景下，定义一种具体的装饰器类
  

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022/11/8 17:44
5. * @description
6. */
7. @Target({ElementType.TYPE})
8. @Retention(RetentionPolicy.RUNTIME)
9. @Documented
10. @Inherited
11. @Service
12. public @interface Decorate {
13.      /**
14.       * 具体的业务场景
15.       * @return
16.       */
17.      String scene();
18.      /**
19.       * 类型:不同业务场景下，不同的装饰器类型
20.       * @return
21.       */
22.      String type();
23. }

复制代码

2、抽象构件接口，BaseHandler，这个是必须滴

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022/11/8 17:07
5. * @description 抽象处理接口
6. */
7. public interface BaseHandler<T, R> {
8.     /**
9.      * 统一的处理方法
10.      * @param t
11.      * @return
12.      */
13.     R handle(T t);
14. }

复制代码

3、抽象装饰器类，AbstractHandler，持有一个被装饰类的引用，这个引用具体在运行时被指定

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022-11-13 22:10:05
5. * @desc 抽象父类
6. */
7. public abstract class AbstractHandler<T, R> implements BaseHandler<T, R> {
8.     protected BaseHandler service;
10.     public void setService(BaseHandler service) {
11.         this.service = service;
12.     }
13. }

复制代码

4、具体的装饰器类AProductServiceDecorate，主要负责处理“导师证书”这个业务场景下，A产品相关的导入逻辑，并且标记了自定义注解Decorate，表示该类是装饰器类。主要负责对A产品证书导入之前逻辑的增强，我们这里称之为“装饰”。

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022-11-13 23:11:16
5. * @desc
6. */
7. @Decorate(scene = SceneConstants.CERTIFICATE_IMPORT, type = DecorateConstants.PRODUCT_A)
8. public class AProductServiceDecorate extends AbstractHandler<MultipartFile, Integer> {
10.     /**
11.      * 重写父类处理数据方法
12.      * @param file
13.      * @return
14.      */
15.     @Override
16.     public Integer handle(MultipartFile file) {
17.         // 解析
18.         CertificatePojo data = parseData(file);
19.         // 校验
20.         check(data);
21.         // 业绩计算
22.         calAchievement(data.getMobile());
23.         return (Integer) service.handle(data);
24.     }
26.     public CertificatePojo parseData(MultipartFile file) {
27.         // file,证书解析
28.         System.out.println("A产品的证书解析......");
29.         CertificatePojo certificatePojo = new CertificatePojo();
30.         certificatePojo.setMobile("12323");
31.         certificatePojo.setName("张三");
32.         certificatePojo.setMemberNo("req_343242ds");
33.         certificatePojo.setEffectDate("2022-10-31:20:20:10");
34.         return certificatePojo;
35.     }
37.     /**
38.      * 证书数据校验
39.      * @param data
40.      */
41.     public void check(CertificatePojo data) {
42.         // 数据规范和重复性校验
43.         // .....
44.         System.out.println("A证书数据校验......");
45.     }
47.     /**
48.      * 计算业绩信息
49.      */
50.     private void calAchievement(String mobile) {
51.         System.out.println("查询用户信息, 手机号：" + mobile);
52.         System.out.println("重新计算业绩...");
53.     }
54. }

复制代码

当然，还是其他装饰类，BProductServiceDecorate，CProductServiceDecorate等等，负责装饰其他产品，这里就不举例了。
5、当然还有管理装饰器类的装饰器类管理器DecorateManager，内部维护一个map，负责存放具体的装饰器类

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022/11/15 17:18
5. * @description 装饰管理器
6. */
7. public class DecorateManager {
9.     /**
10.      * 用于存放装饰器类
11.      */
12.     private Map<String, AbstractHandler> decorateHandleMap = new HashMap<>();
14.     /**
15.      * 将具体装饰器类放在map中
16.      *
17.      * @param handlerList
18.      */
19.     public void setDecorateHandler(List<AbstractHandler> handlerList) {
20.         for (AbstractHandler h : handlerList) {
21.             Decorate annotation = AnnotationUtils.findAnnotation(h.getClass(), Decorate.class);
22.             decorateHandleMap.put(createKey(annotation.scene(), annotation.type()), h);
23.         }
24.     }
26.     /**
27.      * 返回具体的装饰器类
28.      *
29.      * @param type
30.      * @return
31.      */
32.     public AbstractHandler selectHandler(String scene, String type) {
33.         String key = createKey(scene, type);
34.         return decorateHandleMap.get(key);
35.     }
37.     /**
38.      * 拼接map的key
39.      * @param scene
40.      * @param type
41.      * @return
42.      */
43.     private String createKey(String scene, String type) {
44.         return StrUtil.builder().append(scene).append(":").append(type).toString();
45.     }
46. }

复制代码

6、用了springboot，当然需要将这个管理器交给spring的bean容器去管理，需要创建一个配置类DecorateAutoConfiguration

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022-11-12 19:22:41
5. * @desc
6. */
7. @Configuration
8. public class DecorateAutoConfiguration {
10.     @Bean
11.     public DecorateManager handleDecorate(List<AbstractHandler> handlers) {
12.         DecorateManager manager = new DecorateManager();
13.         manager.setDecorateHandler(handlers);
14.         return manager;
15.     }
16. }

复制代码

7、被装饰的service类，CertificateService，只需要关注自己的核心逻辑就可以

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022/11/8 17:10
5. * @description 执行证书导入的service
6. */
7. @Service
8. public class CertificateService implements BaseHandler<CertificatePojo, Integer> {
10.     /**
11.      * 处理导入证书的核心逻辑service
12.      * @param certificate
13.      * @return
14.      */
15.     @Override
16.     public Integer handle(CertificatePojo certificate) {
17.         System.out.println("核心业务,证书数据:" + JSONUtil.toJsonStr(certificate));
18.         // 1、证书数据保存
19.         // 2、代理人信息保存
20.         // 3、相关流水数据保存
21.         // 其他的一些列核心操作
22.         Integer agentId = Integer.MAX_VALUE;
23.         // 返回代理人id
24.         return agentId;
25.     }
26. }

复制代码

8、在原来的controller中，注入管理器类DecorateManager去调用，以及service，也就是被装饰的类。首先拿到装饰器，然后再通过setService方法，传入被装饰的service。也就是具体装饰什么类，需要在运行时才确定。

1. /**
2. * @author 往事如风
3. * @version 1.0
4. * @date 2022-11-13 23:30:37
5. * @desc
6. */
7. @RestController
8. public class WebController {
10.     @Resource
11.     private DecorateManager decorateManager;
13.     @Resource
14.     private CertificateService certificateService;
16.     @PostMapping("/import")
17.     public Result importFile(@RequestParam MultipartFile file, @RequestParam String productCode) {
18.         AbstractHandler handler = decorateManager.selectHandler(SceneConstants.CERTIFICATE_IMPORT, productCode);
19.         if (Objects.isNull(handler)) {
20.             return Result.fail();
21.         }
22.         handler.setService(certificateService);
23.         return Result.success(handler.handle(file));
24.     }
25. }

复制代码

下面模拟下代理人导入证书的流程，当选择A产品，productCode传A过来，后端的处理流程。

• 对于A产品下，证书的解析，A产品传的是excel
  
• 然后数据校验，这个产品下，特有的数据校验
  
• 最后是核心的业绩重算，只有A产品才会有这个逻辑
  

当选择B产品，productCode传A过来，后端的处理流程。

• 对于B产品下，证书的解析，A产品传的是pdf
  
• 然后数据校验，跟A产品也不同，多了xxx步骤
  
• 核心是代理人的晋升处理，这部分是B产品独有的
  

最后说一句，既然都用springboot了，这块可以写一个starter，做一个公用的装饰器模式。如果哪个服务需要用到，依赖这个装饰器的starter，然后标记Decorate注解，定义对应的scene和type属性，就可以直接使用了。
四、源码中运用

4.1、JDK源码中的运用

来看下IO流中，InputStream、FilterInputStream、FileInputStream、BufferedInputStream的一段代码
[code]public abstract class InputStream implements Closeable {    public abstract int read() throws IOException;    public int read(byte b[], int off, int len) throws IOException {        if (b == null) {            throw new NullPointerException();        } else if (off < 0 || len < 0 || len > b.length - off) {            throw new IndexOutOfBoundsException();        } else if (len == 0) {            return 0;        }        int c = read();        if (c == -1) {            return -1;        }        b[off] = (byte)c;        int i = 1;        try {            for (; i < len ; i++) {                c = read();                if (c == -1) {                    break;                }                b[off + i] = (byte)c;            }        } catch (IOException ee) {        }        return i;    }}//--------------------------public class FilterInputStream extends InputStream {       protected FilterInputStream(InputStream in) {        this.in = in;    }    public int read() throws IOException {        return in.read();    }}//--------------------------public class BufferedInputStream extends FilterInputStream {    public BufferedInputStream(InputStream in, int size) {        super(in);        if (size