【设计模式】【12】责任链模式

应用场景

责任链模式，英文名Responsibility Chain Pattern

该模式将多个接收者连接成一条处理链，请求依次经过这些接收者，直到有接收者处理它

这种模式将请求和处理解耦开来，并且允许存在多个处理者，可以很灵活地决定谁去处理，如何处理

我们只要对齐稍加修改，就可以实现更加高级灵活的功能，比如

• 多个接收者依次对请求进行处理，每个接收者只负责处理请求的一部分
• 接收者可以对请求进行拦截，决定后面的接收者要不要继续对请求进行处理
• 请求类可以扮演一个初级产品的角色，处理者可以扮演一个加工者的角色，每个处理者都对产品进行一次加工，最后得到一个最终产品

在代码中，可以通过List或Next指针等方式，来实现链结构

实现代码一

Request交给首个Handler处理，然后首个Handler决定是自己处理，还是交给NextHandler处理，如此循环

	public class Request {
	
	}
	
	public class Response {
	
	}

	public abstract class Handler {
	
	    @Setter
	    protected Handler next;
	
	    abstract public Response handle(Request request);
	
	    protected boolean hasNext() {
	        return next != null;
	    }
	
	    abstract protected boolean willHandle(Request request);
	}
	
	public class HandlerA extends Handler {
	
	    @Override
	    public Response handle(Request request) {
	        if (willHandle(request))
	            return new Response();
	        if (hasNext())
	            return next.handle(request);
	        return null;
	    }
	
	    @Override
	    protected boolean willHandle(Request request) {
	        return false;
	    }
	}
	
	public class HandlerB extends Handler {
	
	    @Override
	    public Response handle(Request request) {
	        if (willHandle(request))
	            return new Response();
	        if (hasNext())
	            return next.handle(request);
	        return null;
	    }
	
	    @Override
	    protected boolean willHandle(Request request) {
	        return true;
	    }
	}
	
	public class HandlerC extends Handler {
	
	    @Override
	    public Response handle(Request request) {
	        if (willHandle(request))
	            return new Response();
	        if (hasNext())
	            return next.handle(request);
	        return null;
	    }
	
	    @Override
	    protected boolean willHandle(Request request) {
	        return true;
	    }
	}

	public class APP {
	
	    public static void main(String[] args) {
	        Request request = new Request();
	        Handler h1 = new HandlerA();
	        Handler h2 = new HandlerB();
	        Handler h3 = new HandlerC();
	        h1.setNext(h2);
	        h2.setNext(h3);
	        Response response = h1.handle(request);
	    }
	}

实现代码二

多个Handler依次对Request进行处理，只要其中一个对Request进行了处理，处理流程结束

	public class Request {
	
	    public boolean consumed = false;
	
	    public void consume() {
	        this.consumed = true;
	    }
	}

	public abstract class Handler {
	
	    abstract public void handle(Request request);
	
	    abstract protected boolean willHandle(Request request);
	}
	
	public class HandlerA extends Handler {
	
	    @Override
	    public void handle(Request request) {
	        if (willHandle(request))
	            System.out.print("A handle");
	    }
	
	    @Override
	    protected boolean willHandle(Request request) {
	        return false;
	    }
	}
	
	public class HandlerB extends Handler {
	
	    @Override
	    public void handle(Request request) {
	        if (willHandle(request))
	            System.out.print("B handle");
	        request.consume();
	    }
	
	    @Override
	    protected boolean willHandle(Request request) {
	        return true;
	    }
	}
	
	public class HandlerC extends Handler {
	
	    @Override
	    public void handle(Request request) {
	        if (willHandle(request))
	            System.out.print("C handle");
	    }
	
	    @Override
	    protected boolean willHandle(Request request) {
	        return true;
	    }
	}

	public class APP {
	
	    public static void main(String[] args) {
	        Request request = new Request();
	        LinkedList handlers = new LinkedList();
	        handlers.add(new HandlerA());
	        handlers.add(new HandlerB());
	        handlers.add(new HandlerC());
	        for (Handler handler : handlers) {
	            handler.handle(request);
	            if (request.consumed)
	                break;
	        }
	    }
	}