责任链模式的定义是：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

责任链模式适合于请求需要经过多个处理器，并被其中一个或多个处理器执行。

classDiagram
class Handler{
	<<interface>>
	+ setNext(Handler)
	+ handler(Request)
}
class ConcreteHandler{
	next:Handler
	+ setNext(Handler)
	+ handler(Request)
}
Handler o..> Handler
ConcreteHandler --|> Handler

代码实现：

// 抽象处理器  
public abstract class Handler {  
    private Handler next;  
    // 初始化处理链  
    public static Handler init(Handler... handlers) {  
        Handler first = handlers[0];  
        for (int i = 1; i < handlers.length; i++) {  
            first.setNext(handlers[i]);  
            first = handlers[i];  
        }  
        return handlers[0];  
    }  
  
    public void setNext(Handler handler) {  
        next = handler;  
    }  
    // 处理当前请求  
    public abstract void handle(Request request);  
    //处理下一个请求  
    protected void nextHandle(Request request) {  
        if (next != null) {  
            next.handle(request);  
        }  
    }  
}

public class HandlerA extends Handler {  
    @Override  
    public void handle(Request request) {  
        request.addName("HandlerA");  
        nextHandle(request);  
    }  
}

public class HandlerB extends Handler {  
    @Override  
    public void handle(Request request) {  
        request.addName("HandlerB");  
        nextHandle(request);  
    }  
}

// 请求
@Data  
public class Request {  
    private final List<String> names = new ArrayList<>();  
  
    public void addName(String name) {  
        names.add(name);  
    }  
}

public static void main(String[] args) {  
	Handler handler = Handler.init(new HandlerA(), new HandlerB());  
	Request request = new Request();  
	handler.handle(request);  
	System.out.println(request.getNames());  
}

上面的例子跟链表相像，一个处理器保持有下一个处理器的引用。

另一种实现变体是处理器的引用统一由处理器链管理，处理器链决定处理的顺序。

public interface Handler {  
    void handle(Request request,HandlerChain chain);  
}

public class HandlerA implements Handler{  
    @Override  
    public void handle(Request request, HandlerChain chain) {  
        request.addName("HandlerA");  
        chain.handle(request);  
    }  
}

public class HandlerB implements Handler{  
    @Override  
    public void handle(Request request, HandlerChain chain) {  
        request.addName("HandlerB");  
        chain.handle(request);  
    }  
}

public class HandlerChain {  
    private List<Handler> handlers = new ArrayList<>();  
    // 当前指针  
    int cur=0;  
  
    public void addHandler(Handler handler) {  
        handlers.add(handler);  
    }  
  
    public void handle(Request request){  
        if(cur>=handlers.size()){  
            return;  
        }  
        Handler handler = handlers.get(cur++);  
        handler.handle(request, this);  
    }  
}

public static void main(String[] args) {  
    HandlerChain chain=new HandlerChain();  
    chain.addHandler(new HandlerA());  
    chain.addHandler(new HandlerB());  
    Request request=new Request();  
    chain.handle(request);  
    System.out.println(request.getNames());  
}

责任链变化的地方是处理的流程。

优点是：

  1. 处理的顺序可以随时修改
  2. 方便新增或删除处理者