JAVA设计模式：职责链模式

职责链模式

Chain of Responsibility（CoR）模式也叫职责链模式或者职责连锁模式，是行为模式之一，该模式构造一系列分别担当不同的职责的类的对象来共同完成一个任务，这些类的对象之间像链条一样紧密相连，所以被称作职责链模式。

 

一、结构与角色

• Handler：处理类的抽象父类，存在对自身的引用，例如组装车中，车头组装完之后自动调用车身组装，所以需要持有它的引用
• concreteHandler：具体的处理类

 

二、应用场景

• 比如客户Client要完成一个任务，这个任务包括a,b,c,d四个部分。首先客户Client把任务交给A，A完成a部分之后，把任务交给B，B完成b部分，…，直到D完成d部分。
• 比如政府部分的某项工作，县政府先完成自己能处理的部分，不能处理的部分交给省政府，省政府再完成自己职责范围内的部分，不能处理的部分交给中央政府，中央政府最后完成该项工作。
• 软件窗口的消息传播。
• SERVLET容器的过滤器（Filter）框架实现。

 

三、基本条件

• 1：对象链的组织。需要将某任务的所有职责执行对象以链的形式加以组织。
• 2：消息或请求的传递。将消息或请求沿着对象链传递，以让处于对象链中的对象得到处理机会。
• 3：处于对象链中的对象的职责分配。不同的对象完成不同的职责。
• 4：任务的完成。处于对象链的末尾的对象结束任务并停止消息或请求的继续传递。

 

四、一般代码示例

4.1 CarHandler

public abstract class CarHandler {
    public abstract void HandlerCar();
}

4.2 CarHeadHandler

public class CarHeadHandler extends CarHandler {
    @Override
    public void HandlerCar() {
        System.out.println("组装车头");
    }
}

4.3 CarBodyHandler

public class CarBodyHandler extends CarHandler {
    @Override
    public void HandlerCar() {
        System.out.println("组装车身");
    }
}

4.4 CarTailHandler

public class CarTailHandler extends CarHandler {
    @Override
    public void HandlerCar() {
        System.out.println("组装车尾");
    }
}

4.5 MainClass

public class MainClass {
    public static void main(String[] args){
        CarHandler headH = new CarHeadHandler();
        CarHandler headB = new CarBodyHandler();
        CarHandler handT = new CarTailHandler();
        //手动一个一个调用，没有自动传递
        headH.HandlerCar();
        headB.HandlerCar();
        handT.HandlerCar();
    }
}

 

五、职责链模式

5.1 CarHandler

public abstract class CarHandler {
    //持有自身的引用，protected保证子类可以引用
    protected CarHandler carHandler;

    public void setNextHandler(CarHandler carHandler){
        this.carHandler = carHandler;
    }

    public abstract void HandlerCar();
}

5.2 CarHeadHandler

public class CarHeadHandler extends CarHandler {
    @Override
    public void HandlerCar() {
        System.out.println("组装车头");
        if(this.carHandler != null){
            //如果下一个处理器存在，代表存在下一个环节，则继续组装
            this.carHandler.HandlerCar();
        }
    }
}

5.3 CarBodyHandler

public class CarBodyHandler extends CarHandler {
    @Override
    public void HandlerCar() {
        System.out.println("组装车身");
        if(this.carHandler != null){
            this.carHandler.HandlerCar();
        }
    }
}

5.4 CarTailHandler

public class CarTailHandler extends CarHandler {
    @Override
    public void HandlerCar() {
        System.out.println("组装车尾");
        if(this.carHandler != null){
            this.carHandler.HandlerCar();
        }
    }
}

5.5 MainClass

public class MainClass {
    public static void main(String[] args){
        CarHandler headH = new CarHeadHandler();
        CarHandler headB = new CarBodyHandler();
        CarHandler handT = new CarTailHandler();
        //设置顺序：车头到车身到车尾
        headH.setNextHandler(headB);
        headB.setNextHandler(handT);
        //调用职责链的链头来执行
        headH.HandlerCar();
    }
}

//运行结果
组装车头
组装车身
组装车尾

5.6 将下一个职责return，代码简化

public abstract class CarHandler {
    //持有自身的引用，protected保证子类可以引用
    protected CarHandler carHandler;

    public CarHandler setNextHandler(CarHandler carHandler){
        this.carHandler = carHandler;
        return this.carHandler;
    }

    public abstract void HandlerCar();
}

5.7 MainClass

public class MainClass {
    public static void main(String[] args){
        CarHandler headH = new CarHeadHandler();
        CarHandler headB = new CarBodyHandler();
        CarHandler handT = new CarTailHandler();
        
        //修改为return返回下一个职责后
        headH.setNextHandler(headB).setNextHandler(handT);
        headH.HandlerCar();
    }
}

 

六、职责链模式的优缺点

优点：

• 责任的分担。每个类只需要处理自己该处理的工作（不该处理的传递给下一个对象完成），明确各类的责任范围，符合类的最小封装原则。
• 可以根据需要自由组合工作流程。如工作流程发生变化，可以通过重新分配对象链便可适应新的工作流程，例如从车身组装到车头组装再到车尾组装。
• 类与类之间可以以松耦合的形式加以组织。

缺点：

• 因为处理时以链的形式在对象间传递消息，根据实现方式不同，有可能会影响处理的速度。