Java设计模式--责任链模式

　　在责任链模式中，由每个对象及其下一个对象的引用连接形成一条责任链。客户端发出的请求将在这个链上进行传递。在这个过程中，每个对象可选择处理该事件，或放弃并交由下一级处理，直至处理完毕返回结果。

示例
1.handler父类，定义处理方法

CostHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package org.mamba.handler;
/**
 * 花费处理类
 * @author mamba
 *
 */
public abstract  class CostHandler {

	/**处理对象，用于引用其后继对象*/
	protected CostHandler handler;

	/**
	 * 请求处理方法
	 * @param money
	 * 申请的经费
	 */
	public abstract void handleRequest(float money);
	
	public void setHandler(CostHandler handler) {
		this.handler = handler;
	}
	

	
}

2.实际处理类（责任链的组成部分）

StuffHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package org.mamba.handler;

/**
 * 普通职员处理
 * 
 * @author mamba
 *
 */
public class StaffHandler extends CostHandler {

	@Override
	public void handleRequest(float money) {
		if (money <= 1000) {
			System.out.println(money+"申请成功" + this.getClass().getName() + "已处理");
		} else {
			handler.handleRequest(money);
		}

	}

}

LeaderHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package org.mamba.handler;

/**
 * 组长处理
 * @author mamba
 *
 */
public class LeaderHandler extends CostHandler {

	@Override
	public void handleRequest(float money) {
		if (money <= 5000) {
			System.out.println(money+"申请成功" + this.getClass().getName() + "已处理");
		} else {
			handler.handleRequest(money);
		}
		
	}

}


BossHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package org.mamba.handler;

/**
 * 老板处理
 * @author mamba
 *
 */
public class BossHandler extends CostHandler{

	@Override
	public void handleRequest(float money) {
		if (money <= 100000) {
			System.out.println(money+"申请成功" + this.getClass().getName() + "已处理");
		} else {
			System.out.println("拒绝申请!"+ this.getClass().getName() + "已处理");
		}
		
	}

}


3.责任链创建工厂，创建责任链并返回责任链的入口对象

CostHandlerFactory
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package org.mamba.factory;

import org.mamba.handler.BossHandler;
import org.mamba.handler.CostHandler;
import org.mamba.handler.LeaderHandler;
import org.mamba.handler.StaffHandler;

/**
 * handler工厂
 * 
 * @author mamba
 *
 */
public class CostHandlerFactory {
	/**
	 * 创建责任链
	 * @return
	 */
	public static CostHandler createHanlerChain() {
		CostHandler stuff = new StaffHandler();
		CostHandler leader = new LeaderHandler();
		CostHandler boss = new BossHandler();
		stuff.setHandler(leader);
		leader.setHandler(boss);
		return stuff;
	}
}

4.请求的对象

ClientRequest
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package org.mamba.client;

import org.mamba.factory.CostHandlerFactory;
import org.mamba.handler.CostHandler;

/**
 * 请求发出方
 * @author mamba
 *
 */
public class ClientRequest {
	public static void main(String[] args) {
		CostHandler handler = CostHandlerFactory.createHanlerChain();
		handler.handleRequest(500);
		handler.handleRequest(5000);
		handler.handleRequest(10000);
		handler.handleRequest(1000000);

	}
}

输出结果

结果 lang;java
1
2
3
4
"500.0申请成功org.mamba.handler.StaffHandler已处理"
"5000.0申请成功org.mamba.handler.LeaderHandler已处理"
"10000.0申请成功org.mamba.handler.BossHandler已处理"
"拒绝申请!org.mamba.handler.BossHandler已处理"

责任链模式的优点：对客户端来说，无需知道是谁处理了它的请求，在结构发生改变的时候，只需要将新的对象加入责任链即可，客户端不用改变依然可以得到返回值。
责任链模式的缺点：由于有多个对象存在这个链中，但多数时候并非所有对象都会被使用，相较于把问题直接提交给对应的对象处理，这样的模式速度更慢。

纯与不纯
如上述例子所述，每个对象仅有两种选择，处理或抛出该问题，每个问题仅会被一个对象处理，则为纯责任链模式。若一个问题在责任链中可以被多个对象处理，则称为不纯的责任链模式。