责任链模式——学生请假

分类：设计模式作者：佚名

一模式定义

在责任链模式中，很多对象由每一个对象对其下家的引用而连接起来，形成一条链。客户端应用请求在这个链上进行传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪个对象最终处理这个请求，这使系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

(1)抽象处理者角色：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法，以设定和返回下家的引用。这个角色通常由一个Java抽象类或Java接口实现。

(2)具体处理角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。

二模式举例

1模式分析

我们借用学生请假来说明这一模式


2责任链模式静态类图


3代码示例

3.1学生接口一IStudent

package com.demo.chain.message;

/**
 * 学生接口
 * 
 * @author
 * 
 */
public interface IStudent {
	/**
	 * 获得学生病情状态
	 * 
	 * 0：小事（班长就可以处理）
	 * 
	 * 1：班长处理不了 老师能处理的事
	 * 
	 * 2：老师处理不了 校长能处理的事
	 * 
	 * 
	 */
	public int getState();

	/**
	 * 获得学生请假消息
	 * 
	 * @return
	 */
	public String getRequestMessage();
}

3.2学生实现一Student

package com.demo.chain.message;

/**
 * 学生实现类
 * 
 * @author
 * 
 */
public class Student implements IStudent {

	// 病情的大小状态
	private int state = -1;
	// 请假消息
	private final String message;

	public Student(int state,String message) {
		this.state = state;
		this.message = message;
	}

	/**
	 * 获得学生请假状态
	 * 
	 * 0：小事（班长就可以处理）
	 * 
	 * 1：班长处理不了 老师能处理的事
	 * 
	 * 2：老师处理不了 校长能处理的事
	 * 
	 * 
	 */
	public int getState() {
		return this.state;
	}

	/**
	 * 获得学生请假消息
	 * 
	 * @return
	 */
	public String getRequestMessage() {
		return this.message;
	}

}

3.3抽象处理接口一IHandler

package com.demo.chain.handle;

import com.demo.chain.message.IStudent;

/**
 * 抽象处理者接口
 * 
 * @author
 * 
 */
public interface IHandler {
	// 处理请求
	public void handleRequest(IStudent student);

	// 设置下一个处理者
	public void setHandler(IHandler handler);
}

3.4抽象处理者一AbstractHandler

package com.demo.chain.handle;

import com.demo.chain.message.IStudent;

/**
 * 抽象处理者
 * 
 * @author
 * 
 */
public abstract class AbstractHandler implements IHandler {
	// 下一个处理者
	private IHandler handler;
	// 请假级别
	private int state = -1;

	// 构造方法 设置级别
	public AbstractHandler(int state) {
		this.state = state;
	}

	// 处理请求 交由子类负责进行具体的处理
	public abstract void process(IStudent student);

	// 处理请求
	public void handleRequest(IStudent student) {
		// 如果学生对象存在
		if (student != null) {
			if (this.state == student.getState()) {
				// 如果请假级别和当前一致 则当前对象进行处理
				this.process(student);
			} else {

				if (this.handler != null) {
					System.out.println("请求上级领导批复！");
					// 如果当前对象处理不了 则交给下一个处理者进行处理
					this.handler.handleRequest(student);
				}
			}
		}
	}

	// 设置下一个处理者
	public void setHandler(IHandler handler) {
		this.handler = handler;
	}

}

3.5班长一squadleaderHandler

package com.demo.chain.handle;

import com.demo.chain.message.IStudent;

/**
 * 抽象处理者
 * 
 * @author
 * 
 */
public abstract class AbstractHandler implements IHandler {
	// 下一个处理者
	private IHandler handler;
	// 请假级别
	private int state = -1;

	// 构造方法 设置级别
	public AbstractHandler(int state) {
		this.state = state;
	}

	// 处理请求 交由子类负责进行具体的处理
	public abstract void process(IStudent student);

	// 处理请求
	public void handleRequest(IStudent student) {
		// 如果学生对象存在
		if (student != null) {
			if (this.state == student.getState()) {
				// 如果请假级别和当前一致 则当前对象进行处理
				this.process(student);
			} else {

				if (this.handler != null) {
					System.out.println("请求上级领导批复！");
					// 如果当前对象处理不了 则交给下一个处理者进行处理
					this.handler.handleRequest(student);
				}
			}
		}
	}

	// 设置下一个处理者
	public void setHandler(IHandler handler) {
		this.handler = handler;
	}

}

3.6老师一TeacherHandler

package com.demo.chain.impl;

import com.demo.chain.handle.AbstractHandler;
import com.demo.chain.message.IStudent;

/**
 * 老师处理者
 * 
 * @author
 * 
 */
public class TeacherHandler extends AbstractHandler {

	public TeacherHandler() {
		super(1);
	}

	// 子类具体处理请求
	@Override
	public void process(IStudent student) {
		System.out.println("老师 批复：" + student.getRequestMessage());
	}

}

3.7校长一SchoolMasterHandler

package com.demo.chain.impl;

