Java进阶篇设计模式之八 ----- 责任链模式和命令模式

素颜马尾好姑娘i 2022-05-07 03:48 194阅读 0赞

## 前言 ##

在[上一篇][Link 1]中我们学习了结构型模式的享元模式和代理模式。本篇则来学习下行为型模式的两个模式， 责任链模式(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的子类可以非常容易地扩展。

**命令模式缺点：**

> 如果命令过多的话，会增加系统的复杂度 。

**使用场景：**

> 如果在有类似`命令`需要指定的，就可以用命令模式，比如记录日志、撤销操作命令等。

## 其它 ##

### 音乐推荐 ###

分享一首很轻快的轻音乐！

border="0" width="330" height="86" src="//music.163.com/outchain/player?type=2&id=5330830&auto=0&height=66">

### 项目的代码 ###

[java-study ][java-study]是本人在学习Java过程中记录的一些代码，也包括之前博文中使用的代码。如果感觉不错，希望顺手给个start，当然如果有不足，也希望提出。  
github地址: [https://github.com/xuwujing/java-study][java-study]

原创不易，如果感觉不错，希望给个推荐！您的支持是我写作的最大动力！  
版权声明:  
作者：虚无境  
博客园出处：[http://www.cnblogs.com/xuwujing][http_www.cnblogs.com_xuwujing]  
CSDN出处：[http://blog.csdn.net/qazwsxpcm][http_blog.csdn.net_qazwsxpcm]　  
个人博客出处：[http://www.panchengming.com][http_www.panchengming.com]

[Link 1]: https://www.cnblogs.com/xuwujing/p/9704228.html
[java-study]: https://github.com/xuwujing/java-study
[http_www.cnblogs.com_xuwujing]: http://www.cnblogs.com/xuwujing
[http_blog.csdn.net_qazwsxpcm]: http://blog.csdn.net/qazwsxpcm
[http_www.panchengming.com]: http://www.panchengming.com