Java进阶篇设计模式之八 - 责任链模式和命令模式
前言
在上一篇中我们学习了结构型模式的享元模式和代理模式。本篇则来学习下行为型模式的两个模式, 责任链模式(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的子类可以非常容易地扩展。
命令模式缺点:
如果命令过多的话,会增加系统的复杂度 。
使用场景:
如果在有类似
命令
需要指定的,就可以用命令模式,比如记录日志、撤销操作命令等。