职责链——对象行为模式

最新推荐文章于 2023-09-28 09:48:37 发布

panpan_chen

最新推荐文章于 2023-09-28 09:48:37 发布

阅读量672

点赞数

分类专栏： Architecture 文章标签：职责链对象行为模式

Architecture 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

意图

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

适用场景

1、有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定；
2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求；
3、处理一个请求的对象集合应被动态指定。

结构图

这里写图片描述

职责链模式角色

•Handler（抽象处理者）：定义出一个处理请求的接口。如果需要，接口可以定义出一个方法，以设定和返回对下家的引用。这个角色通常由一个抽象类或接口实现。
•ConcreteHandler（具体处理者）：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。
•Client: 客户端

优缺点

职责链模式的优点

• 降低耦合度

• 可简化对象的相互连接

• 增强给对象指派职责的灵活性

• 增加新的请求处理类很方便

职责链模式的缺点

•不能保证请求一定被接收。

•系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。

实现

// 全局变量，接口类型  
/**  
 * 使用Java中的interface定义全局变量，可根据具体需要在   
 * 具体的包中使用静态导入相关的全局变量，语法如下：   
 *  import static package01.package02.*;  
 */ 
interface Levels {  
    public static final int LEVEL_01 = 1;  
    public static final int LEVEL_02 = 2;  
    public static final int LEVEL_03 = 3;  
}

// 抽象请求类  
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;  
    }  
}  

// 具体请求类03  
class Request03 extends AbstractRequest {  
    public Request03(String content) {  
        super(content);  
    }  

    @Override 
    public int getRequestLevel() {  
        return Levels.LEVEL_03;  
    }  
}

// 抽象处理者类，  
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");  
    }  
}  

// 具体处理者-03  
class Handler03 extends AbstractHandler {  
    @Override 
    protected int getHandlerLevel() {  
        return Levels.LEVEL_03;  
    }  

    @Override 
    protected void handle(AbstractRequest request) {  
        System.out.println("处理者-03 处理 " + request.getContent()+ "\n");  
    }  
}

// 测试类  
public class Client {  
    public static void main(String[] args) {  
        // 创建指责链的所有节点  
        AbstractHandler handler01 = new Handler01();  
        AbstractHandler handler02 = new Handler02();  
        AbstractHandler handler03 = new Handler03();  

        // 进行链的组装，即头尾相连，一层套一层  
        handler01.setNextHandler(handler02);  
        handler02.setNextHandler(handler03);  

        // 创建请求并提交到指责链中进行处理  
        AbstractRequest request01 = new Request01("请求-01");  
        AbstractRequest request02 = new Request02("请求-02");  
        AbstractRequest request03 = new Request03("请求-03");  

        // 每次提交都是从链头开始遍历  
        handler01.handleRequest(request01);  
        handler01.handleRequest(request02);  
        handler01.handleRequest(request03);  
    }  
}