JAVA设计模式面试小考点之 责任链（实例讲解）

写在前面

这是一篇隔了几个月的内容，这篇文章也是由于一个槽点才出炉的。

ps：朋友们一定要多写注释啊！！！！不然你永远不知道下一个接盘你代码的人，是如何辱骂你的。特么不写注释也还好，问题是简单功能写复杂还不写注释是几个意思，非要在平坦路面上搞点障碍物么！！！

好了，吐槽结束。开始正文。

妈惹法克的小饼干，还是越想越气。算了算了，开始正文。

责任链是个啥

通俗的来讲，责任链有点像流水线。

举个栗子：一个手机从初始一个主板进入流水线后，每个阶段的流水线工人，会根据不同的主板来判断是否对其进行加工，到最后离开流水线的时候会组装成一台完整的手机。

比较专业的讲：责任链模式（Chain of Responsibility）中包含包含一些命令对象和处理对象。处理对象会通过指针形成链式结构（责任链），命名对象经过责任链上的处理对象一个个处理得到最终的处理结果。

讲到这里其实责任链就差不多就结束了，其实这就是一个概念理解了之后就并不负责。

但是！！我猿猿怎么会就此而止呢。。

责任链的优缺点

一个设计模式有优点，必然也有缺点。在适当的使用中，会对业务有一定的帮助。

责任链的优点:

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

责任链的缺点

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。（PS:在一定的可能下，一个任务可能会不经过任何处理直接返回，这也是 优点1 带来的问题）
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用。(PS: 写到这里妈惹法克的小饼干，气不打一出来，业务不复杂别整这些虚头八脑的，还有 记得写备注哦 各位宝宝们)

责任链的具体应用场景

    经过上述的描述之后，大家应该有一定的概念了。这时候有没有想到一些第三方包中使用责任链的具体场景呢。提个醒：spring中就有哟。

1。

2。

3。

ok，答案解密。servlet中的拦截器 和 Spring AOP 职责链 是不是醍醐灌顶一下子想到了呢。当然肯定还有其他的责任链，不过这次我们就以 servlet的拦截器 和 一个小小的demo来讲解

Servlet中定义了 Filter 和 FilterChain 来定义责任链

public interface Filter {
    default void init(FilterConfig filterConfig) throws ServletException {
    }

    void doFilter(ServletRequest var1, ServletResponse var2, FilterChain var3) throws IOException, ServletException;

    default void destroy() {
    }
}

public interface FilterChain {
    void doFilter(ServletRequest var1, ServletResponse var2) throws IOException, ServletException;
}

从源码中即可以看到，Filter相当于流水线女工 ， 而FilterChain相当于流水线女工要完成的工作。

在servlet规范中，只实现了ApplicationFilterChain，其他都是spring实现的。源码太长，旁友们可以进入到ApplicationFilterChain类中查看哟。

ApplicationFilterChain类中存在一个成员变量：

private ApplicationFilterConfig[] filters = new ApplicationFilterConfig[0];

维护了一个Filter数组来执行责任链的操作。言尽于此，主要还是讲起来太麻烦了，各位亲看看源码哟。

demo

我们以一个demo举个实际生产中的栗子吧。

/*
* @Description: 责任链中的环节
* @Date: 2021/7/13
*/
public interface Handler<T extends Object> {

    boolean doSomething(T obj);
}
/*
* @Description: 责任链的处理器
* @Date: 2021/7/13
*/
public interface HandlerChain<T extends Object> {
    void startHandle(T context);

    void addHandler(Handler<T> handler);

    void removeHandler(Handler<T> handler);
}

具体实现责任链的内容 

public class LogHandler implements Handler {
    public boolean doSomething(Object obj) {
       System.out.println("打印日志");
        //打印日志
        return true;
    }
}

public class ValidHandler implements Handler {
    public boolean doSomething(Object obj) {
       System.out.println("校验参数");
        //校验参数
        return true;
    }
}

public class InvokeHandler implements Handler {
    public boolean doSomething(Object obj) {
     System.out.println("搞事情");
        //具体实现内容
        return true;
    }
}

流水线 （其实这里可以搞成LinkedHashMap样式的，但是是demo辣，就无所谓了哦）

public class HandlerChainInvoke implements HandlerChain{

    private HandlerNode tail;

    private HandlerNode head;


    @Override
    public void startHandle(Object context) {
        System.out.println("做一些事情拉");
        HandlerNode node = head;
        Handler handler = node.getHandler();
        while (handler != null){
            handler.doSomething(context);
            node = node.getNextHandlerNode();
            if( node == null ){
                break;
            }
            handler = node.getHandler();
        }
    }

    @Override
    public void addHandler(Handler handler) {
        if (this.head == null) {
            head = new HandlerNode(handler);
            tail = head;
        } else {
            HandlerNode newH = new HandlerNode(handler);
            tail.setNextHandlerNode(newH);
            tail = newH;
        }
    }

    @Override
    public void removeHandler(Handler handler) {
        if(head == null){
            return;
        }
        HandlerNode pre = head;
        HandlerNode handlerNode = head.getNextHandlerNode();
        while( handlerNode != null ){
            if(handlerNode.getHandler().equals(handlerNode)) {
                pre.setNextHandlerNode( handlerNode.getNextHandlerNode() );
                if (handlerNode.equals(tail)) {
                    tail = pre;
                }
                break;
            }

            pre = handlerNode;
            handlerNode = handlerNode.getNextHandlerNode();
        }

    }
}
@Data
class HandlerNode<T extends Object> {
    private Handler<T> handler;

    private HandlerNode<T> nextHandlerNode;

    public HandlerNode(Handler<T> handler) {
        this.handler = handler;
        this.nextHandlerNode = null;
    }
}

具体实现

    @Bean
    public static HandlerChain handlerChain(){
        HandlerChain handlerChain = new HandlerChainInvoke();
        handlerChain.addHandler(new LogHandler());
        handlerChain.addHandler(new ValidHandler());
        handlerChain.addHandler(new InvokeHandler());
        return handlerChain;
    }

    public static void main(String[] args) {
        HandlerChain handlerChain = handlerChain();
        handlerChain.startHandle("");
    }

输出内容：
做一些事情拉
打印日志
校验参数
搞事情

完结撒花

重要的事情说三遍，这就是第三遍：一定要写注释啊。peace and love