动态的 职责链模式

职责链模式

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

责任链模式降低了请求的发送端和接收端之间的耦合，使多个对象都有机会处理这个请求。

角色

• 抽象处理者(Handler)角色
  定义出一个处理请求的接口。 如果需要，接口可以定义出一个方法，以设定和返回对下家的引用。这个角色 通常由一个抽象类或接口实现。
• 具体处理者(ConcreteHandler)角色
  具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。
  由于具体处理者持有对下家的引用，因此，如果需要， 具体处理者可以访问下家。

本质

• 分离职责，动态组合

优点

• 请求者和接收者松散耦合
• 动态组合职责

缺点

• 产生很多细粒度对象
• 不一定能被处理
  需要提供默认处理

处理请示的接口：

public class Handler {

	protected Handler successor;
	
	public void setSuccessor(Handler successor) {
		this.successor=successor;
	}
	public void HandleRequest(int request) {}
}

具体处理请求的类：

public class ConcreteHandler1 extends Handler {

	public void HandleRequest(int request) {
		if (request >= 0 && request < 10) {
			System.out.println("ConcreteHandler1 处理了请求" + request);
		} else if (successor != null) {
			successor.HandleRequest(request);
		}
	}
}

public class ConcreteHandler2 extends Handler {

	public void HandleRequest(int request) {
		if (request >= 10 && request < 20) {
			System.out.println("ConcreteHandler2 处理了请求" + request);
		} else if (successor != null) {
			successor.HandleRequest(request);
		}
	}
}

public class ConcreteHandler3 extends Handler {

	public void HandleRequest(int request) {
        if (request >= 20 && request < 30) {
            System.out.println("ConcreteHandler3 处理了请求" + request);
        } else if (successor != null) {
            successor.HandleRequest(request);
        }
    }
}

测试类：

public class Main {
	public static void main(String[] args) {
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        h1.setSuccessor(h3);
        h3.setSuccessor(h2);

        int[] requests = {1, 2, 3, 11, 12, 13, 21, 22, 23, 99};
        for (int request : requests) {
            h1.HandleRequest(request);
        }
    }
}