java23种设计模式-责任链模式

定义

属于行为型模式的一种，一个请求由多个对象来处理，这些对象形成一条链，请求沿着该链传递，直到该链上的某个对象处理它为止。

角色

• 抽象处理者 定义了处理方法，并且可以设置和返回下一个处理者。为接口或抽象类
• 具体处理者 抽象处理者的实现

实现

/**
 * desc : 抽象处理者
 * Created by tiantian on 2018/8/19
 */
public interface IHandler {
    void handle();
    
    void setNextHandler(IHandler handler);
    
    IHandler getNextHandler();
}

package design.patten.chain;

/**
 * desc : 具体处理者A
 * Created by tiantian on 2018/8/19
 */
public class HandlerA implements IHandler {
    private IHandler nextHandler = null;
    
    @Override
    public void handle() {
        System.out.println("HandlerA do something");
        if (this.hasNext()) {
            nextHandler.handle();
        }
    }

    @Override
    public void setNextHandler(IHandler handler) {
        this.nextHandler = handler ;
    }

    @Override
    public IHandler getNextHandler() {
        return nextHandler;
    }
    
    private boolean hasNext() {
        return nextHandler != null;
    }
}

package design.patten.chain;

/**
 * desc : 具体处理者B
 * Created by tiantian on 2018/8/19
 */
public class HandlerB implements IHandler {
    private IHandler nextHandler = null;

    @Override
    public void handle() {
        System.out.println("HandlerB do something");
        if (this.hasNext()) {
            nextHandler.handle();
        }
    }

    @Override
    public void setNextHandler(IHandler handler) {
        this.nextHandler = handler;
    }

    @Override
    public IHandler getNextHandler() {
        return nextHandler;
    }

    private boolean hasNext() {
        return nextHandler != null;
    }
}

package design.patten.chain;

/**
 * desc : 具体处理者C
 * Created by tiantian on 2018/8/19
 */
public class HandlerC implements IHandler {
    private IHandler nextHandler = null;

    @Override
    public void handle() {
        System.out.println("HandlerC do something");
        if (this.hasNext()) {
            nextHandler.handle();
        }
    }

    @Override
    public void setNextHandler(IHandler handler) {
        this.nextHandler = handler;
    }

    @Override
    public IHandler getNextHandler() {
        return null;
    }

    private boolean hasNext() {
        return nextHandler != null;
    }
}

public class Test {
    public static void main(String[] args) {
        IHandler handlerA = new HandlerA();
        IHandler handlerB = new HandlerB();
        IHandler iHandlerC = new HandlerC();
        
        handlerA.setNextHandler(handlerB);
        handlerB.setNextHandler(iHandlerC);
        
        handlerA.handle();
    }

    // output:
    //HandlerA do something
    //HandlerB do something
    //HandlerC do something
}

应用

JS 中的事件冒泡。 Servlet中的Filter等。

总结

优点： 分离了请求和处理，降低了耦合。请求的处理是在链上的某个处理者处理，请求者不知道具体处理者；处理者亦不知请求的全部细节。
缺点： 请求链较长时性能受到影响。调试不太方便。