设计模式-责任链模式变体之管道模式

一.管道模式的定义

管道模式（Pipeline Pattern）是责任链模式（Chain of Responsibility Pattern）的常用变体之一。在管道模式中，管道扮演着流水线的角色，将数据传递到一个加工处理序列中，数据在每个步骤中被加工处理后，传递到下一个步骤进行加工处理，直到全部步骤处理完毕（比如电子厂里原材料通过流水线工人一个一个加工最后组装成一个完整的电子产品）。
注：责任链模式只有一个处理器会处理数据，而管道模式是多个处理器会处理

二.什么情况下使用管道模式

任务代码较为复杂，需求可拆分为多个子步骤，同时需求变更频繁，可能出现在任意位置添加新的子步骤、删除旧的子步骤、交换子步骤顺序，可以考虑使用管道模式。

三.使用管道模式的背景

最开始做发送律师函系统时，发送律师函的功能，包括：“输入数据校验 -> 根据输入创建律师函 -> 保存律师函到相关 DB 表”总共三个步骤，也不算复杂，所以当时的代码比较简单大概是这样的：

/*** 律师函* @author Administrator**/
@Service
public class LetterServiceImpl implements LetterService {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic void sendLetter(LetterRequest request) {// 校验数据validatedData(request);//创建律师函createLetter(request);//保存律师函saveLetter(request);}private void saveLetter(LetterRequest request) {logger.info("保存律师函");}private void createLetter(LetterRequest request) {logger.info("创建律师函");}private void validatedData(LetterRequest request) {logger.info("校验律师函数据");}}

然而好景不长，随着业务不断完善，这块业务逻辑也越来越复杂，律师函模板也增多了，每个模板对应的数据处理方式有一定的区别，同时也需要增加律师函文件电子签章，存储到电子存证平台，后期可能还会有其他一些需求增加比如发送短信，发送邮件等等，基于目前的情况，我们可以在代码里直接封装方法，这样的话暂时可以偷懒一下，但是后期这块逻辑步骤越来越多，对于代码的改动是很大的且不利于维护，因此为了不给自己后期挖坑，同时也为了代码的维护和后期观看决定把这块代码优化一下，优化时打算使用责任链模式，但是责任链模式是一个处理器对其进行处理，而这个是多个步骤的，因此想到了责任链模式之变体“管道模式”。
注：直接在源代码上进行修改或增加违背了面向对象的单一职责原则（一个类应该只发生一个变化）和开闭原则（对扩展开放，对修改关闭）

四.定义一个管道模板上下文

1.定义管道模板上下文用于处理器处理相应的模板

/*** 律师函管道模板上下文* @author Administrator**/
@Setter
@Getter
public class PipelineTemplateContext {/*** 模板名称*/private String templateName;/*** 获取类名称* @return*/public String getName() {return this.getClass().getSimpleName();}
}

五.构建管道处理器

1.创建一个管道处理器接口，定义一个方法处理数据

/*** 律师函管道处理器* @author Administrator**/
public interface LetterPipelineHandler<T extends PipelineTemplateContext> {/*** 管理处理器处理数据* @param request*/Boolean handler(PipelineTemplateContext context);
}

六.相关处理器具体实现

1.数据校验处理器

/*** 律师函数据校验处理器* @author Administrator**/
@Component
public class ValidatedDataLetterHandler implements LetterPipelineHandler<PipelineTemplateContext> {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(PipelineTemplateContext context) {logger.info("数据校验");if(context == null) {try {throw new Exception("数据不能为空");} catch (Exception e) {e.printStackTrace();}}return true;}}

2.表单输入数据处理

/*** 表单输入数据处理器* @author Administrator**/
@Component
public class FormDataLetterHandler implements LetterPipelineHandler<PipelineTemplateContext> {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(PipelineTemplateContext context) {logger.info("表单输入数据处理");return true;}}

3.创建律师函

/*** 创建律师函* @author Administrator**/
@Component
public class createLetterHandler implements LetterPipelineHandler<PipelineTemplateContext> {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(PipelineTemplateContext context) {logger.info("创建律师函");return true;}}

4.电子签章

/*** 电子签章处理器* @author Administrator**/
@Component
public class SignLetterHandler implements LetterPipelineHandler<PipelineTemplateContext> {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(PipelineTemplateContext context) {logger.info("律师函进行电子签章");return true;}}

5.电子存证

/*** 电子存证处理器* @author Administrator**/
@Component
public class DepositCertificateLetterHandler implements LetterPipelineHandler<PipelineTemplateContext> {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(PipelineTemplateContext context) {logger.info("律师函存证");return true;}}

6.保存律师函

/*** 保存律师函处理器* @author Administrator**/
@Component
public class SaveLetterHandler implements LetterPipelineHandler<PipelineTemplateContext>{private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(PipelineTemplateContext context) {logger.info("保存律师函");return true;}}

七.构建管道上下文和处理器映射关系

管理处理器和管道上下文都定义好了，此时需要把这两个联系起来，在责任链模式中，通常是在处理器中定义下一个处理器，这种方法不能总览全部处理器代码，为了便于总览全部处理器，此时可以通过定义一个路由表来把上下文和处理器想关联起来，路由表里定义一个map，map的key使用PipelineTemplateContext，value 使用一个list集合，集合里存放着处理该上下文的所有处理器，有一个缺点就是如果增加了新的步骤需要在路由表里新增一下。

1.构建路由表

/*** 律师函路由表配置* @author Administrator**/
@Configuration
public class LetterPipelineRouteConfig implements ApplicationContextAware{private ApplicationContext applicationContext;private final static Map<Class<? extends PipelineTemplateContext>,List<Class<? extends LetterPipelineHandler<? extends PipelineTemplateContext>>>> LETTE_RPIPELINE_ROUTE_MAP= new HashMap<>();/*** 系统启动就创建管道上下文与管道处理器映射关系，后续有其他新增或者是删除的处理器可以在此处修改即可*/static {LETTE_RPIPELINE_ROUTE_MAP.put(CommonTemplateContext.class, Arrays.asList(ValidatedDataLetterHandler.class,FormDataLetterHandler.class,createLetterHandler.class,SignLetterHandler.class,DepositCertificateLetterHandler.class,SaveLetterHandler.class));}@Bean("letterPipelineRouteMap")public Map<Class<? extends PipelineTemplateContext>,List<? extends LetterPipelineHandler<? extends PipelineTemplateContext>>> letterPipelineRouteMap(){return LETTE_RPIPELINE_ROUTE_MAP.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, this::toPipeline));}/*** 根据给定的管道中 LetterPipelineHandler 的类型的列表，构建管道*/private List<? extends LetterPipelineHandler<? extends PipelineTemplateContext>> toPipeline(Map.Entry<Class<? extends PipelineTemplateContext>, List<Class<? extends LetterPipelineHandler<? extends PipelineTemplateContext>>>> entry) {return entry.getValue().stream().map(applicationContext::getBean).collect(Collectors.toList());}@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException {this.applicationContext = applicationContext;}}

