前言
在上一篇中我们学习了结构型模式的享元模式和代理模式. 本篇则来学习下行为型模式的两个模式, 责任链模式 (Chain of Responsibility Pattern) 和命令模式(Command Pattern).
责任链模式
简介
责任链模式顾名思义, 就是为请求创建了一个接收者对象的链. 这种模式给予请求的类型, 对请求的发送者和接收者进行解耦. 这种类型的设计模式属于行为型模式. 在这种模式中, 通常每个接收者都包含对另一个接收者的引用. 如果一个对象不能处理该请求, 那么它会把相同的请求传给下一个接收者, 依此类推.
简单的理解的话就是进行层级处理. 生活中比较常见的是请假, 出差, 加薪等申请等等, 而工作中比较常见的就是拦截器和过滤器. 如果请假申请是用以前的那种方式, 发起者需要和每个负责人进行申请, 会比较麻烦, 但是现在一般是走 OA 流程, 只需发起一个 OA 申请即可. 这也是一种 这种就是典型的责任链模式, 发起者只需将请求请求发送到职责链上即可, 无需关心处理细节和请求的传递.
责任链模式主要由这三个角色组成, 请求接收者接口 (Handler), 请求实现者类(ConcreteHandler) 和请求发送者(Client).
请求接收者接口: 定义可以处理客户端请求事项的接口, 包含 "可链接下一个同样能处理请求" 的对象引用.
请求实现者类: 实现请求处理接口, 并判断对象本身是否能够处理本次请求, 如果不能完成请求, 则交由后继者来处理.
请求发送者: 将请求发送给第一个接收者对象, 并等待请求的回复.
这里为了方便理解, 我们使用一个简单的示例来加以说明.
在某公司的某个部门中, 为了活跃部门气氛, 主管便征求部门成员的意见, 于是部门的成员踊跃提出建议, 最终, 主管采纳了 xuwujing 提倡的建议, 并将此建议进行上报, 申请活动经费.
那么我们便可以根据这里例子来使用责任链模式进行开发, 首先加速有三级的领导, 他们有个共同的特性, 就是可以处理各自级别的事情, 那么我们便可以定义一个领导的抽象类, 并定义一个抽象方法可以处理事情, 并设置一个级别的参数, 那么这个抽象类的代码如下:
- abstract class Learder{
- protected Learder learder;
- protected void setLearder(Learder learder){
- this.learder=learder;
- }
- protected Learder getLearder(){
- return learder;
- }
- abstract void handler(int level);
- }
定义好该抽象类之后, 我们需要设计不同的领导进行不同的处理, 但是这些领导需要有个处理的能力, 并且还要根据各自不同的权限进行处理, 如果能够处理, 到此流程就结束了, 否则无法处理则转交给上级进行处理.
那么代码如下:
- class Supervisor extends Learder{
- private String name;
- private String something;
- public Supervisor(String name,String something) {
- this.name=name;
- this.something=something;
- }
- @Override
- void handler(int level) {
- // 如果级别在自己的处理范围之内
- if(level>1){
- System.out.println("主管同意了"+name+"所述的 <"+something+"> 事情!");
- }else{
- System.out.println("主管未能处理"+name+"所述的 <"+something+"> 事情! 转交给上级!");
- getLearder().handler(level);
- }
- }
- }
- class BranchManager extends Learder{
- private String name;
- private String something;
- public BranchManager(String name,String something) {
- this.name=name;
- this.something=something;
- }
- @Override
- void handler(int level) {
- boolean flag=true;
- // 如果级别在自己的处理范围之内
- if(level>0){
- // 这就就直接设置同意了
- if(flag){
- System.out.println("部门经理同意了"+name+"所述的 <"+something+"> 事情!");
- }else{
- System.out.println("部门经理不同意"+name+"所述的 <"+something+"> 事情!");
- }
- }else{
- System.out.println("部门经理未能处理"+name+"所述的 <"+something+"> 事情! 转交给上级!");
- getLearder().handler(level);
- }
- }
- }
- class GeneralManager extends Learder{
- private String name;
- private String something;
- public GeneralManager(String name,String something) {
- this.name=name;
- this.something=something;
- }
- @Override
- void handler(int level) {
- boolean flag=false;
- // 如果级别在自己的处理范围之内
- if(level>-1){
- // 这就就直接设置不同意了
- if(flag){
- System.out.println("总经理同意了"+name+"所述的 <"+something+"> 事情!");
- }else{
- System.out.println("总经理不同意"+name+"所述的 <"+something+"> 事情!");
- }
- }else{
- System.out.println("总经理未能处理"+name+"所述的 <"+something+"> 事情! 转交给上级!");
- getLearder().handler(level);
- }
- }
- }
最后我们再来根据所需要走的流程来进行代码测试. 由于在编写请求类时, 我们并未指定谁是谁的上级, 所以这里我们需要指定上下级关系, 让流程能够走下去. 指定上级之后, 我们再来设置处理该事件的级别, 最后再来进行运行.
那么测试代码如下:
- public static void main(String[] args) {
- String name = "xuwujing";
- String something = "去聚餐";
- String something2 = "去旅游";
- Learder learder1 =new Supervisor(name, something);
- Learder learder2 =new BranchManager(name, something);
- Learder learder3 =new GeneralManager(name, something);
- learder1.setLearder(learder2);
- learder2.setLearder(learder3);
- learder1.handler(1);
- Learder learder4 =new Supervisor(name, something2);
- Learder learder5 =new BranchManager(name, something2);
- Learder learder6 =new GeneralManager(name, something2);
- learder4.setLearder(learder5);
- learder5.setLearder(learder6);
- learder4.handler(0);
- }
输出结果:
主管未能处理 xuwujing 所述的 <去聚餐> 事情! 转交给上级!
部门经理同意了 xuwujing 所述的 <去聚餐> 事情!
主管未能处理 xuwujing 所述的 <去旅游> 事情! 转交给上级!
部门经理未能处理 xuwujing 所述的 <去旅游> 事情! 转交给上级!
总经理不同意 xuwujing 所述的 <去旅游> 事情!
责任链模式优点:
耦合度低, 请求者和执行者并没有必然的联系;
灵活度高, 可以通过内部成员来进行更改它们执行的次序;
扩展性好, Handler 的子类扩展非常方便.
责任链模式缺点:
会在某程度上降低程序的性能, 设置不当的话可能会出现循环调用.
在链过长时, 会降低代码的阅读性以及增加代码的复杂度.
使用场景:
需要动态指定处理某一组请求时, 在不确定接受者的的情况下, 向多个对象发送请求时.
注意事项:
虽然责任链模式很灵活, 但是牺牲的是一定的性能, 因为责任链模式是层级处理, 在处理数据的有一定的延迟, 所所以需要低延迟的情况下, 不推荐使用责任链模式.
命令模式
简介
命令模式顾名思义, 是一种数据驱动的设计模式, 它属于行为型模式. 请求以命令的形式包裹在对象中, 并传给调用对象. 调用对象寻找可以处理该命令的合适的对象, 并把该命令传给相应的对象, 该对象执行命令.
也就是将一个请求封装成一个对象, 从而可以用不同的请求对客户进行参数化.
命令模式主要由这三个角色组成, 命令对象 (command), 命令执行对象(received) 和命令请求对象(invoker).
命令对象: 通过接口或抽象类声明实现的方法.
命令执行对象: 实现命令对象的方法, 并将一个接收者和动作进行绑定, 调用接收者相应的操作.
命令请求对象: 用于执行这个请求, 可以动态的对命令进行控制.
这里我们依旧用一个简单的示例来进行说明.
在某个学校中, 学生需要听从老师的命令, 比如老师可以让学生去打扫教室卫生, 去完成未做完的作业等等命令, 但是学生的时间有限, 只能在某个时间范围内完成某一件事情, 此时刚好有两个老师对学生 xuwujing 说出了命令, 李老师先让 xuwujing 在放学后打扫教室, 王老师让 xuwujing 在回家前把未做完的作业做完并交给他, 但是学校的门禁的时间有限, 于是 xuwujing 就只 打扫了教室, 然后开溜了...
那么根据这个示例, 我们可以使用命令模式来完成.
首先, 先定义一个学生类, 并指定该学生可以做的事情.
代码如下:
- class Student{
- void cleanClassRoom(String name){
- System.out.println(name+"开始打扫教室...");
- }
- void doHomeWork(String name){
- System.out.println(name+"开始做作业...");
- }
- }
然后定义一个 命令抽象类, 并设置执行的方法.
- abstract class Command{
- protected Student student;
- public Command(Student student){
- this.student = student;
- }
- abstract void execute(String name);
- }
继而再定义两个命令执行对象, 分别设置所需执行的命令.
- class LiTeacher extends Command{
- public LiTeacher(Student student) {
- super(student);
- }
- @Override
- void execute(String name) {
- student.cleanClassRoom(name);
- }
- }
- class WangTeacher extends Command{
- public WangTeacher(Student student) {
- super(student);
- }
- @Override
- void execute(String name) {
- student.doHomeWork(name);
- }
- }
最后再来定义一个命令请求对象, 用于执行该请求, 并对命令进行控制, 比如新增命令, 撤销命令和执行命令等等.
那么代码如下:
- class Invoker {
- private List<Command> commands = new ArrayList<Command>();
- public void setCommand(Command command) {
- if(commands.size()>0) {
- System.out.println("不执行 WangTeacher 的命令!");
- }else {
- commands.add(command);
- }
- }
- public void executeCommand(String name) {
- commands.forEach(command->{
- command.execute(name);
- });
- }
- public void undoCommand(Command command) {
- commands.remove(command);
- System.out.println("撤销该命令!");
- }
- }
最后再来进行代码的测试.
测试代码如下:
- public static void main(String[] args) {
- String name = "xuwujing";
- Student student = new Student();
- Command command1 = new LiTeacher(student);
- Command command2 = new WangTeacher(student);
- Invoker invoker =new Invoker();
- invoker.setCommand(command1);
- invoker.setCommand(command2);
- invoker.executeCommand(name);
- }
输出结果:
不执行 WangTeacher 的命令!
xuwujing 开始打扫教室...
命令模式优点:
耦合度低, 请求者和执行者并没有必然的联系;
扩展性好, Command 的子类可以非常容易地扩展.
命令模式缺点:
如果命令过多的话, 会增加系统的复杂度 .
使用场景:
如果在有类似命令需要指定的, 就可以用命令模式, 比如记录日志, 撤销操作命令等.
其它
音乐推荐
分享一首很轻快的轻音乐!
项目的代码
https://github.com/xuwujing/java-study 是本人在学习 Java 过程中记录的一些代码, 也包括之前博文中使用的代码. 如果感觉不错, 希望顺手给个 start, 当然如果有不足, 也希望提出.
GitHub 地址: https://github.com/xuwujing/java-study
原创不易, 如果感觉不错, 希望给个推荐! 您的支持是我写作的最大动力!
来源: https://www.cnblogs.com/xuwujing/p/9794886.html