概要:
该文章参考了《设计模式之禅》一书及一些前辈的博客文章
1.该文章阐述了责任链模式的基础原理及示例代码;
2.该文章适合初学设计模式的技术人员研习;
3.该文章有许多不足之处,请各位大咖指正,喷子绕道;
正文:
责任链模式:使多个对象都有机会处理请求,从而避免请求的发送者和接收者之前的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。
1.责任链模式示例代码实现:
package com.csdn;
/*
* 员工抽象类
*/
public interface Employee {
//获取申报级别
public int getType();
//获取申报事项
public String getRequest();
}
package com.csdn;
/**
* 员工汤姆
* @author Administrator
*
*/
public class Tom implements Employee {
//汤姆的申报级别
private int type = 0;
//汤姆的申报事项
private String request;
//构造函数传递求情
public Tom(int _request){
//申报事项为请假?天
this.request = "Tom提交请假申请,请假天数是"+_request+"天";
//如果是请假1~3天,申报级别为3(对应主管)
if(_request > 0 && _request < 4){
type = 3;
//如果是请假4~7天,申报级别为2(对应经理)
}else if(_request > 3 && _request < 8){
type = 2;
//如果是请假7天以上,申报级别为1(对应董事长)
}else if(_request > 7){
type = 1;
}
}
//获得自己的申报级别
@Override
public int getType() {
return this.type;
}
//获取自己的申报事项
@Override
public String getRequest() {
return this.request;
}
}
package com.csdn;
/**
* Handler类,处理逻辑关系
* @author Administrator
*
*/
public abstract class Handler {
//3个汇报等级
public final static int CHARGE_LEVEL_REQUEST = 3;
public final static int MANAGER_LEVEL_REQUEST = 2;
public final static int CHAIRMAN_LEVEL_REQUEST = 1;
//当前处理者等级
private int level = 0;
//当前处理者的下级处理者
private Handler nextHandler;
public Handler(int _level){
this.level = _level;
}
//责任链模式主要实现方法
public final void HandleMessage(Employee employee){
//判断用户的申报等级是否跟当前处理者等级一致
//如果一致,处理者处理请求并提交给用户返回值
if(employee.getType() == this.level){
this.response(employee);
//如果不一致,请求交给下一级处理者处理
}else{
//如果下一级处理者不为空
if(this.nextHandler != null){
//因为该模拟场景是请假申请,一般需要逐级审批同意,一般的责任链模式无此处理
this.response(employee);
//转到下一级处理者处理请求,递归
this.nextHandler.HandleMessage(employee);
}else{
System.out.println("没有上级可以请示了,作不同意处理");
}
}
}
//传入下级处理者是谁
public void setNext(Handler _handler){
this.nextHandler = _handler;
}
//每级处理者处理后做出的响应
protected abstract void response(Employee employee);
}
package com.csdn;
/**
* 主管类
* @author Administrator
*
*/
public class Charge extends Handler{
//主管等级为3,下一级是经理
public Charge() {
super(Handler.CHARGE_LEVEL_REQUEST);
super.setNext(new Manager());
}
//主管的具体回复
@Override
protected void response(Employee employee) {
System.out.println("-----Tom向主管请示-----");
System.out.println(employee.getRequest());
System.out.println("主管表示同意");
}
}
package com.csdn;
/**
* 经理类
* @author Administrator
*
*/
public class Manager extends Handler{
//经理等级为2,下一级是董事长
public Manager() {
super(Handler.MANAGER_LEVEL_REQUEST);
super.setNext(new Chairman());
}
//经理的具体回复
@Override
protected void response(Employee employee) {
System.out.println("-----Tom向经理请示-----");
System.out.println(employee.getRequest());
System.out.println("经理表示同意");
}
}
package com.csdn;
/**
* 董事长类
* @author Administrator
*
*/
public class Chairman extends Handler{
//董事长等级为1,无下一级
public Chairman() {
super(Handler.CHAIRMAN_LEVEL_REQUEST);
}
//董事长的具体回复
@Override
protected void response(Employee employee) {
System.out.println("-----Tom向董事长请示-----");
System.out.println(employee.getRequest());
System.out.println("董事长表示同意");
}
}
package com.csdn;
/**
* 场景模拟
* @author Administrator
*
*/
public class Client {
public static void main(String[] args) {
//汤姆想请假12天(12天需要主管、经理、董事长都批准)
Tom tom = new Tom(12);
//汤姆的主管出现了
Handler charge = new Charge();
//主管收到汤姆的请求并开始处理
charge.HandleMessage(tom);
}
}
输出:
-----Tom向主管请示-----
Tom提交请假申请,请假天数是12天
主管表示同意
-----Tom向经理请示-----
Tom提交请假申请,请假天数是12天
经理表示同意
-----Tom向董事长请示-----
Tom提交请假申请,请假天数是12天
董事长表示同意
注:
a:该示例模拟了员工的请假审批流,请假天数越多,在这个审批链中需要做出响应的人越多。在很多情况下,责任链模式只是要求从开始沿着这个“链”找出一个请求对应的处理人,不需要经过的每一级都做出处理。
b:责任链模式屏蔽了请求的处理过程,发起一个请求到底是谁处理的,这个你不用关心,只要你把请求抛给责任链的第一个处理者,最终会返回一个处理结果,作为请求者可以不用知道到底是谁处理的,这是责任链模式的核心。
2.通用责任链模式模板代码实现:
package com.csdn;
//抽象处理者
public abstract class Handler {
private Handler nextHandler;
//每个处理者都必须对请求作出处理
public final Response handleMessage(Request request){
Response response = null;
//判断是否是自己的处理级别
if(this.getHandlerLevel().equals(request.getRequsetLevel())){
response = this.echo(request);
}else{
//判断是否有下一个处理着
if(this.nextHandler != null){
response = this.nextHandler.handleMessage(request);
}else{
//没有适当的处理者,业务自行处理
}
}
return response;
}
//设置下一个处理者是谁
public void setNext(Handler _handler){
this.nextHandler = _handler;
}
//每个处理者都有一个处理级别
protected abstract Level getHandlerLevel();
//每个处理者都必须实现处理任务
protected abstract Response echo(Request request);
}
//模式中有关框架代码
class Level{
//定义一个请求和处理等级
}
class Request{
//请求的等级
public Level getRequsetLevel(){
return null;
}
}
class Response{
//处理者返回的数据
}
package com.csdn;
//具体处理者
public class ConcreteHandler1 extends Handler{
//定义自身处理逻辑
@Override
protected Level getHandlerLevel() {
return null;
}
//设置自己处理级别
@Override
protected Response echo(Request request) {
return null;
}
}
package com.csdn;
//具体处理者
public class ConcreteHandler2 extends Handler{
//定义自身处理逻辑
@Override
protected Level getHandlerLevel() {
return null;
}
//设置自己处理级别
@Override
protected Response echo(Request request) {
return null;
}
}
package com.csdn;
//具体处理者
public class ConcreteHandler3 extends Handler{
//定义自身处理逻辑
@Override
protected Level getHandlerLevel() {
return null;
}
//设置自己处理级别
@Override
protected Response echo(Request request) {
return null;
}
}
package com.csdn;
//场景模拟
public class Client {
public static void main(String[] args) {
//声明所有的处理节点
Handler handler1 = new ConcreteHandler1();
Handler handler2 = new ConcreteHandler2();
Handler handler3 = new ConcreteHandler3();
//设置链中阶段顺序1--2--3
handler1.setNext(handler2);
handler2.setNext(handler3);
//提交请求返回结果
Response response = handler1.handleMessage(new Request());
}
}
注:
a:在示例和通用模板中Handler是抽象类,融合了模板方法模式,每个实现类只要实现两个方法