移动架构之责任链模式

发表于 | 分类于 | |

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

使用场景

  1. 多个对象能够处理同一请求，具体处理则在运行时动态确定
  2. 在请求处理者不明确的时候向多个对象提交同一个请求
  3. 需要动态制定一组对象处理请求

理解实例

这里使用一个传递纸条的过程来得以说明
首先出现了一张纸条，然后纸条开始传递，一直传递到纸条接收者，这样一条责任链就形成了
也就是说在责任链模式里面，重要的建立一条链表
首先创建一个抽象类，其主要是请求的类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public abstract class AbstractRequest {

	private Object object;
	
	public AbstractRequest(Object object) {
		this.object = object;
	}

	//具体的内容对象
	public Object getContent() {
		return object;
	}

	//获取请求级别
	public abstract int getRequestLevel();
}

然后是其具体的请求种类，这里根据其返回值决定是否可以处理，这里写出一个，其他的实现类只是返回值不同

1
2
3
4
5
6
7
8
9
10
11
public class Request1 extends AbstractRequest{

	public Request1(Object object) {
		super(object);
	}

	@Override
	public int getRequestLevel() {
		return 1;
	}
}

定义一个抽象类，又来处理请求，应为要建立链表，所以实现的类必须持有下一个处理类的引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class Handler {

	public Handler nextHandler;

	public  void handleRequest(AbstractRequest abstractRequest) {
		if(getHandleLevel() == abstractRequest.getRequestLevel()) {
			handle(abstractRequest);
		}else {
			if(nextHandler != null) {
				nextHandler.handleRequest(abstractRequest);
			}else {
				System.out.println("所有的处理对象都不能处理它");
			}
		}
	}

	//每个处理者的对象的具体处理方式
	public abstract void handle(AbstractRequest abstractRequest);

	//每个处着对象处理的级别
	public abstract int getHandleLevel();
}

然后是实现这个抽象类的具体类，这里也只写了一个处理类，每个处理类也只有获取等级这个方法返回值不同

1
2
3
4
5
6
7
8
9
10
11
12
public class Handler1 extends Handler{

	@Override
	public void handle(AbstractRequest abstractRequest) {
		System.out.println("handle1处理请求: " + abstractRequest.getRequestLevel());
	}

	@Override
	public int getHandleLevel() {
		return 1;
	}
}

然后是在调用者的地方初始化这条责任链，其必须保证这条链的完整性，形成一条单向的链

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Client {
	public static void main(String[] args) {
		//确定链式关系
		Handler handler1 = new Handler1();
		Handler handler2 = new Handler2();
		Handler handler3 = new Handler3();

		handler1.nextHandler = handler2;
		handler2.nextHandler = handler3;
		
		AbstractRequest request = new Request3("请求3");
		handler1.handleRequest(request);
	}
}

Donate comment here