高性能高质量代码:设计模式-责任链模式

书写代码必须符合高质量高性能要求，这也是能够在视觉上和其他程序员拉开差距的技能，同时也是一个优秀程序员的基本要求。

何为高质量：代码具备可维护性，可读性，可扩展性，灵活性，简洁性，可复用性， 可测试性。

何为高性能：代码能尽可能的提高处理效率。

如何写高质量高性能代码：首先要做的就是精通设计模式，设计原则，掌握各种算法以及了解硬件底层相关内容。

今天我们来说一说责任链模式。

1责任链模式

将请求的发送和接收解耦，让多个接收对象都有机会处理这个请求。将这些接收对象串成一条链，并沿着这条链传递这个请求，直到链上的某个接收对象能够处理它为止。

第一种实现：

public abstract class Handler {
    
    protected Handler successor = null;

    public void setSuccessor(Handler successor) { 
        this.successor = successor;
    }
    public final void handle() { 
        boolean handled = doHandle(); 
        if (successor != null && !handled) {  
            successor.handle(); 
        }
    }

    protected abstract boolean doHandle();
}


public class HandlerA extends Handler {
    @Override
    protected boolean doHandle() { 
        boolean handled = false; 
         return handled;
    }
}

public class HandlerB extends Handler {
    @Override
    protected boolean doHandle() { 
        boolean handled = false;
        return handled;
    }
}

public class HandlerChain {
            private Handler head = null;
            private Handler tail = null;
            public void addHandler(Handler handler) {
                handler.setSuccessor(null);
                if (head == null) {
                    head = handler;
                    tail = handler;
                    return;
                }
                tail.setSuccessor(handler);
                tail = handler;
            }

            public void handle() {
                if (head != null) {
                    head.handle();
                }
            }
}

public class Application {
            public static void main(String[] args) { 
                HandlerChain chain = new HandlerChain(); 
                chain.addHandler(new HandlerA()); 
                chain.addHandler(new HandlerB()); 
                chain.handle();
            }
        }

第二种实现：

public interface IHandler {
    boolean handle();
}

public class HandlerA implements IHandler {
    @Override
    public boolean handle() {
        boolean handled = false; 
        return handled;
    }
}

public class HandlerB implements IHandler {
    @Override
    public boolean handle() {
        boolean handled = false; 
        return handled;
    }
}

public class HandlerChain {
    private List<IHandler> handlers = new ArrayList<>();

    public void addHandler(IHandler handler) {
        this.handlers.add(handler);
    }

    public void handle() {
        for (IHandler handler : handlers) {
            boolean handled = handler.handle();
            if (handled) {
                break;
            }
        }
    }
}

public class Application {
    public static void main(String[] args) {
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new HandlerA());
        chain.addHandler(new HandlerB());
        chain.handle();
    }
}

责任链模式并不一定按照定义那样，在中途遇到某到某种情况就要终止，完全不必被定义束缚，以为所有的设计模式定义都只是作为指导思想的存在，因此也可以让责任链不管遇到什么情况都继续往下传递请求。而且不仅用数组可以实现，用链表也可以实现，原理都是差不多。

应用职责链模式，我们把各个敏感词过滤函数继续拆分出来，设计成独立的类，进一步简化了SensitiveWordFilter类，让SensitiveWordFilter类的代码不会过多复杂。

当我们要扩展新的过滤算法的时候，比如，我们还需要过滤特殊符号，按照非职责链模式的代码实现方式，我们需要修改SensitiveWordFilter的代码，违反开闭原则。不过，这样的修改还算比较集中，也是可以接受的。而职责链模式的实现方式更加优雅，只需要新添加一个Filter类，并且通过addFilter()函数将它添加到FilterChain中即可，其他代码完全不需要修改。

不过，你可能会说，即便使用职责链模式来实现，当添加新的过滤算法的时候，还是要修改客户端代码（ApplicationDemo），这样做也没有完全符合开闭原则。

实际上，细化一下的话，我们可以把上面的代码分成两类：框架代码和客户端代码。其中ApplicationDemo属于客户端代码，对客户端代码进行细微修改影响不会很大，所以是可以接受的。

假设敏感词过滤框架并不是我们开发维护的，而是我们引入的一个第三方框架，我们要扩展一个新的过滤算法，不可能直接去修改框架的源码。这个时候，利用职责链模式就能达到开篇所说的，在不修改框架源码的情况下，基于职责链模式提供的扩展点，来扩展新的功能。换句话说，我们在框架这个代码范围内实现了开闭原则。