小知识点——责任链模式

在项目中，有应用到，及时整理，方便日后温习。

定义

责任链模式是一种设计模式，也是行为型设计模式之一。多个对象以链条的形式进行连接，链的节点是由每一 个对象引用下一个对象构成。请求在链条的一端发出，并向链的另一端进行传递，直到有对象处理了这个请求，那么传递就终止了，这就是责任链模式。

作用

责任链上的处理者处理请求，而客户端只需要将请求发送到责任链上即可，不需要关心请求的处理过程或请求的传递，这样责任就分得很清楚了，达到请求的发送者和请求的处理者解耦。

优点

• 降低耦合度。它将请求的发送者和接收者解耦。
• 简化了对象。使得对象不需要知道链的结构。
• 增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任。
• 增加新的请求处理类很方便。

缺点

• 不能保证请求一定被接收。
• 系统性能将受到一定影响，而且在进行代码调试时不太方便，可能会造成循环调用。
• 可能不容易观察运行时的特征，有碍于除错。

使用场景

• 可以多个对象处理同一个请求，具体由那个对象去处理，要看运行时动态决定。
• 在不明确指定接收者的情况下，可以向多个对象中提交一个请求。
• 可以动态指定一组对象处理请求。

角色

• 抽象角色：这个角色通常由一个Java接口或Java抽象类实现，定义。
• 具体处理者角色：这个角色就是接到请求后，可以选择处理掉请求，或者将请求传递给下一个处理者对象处理。

下面通过代码实现一个简单的责任链模式：

1、定义一个抽象角色（BaseHandler）

/**
 * @Author 安仔夏天很勤奋
 * Create Date is  2020/4/17
 * Des  责任链模式的抽象角色
 * 1、定义一个处理请求，返回处理结果
 * 2、定义当前对象指向下一个处理节点Handler对象的引用。
 */
public abstract class BaseHandler {
    //保持当前对象指向下一个处理节点Handler对象的引用。
    public BaseHandler nextHandler;
    //根据传入的条件处理请求
    public abstract String handlerRequest(String condition);
}

2、定义具体处理角色，即具体实现（ConcreteHandler1、ConcreteHandler2、ConcreteHandler3）。继续BaseHandler类，重写handlerRequest()方法。如果传递的条件符合则处理请求，如果不符合条件并存在责任链的下一个处理者对象，则传递给下一个处理者对象处理，反之直接返回错误结果。

/**
 * @Author 安仔夏天很勤奋
 * Create Date is  2020/4/17
 * Des 具体实现者1
 */
public class ConcreteHandler1 extends BaseHandler {
    @Override
    public String handlerRequest(String condition) {
        if("ConcreteHandler1".equals(condition)){
//            System.out.println("处理者为：ConcreteHandler1");
            return "处理者为：ConcreteHandler1";
        }else{
            if(nextHandler==null){
                return "没有找到处理者["+condition+"]，你看着办！";
            }
            return nextHandler.handlerRequest(condition);
        }
    }
}

/**
 * @Author 安仔夏天很勤奋
 * Create Date is  2020/4/17
 * Des 具体实现者2
 */
public class ConcreteHandler2 extends BaseHandler {
    @Override
    public String handlerRequest(String condition) {
        if("ConcreteHandler2".equals(condition)){
//            System.out.println("处理者为：ConcreteHandler2");
            return "处理者为：ConcreteHandler2";
        }else{
            if(nextHandler==null){
                return "没有找到处理者["+condition+"]，你看着办！";
            }
            return nextHandler.handlerRequest(condition);
        }
    }
}

/**
 * @Author 安仔夏天很勤奋
 * Create Date is  2020/4/17
 * Des 具体实现者3
 */
public class ConcreteHandler3 extends BaseHandler {
    @Override
    public String handlerRequest(String condition) {
        if("ConcreteHandler3".equals(condition)){
//            System.out.println("处理者为：ConcreteHandler3");
            return "处理者为：ConcreteHandler3";
        }else{
            if(nextHandler==null){
                return "没有找到处理者["+condition+"]，你看着办！";
            }
            return nextHandler.handlerRequest(condition);
        }
    }
}

3、Client端调用（）

/**
 * @Author 安仔夏天很勤奋
 * Create Date is  2020/4/17
 * Des  客户端
 */
public class ClientTest {
    public static void main(String[] args){
        BaseHandler handler1 = new ConcreteHandler1();
        BaseHandler handler2 = new ConcreteHandler2();
        BaseHandler handler3 = new ConcreteHandler3();
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler3;
        //打印请求处理后的结果
        String result = handler1.handlerRequest("ConcreteHandler3");
        System.out.println(result+"");
    }
}

上面的责任链模式例子是一个简单版，但多数情况下，责任链中请求和对应处理规则是不尽相同的，在这种情况下可以将请求进行封装，同时对请求的处理规则也进行封装作为一个独立的对象。