对于责任链模式,顾名思义,就是像一条锁链一样一级一级的处理事务,就像我们在学校请假时,如果请一天的假,班主任批准就好,但是要请一周的假,班主任就管不了了,班主任要交给级部主任审批,当然你要请一个月的话只能一级级传到校长那里了,这就叫责任链,用这个例子大家应该就清楚了吧。 网络上的专业解释: 此模式为请求创建了一个接收者对象的链,此模式中,通常每个接收者都包含着另一个接收者的引用。如果该接收者不能处理此请求,就传给下一个接收者,以此类推。

实例:用责任链模式描述三级的请求传递。 以下是我画的类图:

java 责任链动态配置 java责任链模式实例_设计模式

以下是我针对实例所敲的代码:

1.创建请求者和接收者的等级接口

//等级设置
public interface Lever {
	//低
	int LOWER=1;
	//中
	int MIDDLE=2;
	//高
	int UPPER=3;
}

2.创建抽象请求者以及他的三个子类(用于传入不同等级的事件)

//抽象请求者
public abstract class RequestManager {
	//事情的名字
	private String thing;
	public RequestManager(String thing) {
		super();
		this.thing = thing;
	}
	//获取事情名称
	public String getThing() {
		return this.thing;
	}
	//获取此请求的等级
	protected abstract int getLever();
}

public class Request_1 extends RequestManager {
	public Request_1(String thing) {
		super(thing);
	}
	@Override
	protected int getLever() {
		return Lever.LOWER;
	}
}

public class Request_2 extends RequestManager {
	public Request_2(String thing) {
		super(thing);
	}
	@Override
	protected int getLever() {
		return Lever.MIDDLE;
	}
}

public class Request_3 extends RequestManager {
	public Request_3(String thing) {
		super(thing);
	}
	@Override
	protected int getLever() {
		return Lever.UPPER;
	}
}

3.创建抽象接收者以及他的三个子类

//抽象处理者
public abstract class ResponseManager {
	//下一级处理者
	private ResponseManager nextResponse;
	//所要处理的事情
	protected RequestManager request;
	public void setNextResponse(ResponseManager nextResponse) {
		this.nextResponse = nextResponse;
	}
	//获取处理者的等级
	protected abstract int getLever();
	//获取处理者的名称
	protected abstract String getResponseName();
	//处理者的处理方式
	protected abstract void operate(RequestManager request);
	public void compare(RequestManager request){
		int responseLever=this.getLever();
		int requestLever=request.getLever();
		if(responseLever==requestLever){
			this.operate(request);
		}else{
			if(this.nextResponse!=null){
				System.out.println(this.getResponseName()+"  处理不了    "+request.getThing()+",交给上级");
				this.nextResponse.compare(request);
			}else{
				System.out.println("没人能处理    "+request.getThing());
			}
		}
	}
}

public class Response_1 extends ResponseManager{
	@Override
	protected int getLever() {
		return Lever.LOWER;
	}
	@Override
	protected void operate(RequestManager request) {
		System.out.println("Response_1 deal with "+request.getThing());
	}
	@Override
	protected String getResponseName() {
		return "Response_1";
	}
}

public class Response_2 extends ResponseManager{
	@Override
	protected int getLever() {
		return Lever.MIDDLE;
	}
	@Override
	protected void operate(RequestManager request) {
		System.out.println("Response_2 deal with "+request.getThing());
	}
	@Override
	protected String getResponseName() {
		return "Response_2";
	}
}

public class Response_3 extends ResponseManager{
	@Override
	protected int getLever() {
		return Lever.UPPER;
	}
	@Override
	protected void operate(RequestManager request) {
		System.out.println("Response_3 deal with "+request.getThing());
	}
	@Override
	protected String getResponseName() {
		return "Response_3";
	}
}

4.编写测试代码

//测试供应链
public class Test {
	public static void main(String[] args) {
		//创建三个不同等级的请求
		Request_1 request_1=new Request_1("小事");
		Request_2 request_2=new Request_2("中事");
		Request_3 request_3=new Request_3("大事");
		//创建三个不同等级的接收者
		Response_1 response_1=new Response_1();
		Response_2 response_2=new Response_2();
		Response_3 response_3=new Response_3();
		//创建接收者的链结构
		response_1.setNextResponse(response_2);
		response_2.setNextResponse(response_3);
		//开始接收并处理请求
		response_1.compare(request_1);
		response_1.compare(request_2);
		response_1.compare(request_3);
	}
}

5.后台输出

Response_1 deal with 小事
Response_1  处理不了    中事,交给上级
Response_2 deal with 中事
Response_1  处理不了    大事,交给上级
Response_2  处理不了    大事,交给上级
Response_3 deal with 大事

看完我所编写的代码,不知有没有对这种模式的理解加深,为了说明这种模式的优点我的确弄的复杂了,一下造了六个子类,但这样也更容易看出他的优点嘛:

1. 这里是列表文本1.实现了接收者和请求者的分离,降低了耦合性
    2.增加新的接收者也很方便,只需要建一个继承于抽象接收者的类然后再设置各个接收者的上下级关系即可
    3.这种模式使思路很清晰,一级一级的很有层次感

当然,这种模式也是有不足之处的:

1.因为请求事件并没有指定他的处理对象,所以每次处理事务时要从第一个接收者开始遍历,然后边遍历边找他相应的处理对象,这样无疑增加了内存浪费,降低了性能。
    2.在ResponseManager类中的compare()方法里面用到了递归来找寻他的处理对象,在大的项目中,对于庞大的请求者和接收者,栈的大小要求不能低,否则造成数据溢出就麻烦了。