import com.demo.chain.handle.AbstractHandler;
import com.demo.chain.message.IStudent;

/**
 * 校长处理者
 * 
 * @author
 * 
 */
public class SchoolMasterHandler extends AbstractHandler {

	public SchoolMasterHandler() {
		super(2);
	}

	// 子类具体处理请求
	@Override
	public void process(IStudent student) {
		System.out.println("校长 批复：" + student.getRequestMessage());
	}
}

3.8外观类一ProcessHandler

package com.demo.chain.process;

import com.demo.chain.handle.IHandler;
import com.demo.chain.impl.SchoolMasterHandler;
import com.demo.chain.impl.squadleaderHandler;
import com.demo.chain.impl.TeacherHandler;
import com.demo.chain.message.IStudent;

/**
 * 设置责任链关联
 * 
 * @author
 * 
 */
public class ProcessHandler {

	// 班长处理者
	private final IHandler sqmshandler;
	// 老师处理者
	private final IHandler techhandler;
	// 校长处理者
	private final IHandler scmshandler;

	// 单例模式
	private static ProcessHandler processHandler = new ProcessHandler();

	/**
	 * 构造方法建立请假处理责任链
	 */
	private ProcessHandler() {
		// 创建处理对象
		// 班长
		this.sqmshandler = new squadleaderHandler();
		// 老师
		this.techhandler = new TeacherHandler();
		// 校长
		this.scmshandler = new SchoolMasterHandler();
		/**
		 * 建立责任链
		 */
		// 设置班长的下一个处理者：老师
		this.sqmshandler.setHandler(this.techhandler);
		// 设置老师的下一个处理者：校长
		this.techhandler.setHandler(this.scmshandler);

	}

	/**
	 * 获得单例对象实例
	 * 
	 * @return
	 */
	public static ProcessHandler getInstance() {
		return processHandler;
	}

	/**
	 * 发送请假请求
	 * 
	 * @param message
	 */
	public void sendMessage(IStudent student) {
		// 发送给第一个处理者：班长 处理
		this.sqmshandler.handleRequest(student);
	}
}

3.9客户端一Client

package com.demo;

import java.util.Random;

import com.demo.chain.message.IStudent;
import com.demo.chain.message.Student;
import com.demo.chain.process.ProcessHandler;

/**
 * 主应用程序
 * 
 * @author
 * 
 */
public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		// 获得外观对象
		ProcessHandler processHandler = ProcessHandler.getInstance();

		// 创建随机数对象 用来随机产生学生对象
		Random random = new Random();
		for (int i = 0; i < 3; i++) {
			// 获得随机数
			int radom = random.nextInt(3);
			IStudent student = new Student(radom,"学生" + i + "生病了，要请假！");
			System.out.println("#################################");
			// 处理消息
			processHandler.sendMessage(student);
			System.out.println("#################################\n");
		}

	}
}

4运行结果

#################################

请求上级领导批复！

请求上级领导批复！

校长 批复：学生0生病了，要请假！

#################################

#################################

请求上级领导批复！

请求上级领导批复！

校长 批复：学生1生病了，要请假！

#################################

#################################

班长 批复：学生2生病了，要请假！

#################################

三该模式设计原则

1"开-闭"原则

2单一职责原则

四使用场合

(1)有多个对象处理同一请求，具体由哪一个来处理还不确定，只有在运行时才确定哪个对象处理的情况。

(2)消息具有多个接收者，而接收对象又是不明确的情况。只需要向其中的一个对象发出消息，由其内部具体处理。

(3)同一消息的多个处理对象可能会动态增加或减少，需要动态地指定的情况。

五责任链模式静态类图

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

