职责链模式
职责链模式:使多个对象都有机会处理请求,从而避免请求的送发者和接收者之间的耦合关系,使多个对象都有机会处理请求,从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有一个对象处理它为止。
职责链模式的优缺点:
优点:
1. 责任的分担。每个类只需要处理自己该处理的工作(不该处理的传递给下一个对象完成),明确各类的责任范围,符合类的最小封装原则。
2. 可以根据需要自由组合工作流程。如工作流程发生变化,可以通过重新分配对象链便可适应新的工作流程。
3. 类与类之间可以以松耦合的形式加以组织。
缺点:
因为处理时以链的形式在对象间传递消息,根据实现方式不同,有可能会影响处理的速度。
职责链模式的角色和职责
Handler
处理类的抽象父类。
concreteHandler
具体的处理类。
职责链模式的基本条件
要实现Chain of Responsibility模式,需要满足该模式的基本条件:
1. 对象链的组织。需要将某任务的所有职责执行对象以链的形式加以组织。
2. 消息或请求的传递。将消息或请求沿着对象链传递,以让处于对象链中的对象得到处理机会。
3. 处于对象链中的对象的职责分配。不同的对象完成不同的职责。
4. 任务的完成。处于对象链的末尾的对象结束任务并停止消息或请求的继续传递。
package com.qinsoft.design;
/**
* 职责链模式:行为型
*/
public class ChainOfResponsibility {
public static void main(String[] args)
{
// 创建指责链的所有节点
AbstractHandler handler01 = new Handler01();
AbstractHandler handler02 = new Handler02();
// 进行链的组装,即头尾相连,一层套一层
handler01.setNextHandler(handler02);
// 创建请求并提交到指责链中进行处理
AbstractRequest request01 = new Request01("请求-01");
AbstractRequest request02 = new Request02("请求-02");
// 每次提交都是从链头开始遍历
handler01.handleRequest(request01);
handler01.handleRequest(request02);
}
}
interface Levels
{
public static final int LEVEL_01 = 1;
public static final int LEVEL_02 = 2;
}
// 抽象请求类
abstract class AbstractRequest {
private String content = null;
public AbstractRequest(String content)
{
this.content = content;
}
public String getContent()
{
return this.content;
}
// 获得请求的级别
public abstract int getRequestLevel();
}
// 具体请求类01
class Request01 extends AbstractRequest {
public Request01(String content) {
super(content);
}
@Override
public int getRequestLevel() {
return Levels.LEVEL_01;
}
}
//具体请求类02
class Request02 extends AbstractRequest {
public Request02(String content) {
super(content);
}
@Override
public int getRequestLevel() {
return Levels.LEVEL_02;
}
}
// 抽象处理者类,
abstract class AbstractHandler {
// 责任链的下一个节点,即处理者
private AbstractHandler nextHandler = null;
// 捕获具体请求并进行处理,或是将请求传递到责任链的下一级别
public final void handleRequest(AbstractRequest request) {
// 若该请求与当前处理者的级别层次相对应,则由自己进行处理
if (this.getHandlerLevel() == request.getRequestLevel()) {
this.handle(request);
} else {
// 当前处理者不能胜任,则传递至职责链的下一节点
if (this.nextHandler != null) {
System.out.println("当前 处理者-0" + this.getHandlerLevel()+ " 不足以处理 请求-0" + request.getRequestLevel());
// 这里使用了递归调用
this.nextHandler.handleRequest(request);
} else {
System.out.println("职责链上的所有处理者都不能胜任该请求...");
}
}
}
// 设置责任链中的下一个处理者
public void setNextHandler(AbstractHandler nextHandler) {
this.nextHandler = nextHandler;
}
// 获取当前处理者的级别
protected abstract int getHandlerLevel();
// 定义链中每个处理者具体的处理方式
protected abstract void handle(AbstractRequest request);
}
// 具体处理者-01
class Handler01 extends AbstractHandler {
@Override
protected int getHandlerLevel() {
return Levels.LEVEL_01;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("处理者-01 处理 " + request.getContent() + "\n");
}
}
// 具体处理者-02
class Handler02 extends AbstractHandler {
@Override
protected int getHandlerLevel() {
return Levels.LEVEL_02;
}
@Override
protected void handle(AbstractRequest request) {
System.out.println("处理者-02 处理 " + request.getContent() + "\n");
}
}