八.构建管道执行器

构建管道执行器。管道执行器根据传入的上下文数据的类型，找到其对应的管道，然后将上下文数据放入管道中去进行处理。

/*** 律师函管道执行器* @author Administrator**/
@Component
public class LetterPipelineExecutor {private final Logger logger = LoggerFactory.getLogger(this.getClass());/*** 引用 LetterPipelineRouteConfig 中的 letterPipelineRouteMap*/@Autowiredprivate Map<Class<? extends PipelineTemplateContext>,List<? extends LetterPipelineHandler<? super PipelineTemplateContext>>> letterPipelineRouteMap;/***   请记住PECS原则：生产者（Producer）使用extends，消费者（Consumer）使用super。生产者使用extends如果你需要一个列表提供T类型的元素（即你想从列表中读取T类型的元素），你需要把这个列表声明成<? extends T>，比如List<? extends Integer>，因此你不能往该列表中添加任何元素。消费者使用super如果需要一个列表使用T类型的元素（即你想把T类型的元素加入到列表中），你需要把这个列表声明成<? super T>，比如List<? super Integer>，因此你不能保证从中读取到的元素的类型。即是生产者，也是消费者如果一个列表即要生产，又要消费，你不能使用泛型通配符声明列表，比如List<Integer>。注意 ？ extends T 与 ？super T  的用法* @param context*/public void executor(PipelineTemplateContext context) {if(context == null) {try {logger.info("参数不能为空");throw new Exception("参数不能为空");} catch (Exception e) {e.printStackTrace();}}Class<? extends PipelineTemplateContext> dataType = context.getClass();Boolean flag = true;List<? extends LetterPipelineHandler<? super PipelineTemplateContext>> pipelineList = letterPipelineRouteMap.get(dataType);if(!CollectionUtils.isEmpty(pipelineList)) {for (LetterPipelineHandler<? super PipelineTemplateContext> handler : pipelineList) {flag = handler.handler(context);if(flag) {break;}}}}}

九.流程代码

1.service层代码

/*** 律师函* @author Administrator**/
public interface LetterService {void sendLetter(LetterRequest request);
}

2.service实现层代码


/*** 律师函* @author Administrator**/
@Service
public class LetterServiceImpl implements LetterService {private Logger logger = LoggerFactory.getLogger(this.getClass());@Autowiredprivate LetterPipelineExecutor letterPipelineExecutor;@Overridepublic void sendLetter(LetterRequest request) {logger.info("律师函业务逻辑层");CommonTemplateContext  context= convert(request);letterPipelineExecutor.executor(context);}private CommonTemplateContext convert(LetterRequest request) {CommonTemplateContext context = new CommonTemplateContext();context.setUserId(request.getUserId());context.setFormInput(request.getFormInput());context.setTemplateName(request.getModelName());return context;}}

十.测试与结果

1.编写简单的controller层代码

@RestController
public class LetterController {@Autowiredprivate LetterService letterService;@PostMapping("letter/settel")public String settel(LetterRequest request) {letterService.sendLetter(request);return "成功";}
}

2.postman测试用例

3.测试结果

十一.扩展

1.可以设想又增加了一些逻辑，比如创建完成以后给用户发送短信，律师函发送短信处理器代码如下

/*** 发送短信通知处理器* @author Administrator**/
@Component
public class SendMsgLetterHandler implements LetterPipelineHandler<CommonTemplateContext> {private Logger logger = LoggerFactory.getLogger(this.getClass());@Overridepublic Boolean handler(CommonTemplateContext context) {logger.info("发送短息通知用户");return true;}}

2.同时也要在路由表那儿把此处理器添加到对应的位置如下图：

3.测试结果，通过下图发现比上一个测试多了一句话，说明成功了，业务逻辑代码没有任何改动，只是在路由表中增加了一个处理器，代码有很好的扩展性。