常见面试题之设计模式--责任链模式

迈不过友情╰ 2024-03-22 21:14 64阅读 0赞

### 1. 概述 ###

在现实生活中，常常会出现这样的事例：一个请求有多个对象可以处理，但每个对象的处理条件或权限不同。例如，公司员工请假，可批假的领导有部门负责人、副总经理、总经理等，但每个领导能批准的天数不同，员工必须根据自己要请假的天数去找不同的领导签名，也就是说员工必须记住每个领导的姓名、电话和地址等信息，这增加了难度。这样的例子还有很多，如找领导出差报销、生活中的“击鼓传花”游戏等。

**定义：**

又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

比较常见的`springmvc`中的拦截器，`web`开发中的`filter`过滤器。

![在这里插入图片描述][020e4f7d35554336a6526cf758b6ceaa.png_pic_center]

### 2. 结构 ###

职责链模式主要包含以下角色：

*  抽象处理者（`Handler`）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
 *  具体处理者（`Concrete Handler`）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
 *  客户类（`Client`）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

### 3. 案例实现 ###

处理订单的操作

![在这里插入图片描述][9ad7b07ab30c4d7691b6c2b2c66a8424.png_pic_center]

类图：

![在这里插入图片描述][1df47ca04bee4a4e8e164427c4a80461.png_pic_center]

代码：

抽象处理者

package com.dcxuexi.designpattern.chain;
    
    /**
     * 抽象处理者
     */
    public abstract class Handler {
        
    
        protected Handler handler;
    
        public void setNext(Handler handler) {
        
            this.handler = handler;
        }
    
        /**
         * 处理过程
         * 需要子类进行实现
         */
        public abstract void process(OrderInfo order);
    }

订单信息类：

package com.dcxuexi.designpattern.chain;
    
    
    import java.math.BigDecimal;
    
    public class OrderInfo {
        
    
        private String productId;
        private String userId;
    
        private BigDecimal amount;
    
        public String getProductId() {
        
            return productId;
        }
    
        public void setProductId(String productId) {
        
            this.productId = productId;
        }
    
        public String getUserId() {
        
            return userId;
        }
    
        public void setUserId(String userId) {
        
            this.userId = userId;
        }
    
        public BigDecimal getAmount() {
        
            return amount;
        }
    
        public void setAmount(BigDecimal amount) {
        
            this.amount = amount;
        }
    }

具体处理者：

/**
     * 订单校验
     */
    public class OrderValidition extends Handler {
        
    
        @Override
        public void process(OrderInfo order) {
        
            System.out.println("校验订单基本信息");
            //校验
            handler.process(order);
        }
    
    }
    
    /**
     * 补充订单信息
     */
    public class OrderFill extends Handler {
        
        @Override
        public void process(OrderInfo order) {
        
            System.out.println("补充订单信息");
            handler.process(order);
        }
    
    }
    
    /**
     * 计算金额
     */
    public class OrderAmountCalcuate extends Handler {
        
        @Override
        public void process(OrderInfo order) {
        
            System.out.println("计算金额-优惠券、VIP、活动打折");
            handler.process(order);
        }
    
    }
    
    /**
     * 订单入库
     */
    public class OrderCreate extends Handler {
        
        @Override
        public void process(OrderInfo order) {
        
            System.out.println("订单入库");
        }
    }

客户类：

public class Application {
        
    
        public static void main(String[] args) {
        
            //检验订单
            Handler orderValidition = new OrderValidition();
            //补充订单信息
            Handler orderFill = new OrderFill();
            //订单算价
            Handler orderAmountCalcuate = new OrderAmountCalcuate();
            //订单落库
            Handler orderCreate = new OrderCreate();
    
            //设置责任链路
            orderValidition.setNext(orderFill);
            orderFill.setNext(orderAmountCalcuate);
            orderAmountCalcuate.setNext(orderCreate);
    
            //开始执行
            orderValidition.process(new OrderInfo());
        }
    
    }

### 4. 优缺点 ###

**优点**

*  降低了对象之间的耦合度
    
    该模式降低了请求发送者和接收者的耦合度。
 *  增强了系统的可扩展性
    
    可以根据需要增加新的请求处理类，满足开闭原则。
 *  增强了给对象指派职责的灵活性
    
    当工作流程发生变化，可以动态地改变链内的成员或者修改它们的次序，也可动态地新增或者删除责任。
 *  责任链简化了对象之间的连接
    
    一个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的`if`或者`if···else`语句。
 *  责任分担
    
    每个类只需要处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

**缺点：**

*  不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
 *  对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
 *  职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

### 4. 举一反三 ###

*  内容审核（视频、文章、课程….）
    
    ![在这里插入图片描述][aed8d658b0364acaac7b9a5e39bba63f.png_pic_center]
 *  订单创建
    
    ![在这里插入图片描述][9d60cbdbdd334cbbb7e5af3c7778331c.png_pic_center]
 *  简易流程审批
    
    ![在这里插入图片描述][3eb78d7293a34ea4bf7fea4fdc926aeb.png_pic_center]

能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。

[020e4f7d35554336a6526cf758b6ceaa.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ef8b6904d463408496453ceff2124528.png
[9ad7b07ab30c4d7691b6c2b2c66a8424.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/c39d310bf28748c79c0e6035bbbe6473.png
[1df47ca04bee4a4e8e164427c4a80461.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/bffbea8afeee44fdaa473b7ab0f16682.png
[aed8d658b0364acaac7b9a5e39bba63f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/454b1d9181524c2f9b347cfb567572d0.png
[9d60cbdbdd334cbbb7e5af3c7778331c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/90399af4072440efb8e97afd5209c5cd.png
[3eb78d7293a34ea4bf7fea4fdc926aeb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/85149b82aff348da96c947b42ccd0ab2.png