设计模式之职责链模式

谁借莪１个温暖的怀抱￠ 2022-03-27 08:16 255阅读 0赞

# 模式定义 #

职责链模式，也叫责任链模式或者责任连锁模式。 避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止，这就是职责链模式，也叫责任链模式或者责任连锁模式。

在职责链模式中最关键的一点就是客户提交请求后，请求沿着链往下传递直到有一个处理者处理它，在这里客户无需关心它的请求是哪个处理者来处理，反正总有一个处理者会处理它的请求。

在这里客户端和处理者都没有对方明确的信息，同时处理者也不知道职责链中的结构。所以职责链可以简化对象的相互连接，他们只需要保存一个指向其后续者的引用，而不需要保存所有候选者的引用。

在职责链模式中我们可以随时随地的增加或者更改一个处理者，甚至可以更改处理者的顺序，增加了系统的灵活性。处理灵活性是增加了，但是有时候可能会导致一个请求无论如何也得不到处理，它会被放置在链末端，这个既是职责链的优点也是缺点。

# 模式结构 #

下图是职责链模式的UML结构图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NDUwMDg5_size_16_color_FFFFFF_t_70][]

从上面可以看出职责链包含三个角色：

Handler: 抽象处理者。定义了一个处理请求的方法。所有的处理者都必须实现该抽象类。 ConcreteHandler: 具体处理者。处理它所负责的请求，同时也可以访问它的后继者。如果它能够处理该请求则处理，否则将请求传递到它的后继者。 Client: 客户类。

下面是最典型的具体处理者类。

public class ConcreteHandler extends Handler
    {
        public void handleRequest(String request)
        {
            if(请求request满足条件)
            {
                ......  //处理请求；
            }
            else
            {
                this.successor.handleRequest(request); //转发请求
            }
        }
    }

要职责链模式需满足

1、需要将某任务的所有职责执行对象以链的形式加以组织。

2、将消息或请求按照对象链传递，让处于对象链中的对象得到处理机会。

3、处于对象链中的对象，不同的对象执行不同的职责

4、处于对象链的末尾的对象结束任务并停止消息或请求继续传递。

比如客户想要完成一个任务，这个任务包括a,b,c三部分

首先客户把任务交给A去完成a部分，A完成后才能B去完成b部分直到C完成c部分

我们拿组装汽车举例：先安装车头，然后安装车身，最后安装车尾。

处理器的抽象类

/**
     * 职责：Handler 职责类的抽象父类
     */
    public abstract class AbstractCarHandler {
    
        AbstractCarHandler carHandler = null;
    
        public abstract void carHandler();
    
        public AbstractCarHandler setNextCarHandler(AbstractCarHandler nextCarHandler){
            this.carHandler = nextCarHandler;
            return this.carHandler;
        }
    
        /**职责下传*/
        protected void doChain(){
            if(this.carHandler != null){
                this.carHandler.carHandler();
            }
        }
    }

责任链一个执行者处理车头

/**
     * 职责：concreteHandler 具体的处理类
     */
    public class CarHeadHandler extends AbstractCarHandler {
        @Override
        public void carHandler() {
            System.out.println("处理车的head！");
    
            //下传
            this.doChain();
        }
    }

责任链一个执行者处理车身

/**
     * 职责：concreteHandler 具体的处理类
     */
    public class CarBodyHandler extends AbstractCarHandler {
        @Override
        public void carHandler() {
            System.out.println("处理车的body！");
    
            //下传
            this.doChain();
        }
    }

责任链一个执行者处理车尾

/**
     * 职责：concreteHandler 具体的处理类
     */
    public class CarTailHandler extends AbstractCarHandler {
        @Override
        public void carHandler() {
            System.out.println("处理车的tail！");
    
            //下传
            this.doChain();
        }
    }

public static void main(String[] args) {
            AbstractCarHandler carheadHandle = new CarHeadHandler();
            AbstractCarHandler carbodyHandle = new CarBodyHandler();
            AbstractCarHandler carTailHandler = new CarTailHandler();
    
            //组装责任链
            carheadHandle.setNextCarHandler(carbodyHandle).setNextCarHandler(carTailHandler);
    
            //链头部开始执行
            carheadHandle.carHandler();
        }

运行结果：

处理车的head！

处理车的body！

处理车的tail！

--------------------

比如你要请假，根据请假的天数不同，不同的领导进行审批。

休假请求类

public class LeaveRequest // 休假请求
    {
        private String leaveName; // 休假人
        private int leaveDays; // 休假天数
    
        public LeaveRequest(String leaveName,int leaveDays)
        {
            this.leaveName=leaveName;
            this.leaveDays=leaveDays;
        }
    
        public void setLeaveName(String leaveName) {
            this.leaveName = leaveName;
        }
    
        public void setLeaveDays(int leaveDays) {
            this.leaveDays = leaveDays;
        }
    
        public String getLeaveName() {
            return (this.leaveName);
        }
    
        public int getLeaveDays() {
            return (this.leaveDays);
        }
    }

2.抽象处理类

public abstract class Leader // 抽象处理者
    {
        protected String name;
        protected Leader successor;
        public Leader(String name)
        {
            this.name=name;
        }
        public void setSuccessor(Leader successor) 
        { // 设置下一个处理者
            this.successor=successor;
        }
        public abstract void handleRequest(LeaveRequest request); // 处理请求
    }

3.主任 审批小于三天

public class Director extends Leader // 主任
    {
        public Director(String name)
        {
            super(name);
        }
        public void handleRequest(LeaveRequest request)
        {
            if(request.getLeaveDays()<3) // 小于三天主任审批
            {
                System.out.println("主任" + name + "审批员工" + request.getLeaveName() + "的请假条，请假天数为" + request.getLeaveDays() + "天。");
            }
            else
            {
                if(this.successor!=null)
                {
                    this.successor.handleRequest(request);
                }
            }
        }
    }

4.经理 审批小于十天

public class Manager extends Leader // 经理审批
    {
        public Manager(String name)
        {
            super(name);
        }
        public void handleRequest(LeaveRequest request)
        {
            if(request.getLeaveDays()<10)
            {
                System.out.println("经理" + name + "审批员工" + request.getLeaveName() + "的请假条，请假天数为" + request.getLeaveDays() + "天。");
            }
            else
            {
                if(this.successor!=null)
                {
                    this.successor.handleRequest(request);
                }
            }
        }
    }

5.副总经理 审批小于二十天

public class ViceGeneralManager extends Leader // 副总经理
    {
        public ViceGeneralManager(String name)
        {
            super(name);
        }
        public void handleRequest(LeaveRequest request)
        {
            if(request.getLeaveDays()<20)
            {
                System.out.println("副总经理" + name + "审批员工" + request.getLeaveName() + "的请假条，请假天数为" + request.getLeaveDays() + "天。");
            }
            else
            {
                if(this.successor!=null)
                {
                    this.successor.handleRequest(request);
                }
            }
        }
    }

6.总经理 审批小于三十天

public class GeneralManager extends Leader // 总经理审批
    {
        public GeneralManager(String name)
        {
            super(name);
        }
    
        public void handleRequest(LeaveRequest request)
        {
            if(request.getLeaveDays()<30)
            {
                System.out.println("总经理" + name + "审批员工" + request.getLeaveName() + "的请假条，请假天数为" + request.getLeaveDays() + "天。");
            }
            else
            {
                System.out.println("莫非" + request.getLeaveName() + "想辞职，居然请假" + request.getLeaveDays() + "天。");
            }
        }
    }

7.客户端

public static void main(String args[])
        {
            //Leader objDirector,objManager,objGeneralManager,objViceGeneralManager;
    
           Director objDirector=new Director("王明");
           Manager objManager=new Manager("赵强");
           GeneralManager objGeneralManager=new GeneralManager("李波");
           ViceGeneralManager objViceGeneralManager=new ViceGeneralManager("肖红");
    
            // 建立职责链
            objDirector.setSuccessor(objManager); // 主任上级是经理
            objManager.setSuccessor(objViceGeneralManager); // 经理上级是副经理
            objViceGeneralManager.setSuccessor(objGeneralManager); // 副经理上级是总经理
    
            LeaveRequest lr1=new LeaveRequest("张三",2);
            objDirector.handleRequest(lr1);
    
            LeaveRequest lr2=new LeaveRequest("李四",5);
            objDirector.handleRequest(lr2);
    
            LeaveRequest lr3=new LeaveRequest("王五",15);
            objDirector.handleRequest(lr3);
    
            LeaveRequest lr4=new LeaveRequest("赵六",25);
            objDirector.handleRequest(lr4);
        }

运行结果：  
主任王明审批员工张三的请假条，请假天数为2天。  
经理赵强审批员工李四的请假条，请假天数为5天。  
副总经理肖红审批员工王五的请假条，请假天数为15天。  
总经理李波审批员工赵六的请假条，请假天数为25天。

![f35313aceabaec38f034de130cb88be3.png][]

## 优点 ##

1、降低耦合度。它将请求的发送者和接受者解耦。

2、简化了对象。使得对象不需要知道链的结构。

3、增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。

4、增加新的请求处理类很方便。

## 缺点 ##

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

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

3、可能不容易观察运行时的特征，有碍于除错。

# 模式适用场景 #

1、有多个对象可以处理同一个请求，具体哪个对象处理该请求由运行时刻自动确定。

2、在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

3、可动态指定一组对象处理请求。

# 总结 #

1、职责链模式将请求的发送者和接受者解耦了。客户端不需要知道请求处理者的明确信息，甚至不需要知道链的结构，它只需要将请求进行发送即可。

2、职责链模式能够非常方便的动态增加新职责或者删除职责。

3、客户端发送的请求可能会得不到处理。

4、处理者不需要知道链的结构，只需要明白他的后续者是谁就可以了。这样就简化了系统中的对象。

实现场景

[责任链模式实现的三种方式][Link 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3NDUwMDg5_size_16_color_FFFFFF_t_70]: /images/20220327/54d2b473940c4fcb9c317f52b8d7925b.png
[f35313aceabaec38f034de130cb88be3.png]: /images/20220327/f806e910600f4ea79c2607cead6faf89.png
[Link 1]: https://www.cnblogs.com/lizo/p/7503862.html