迭代器模式（Iterator）
迭代器模式（Iterator）迭代器模式（Iterator）[Cursor]意图：提供一种方法顺序访问一个聚合对象中的每个元素，而又不想暴露该对象的内部表示。应用：STL标准库迭代器实现、Java集合类型迭代器等模式结构：心得：迭代器模式的目的是在不获知集合对象内部细节的同时能对集合元素进行遍历操作
高性能IO模型浅析
高性能IO模型浅析服务器端编程经常需要构造高性能的IO模型，常见的IO模型有四种：（1）同步阻塞IO（BlockingIO）：即传统的IO模型。（2）同步非阻塞IO（Non-blockingIO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的N
策略模式（Strategy）
策略模式（Strategy）策略模式（Strategy）[Policy]意图：定义一系列算法，把他们封装起来，并且使他们可以相互替换，使算法可以独立于使用它的客户而变化。应用：排序的比较方法、封装针对类的不同的算法、消除条件判断、寄存器分配算法等。模式结构：心得：对对象（Context）的处理操作可
访问者模式（Visitor）
访问者模式（Visitor）访问者模式（Visitor）意图：表示一个作用于某对象结构中的各元素的操作，它使你在不改变各元素的类的前提下定义作用于这些元素的新操作。应用：作用于编译器语法树的语义分析算法。模式结构：心得：访问者模式是要解决对对象添加新的操作和功能时候，如何尽可能不修改对象的类的一种方
命令模式（Command）
命令模式（Command）命令模式（Command）[Action/Transaction]意图：将一个请求封装为一个对象，从而可用不同的请求对客户参数化。对请求排队或记录请求日志，以及支持可撤消的操作。应用：用户操作日志、撤销恢复操作。模式结构：心得：命令对象的抽象接口（Command）提供的两个
生成器模式（Builder）
生成器模式（Builder）生成器模式（Builder）意图：将一个对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。 应用：编译器词法分析器指导生成抽象语法树、构造迷宫等。模式结构：心得：和工厂模式不同的是，Builder模式需要详细的指导产品的生产。指导者（Director）使用C
设计模式学习心得
设计模式学习心得《设计模式：可复用面向对象软件的基础》一书以更贴近读者思维的角度描述了GOF的23个设计模式。按照书中介绍的每个设计模式的内容，结合网上搜集的资料，我将对设计模式的学习心得总结出来。网络上关于设计模式的资料和文章汗牛充栋，有些文章对设计模式介绍生动形象。但是我相信“一千个读者，一千个
工厂方法模式（Factory Method）
工厂方法模式（Factory Method）工厂方法模式（Factory Method）[Virtual Constructor]意图：定义一个用于创建对象的接口，让子类决定实例化哪一个类，使一个类的实力化延迟到子类。应用：多文档应用管理不同类型的文档。模式结构：心得：面对同一继承体系（Produc
单例模式（Singleton）
单例模式（Singleton）单例模式（Singleton）意图：保证一个类只有一个实例，并提供一个访问它的全局访问点。应用：Session或者控件的唯一示例等。模式结构：心得：单例模式应该是设计模式中最简单的结构了，它的目的很简单，就是保证自身的实例只有一份。实现这种目的的方式有很多，在Java中
装饰者模式（Decorator）
装饰者模式（Decorator）装饰者模式（Decorator）[Wrapper]意图：动态的给一个对象添加一些额外的职责，就增加功能来说，比生成子类更为灵活。应用：给GUI组件添加功能等。模式结构：心得：装饰器（Decorator）和被装饰的对象（ConcreteComponent）拥有统一的接口
抽象工厂模式（Abstract Factory）
抽象工厂模式（Abstract Factory）抽象工厂模式（Abstract Factory）[Kit]意图：提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。应用：用户界面工具包。模式结构：心得：工厂方法把生产产品的方式封装起来了，但是一个工厂只能生产一类对象，当一个工厂需要生
桥接模式（Bridge）
桥接模式（Bridge）桥接模式（Bridge）[Handle/Body]意图：将抽象部分与它的实现部分分离，使他们都可以独立的变化。应用：不同系统平台的Windows界面。模式结构：心得：用户所见类体系结构（Window派生）提供了一系列用户的高层操作的接口，但是这些接口的实现是基于具体的底层实现
适配器模式（Adapter）
适配器模式（Adapter）适配器模式（Adapter）[Wrapper]意图：将类的一个接口转换成用户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。应用：将图形类接口适配到用户界面组件类中。模式结构：心得：适配器模式一般应用在具有相似接口可复用的条件下。目标接口（Targ
组合模式（Composition）
组合模式（Composition）组合模式（Composition）意图：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。应用：组合图形、文件目录、GUI容器等。模式结构：心得： 用户（Client）通过抽象类（Component）提供的公用接口统一
原型模式（Prototype）
原型模式（Prototype）原型模式（Prototype）意图：用原型实例制定创建对象的种类，并且通过拷贝这些原型创建新的对象。应用：Java/C#中的Clonable和IClonable接口等。模式结构：心得：原型模式本质上就是对象的拷贝，使用对象拷贝代替对象创建的原因有很多。比如对象的初始化构
什么是设计模式？Design pattern--和生活结合更好理解
什么是设计模式一套被反复使用、多数人知晓的、经过分类编目的、代码 设计经验 的总结；使用设计模式是为了 可重用 代码、让代码 更容易 被他人理解、保证代码 可靠性；设计模式使代码编制  真正工程化；设计模式使软件工程的 基石脉络， 如同大厦的结构一样；并不直接用来完成代码的编写，而是 描述 在各种不同情况下，要怎么解决问题的一种方案；能使不稳定依赖于相对稳定、具体依赖于相对抽象，避免引
面向对象设计原则一——单一职责原则
单一职责原则定义（Single Responsibility Principle，SRP）一个对象应该只包含 单一的职责，并且该职责被完整地封装在一个类中。Every  Object should have  a single responsibility, and that responsibility should be entirely encapsulated by t
十分钟理解Java中的动态代理----强烈推荐
动态代理和CGLib代理分不清吗，看看这篇文章，写的非常好，强烈推荐。原文截图*************************************************************************************************************************原文文本************
适配器模式-让不兼容的接口得以适配
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以相互合作。
策略模式-定义一个算法族
策略模式定义了一系列算法族，并封装在类中，它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot