细说责任链模式
提示：
博主：章飞 _906285288的博客
博客地址：http://blog.csdn.net/qq_29924041
细说责任链模式
想一想你的公司里面的是不是有这样的制度，你要请假，如果你要是请一天假的话，直接找你的直接主管批就行了，如果你请三天假的话，这个时候可能就要你部门的主管批了，如果你想请更长时间的假的话，这个时候可能就需要找到总监或者更高级别的人批示了。每个领导所管辖的范围其实都是有限的。这其实就是责任链模式。每个领导的责任宽度不一样，在请假的批示中，如果某个领导不批的话，那流程也就走完了。
定义
责任链模式:责任链模式是使多个对象都有机会去处理请求，从而避免了请求的发送者与接受者之间的耦合关系。使这些对象像一条链一样传递下去，直到有对象能够处理它为止。
所以：责任链模式，其实就是：要么承担责任做出回应，要么向下传递请求，最终会有环节做出回应
责任链模式屏蔽了请求的处理过程，你发起一个请求到底是谁处理的，这个你不用关心，只要你把请求抛给责任链的第一个处理者，最终会返回一个处理结果（当然也可以不做任何处理），作为请求者可以不用知道到底是需要谁来处理的，这是责任链模式的核心；同时责任链模式也可以做为一种补救模式来使用
UML模型
责任链模式其实重点是这个链，通过ConcreteHandler传递来决定究竟是谁来具体来处理。
场景
场景一
设计模式之禅中的案例，古代女子的三从四德，在家从父，出嫁从夫，夫死从子，即未出嫁的女子，在家里有什么事情一般是请求父亲的指示，而出嫁的女子，一般需要听从丈夫的话，当丈夫去世之后，女子一般是听儿子的话，通过不同阶段的女子，其处理的对象是不一样的。者也就是责任链模式的一种应用场景，最开始从父亲一级传递到丈夫一级，然后再传递到儿子一级。直到某一级能够处理相关业务。代码参考代码一
场景二
在android四大组件中，有一个叫做有序广播的技术，广播这种东西是辐射化的，即只要注册了广播都可以收到，但是有序广播则决定了广播接受的顺序，即有优先级之分也可以被中间拦截，当一级广播收到之后，决定是自己处理还是继续往下广播，二级广播收到一级广播发来的信息后，决定是自己处理，还是继续分发，因此这也是一种在android实际应用场景中经常会遇到的责任链模式的一种系统应用场景。
代码
代码一
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo2;
import src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.IWomen;
public abstract class Handler {
private int level;
private Handler nextHandler;
public Handler(int level) {
this.level = level;
}
public void setNextHandler(Handler mHandler){
this.nextHandler = mHandler;
}
public void HandlerMessage(IWomen mWomen) {
if (mWomen.getType() == this.level) {
this.response(mWomen);
}else {
if (this.nextHandler != null) {
this.nextHandler.HandlerMessage(mWomen);
}else {
System.out.println("----------没地方请示-----------");
}
}
}
public abstract void response(IWomen mWomen);
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo2;
import src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.IWomen;
public class FatherHandler extends Handler{
public FatherHandler() {
super(1);
// TODO Auto-generated constructor stub
}
@Override
public void response(IWomen mWomen) {
// TODO Auto-generated method stub
System.out.println("--------女儿向父亲请示-------");
System.out.println(mWomen.getRequest());
System.out.println("父亲的答复是:同意\n");
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo2;
import src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.IWomen;
public class HusbandHandler extends Handler{
public HusbandHandler() {
super(2);
// TODO Auto-generated constructor stub
}
@Override
public void response(IWomen mWomen) {
// TODO Auto-generated method stub
System.out.println("--------妻子向丈夫请示-------");
System.out.println(mWomen.getRequest());
System.out.println("丈夫的答复是:同意\n");
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo2;
import src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.IWomen;
public class SonHandler extends Handler{
public SonHandler() {
super(3);
// TODO Auto-generated constructor stub
}
@Override
public void response(IWomen mWomen) {
// TODO Auto-generated method stub
System.out.println("--------母亲向儿子请示-------");
System.out.println(mWomen.getRequest());
System.out.println("儿子的答复是:同意\n");
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo1;
public interface IWomen {
public int getType();
public String getRequest();
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo1;
public class Women implements IWomen {
private int type = 0;
private String request = "";
public Women(int type, String request) {
this.type = type;
this.request = request;
// 为了显示好看点，我在这里做了点处理
switch (this.type) {
case 1:
this.request = "女儿的请求是:" + request;
break;
case 2:
this.request = "妻子的请求是:" + request;
break;
case 3:
this.request = "母亲的请求是:" + request;
break;
default:
break;
}
}
public int getType() {
// TODO Auto-generated method stub
return type;
}
public String getRequest() {
// TODO Auto-generated method stub
return request;
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo2;
import java.util.ArrayList;
import java.util.Random;
import src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.IWomen;
import src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.Women;
/**
* 责任链模式，其实就是：要么承担责任做出回应，要么向下传递请求，最终会有环节做出回应，
* 责任链模式角色分布:
* Handler:抽象类，定义出来所有责任人的类型，
* ConcreteHandler:定义出具体的相关责任人
* Request:需要处理的相关事件类
*
* @author Administrator
* 责任链模式屏蔽了请求的处理过程，你发起一个请求到底是谁处理的，这个你不用关心，只要你把请
求抛给责任链的第一个处理者，最终会返回一个处理结果（当然也可以不做任何处理），作为请求者可以不
用知道到底是需要谁来处理的，这是责任链模式的核心
；同时责任链模式也可以做为一种补救模式来使用
注意责任链模式与广播链模式之间的一些区别
*/
public class TestMian {
public static void main(String[] args) {
//随机挑选几个女性
Random rand = new Random();
ArrayList<src.com.zzf.designpattern.chainofresponsibilitypattern.demo1.IWomen> arrayList = new ArrayList();
for(int i=0;i<5;i++){
arrayList.add(new Women(rand.nextInt(4),"我要出去逛街"));
}
Handler mHandler = new FatherHandler();
Handler mHandler2 = new HusbandHandler();
SonHandler sonHandler = new SonHandler();
mHandler.setNextHandler(mHandler2);
mHandler2.setNextHandler(sonHandler);
for(IWomen w:arrayList){
mHandler.HandlerMessage(w);
}
}
}
代码二
一级广播的实现
public class FirstReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
int limit = intent.getIntExtra("limit", -10001);
//如果限制值为10000，则处理，否则交给下一个receiver处理
if(limit == 10000) {
String msg = intent.getStringExtra("msg");
Toast.makeText(context,msg,Toast.LENGTH_SHORT).show();
abortBroadcast();
} else {
//添加信息发送给下一个Receiver
Bundle b = new Bundle();
b.putString("new","Message From FisrtReceiver");
setResultExtras(b);
}
}
}
二级广播的实现
public class SecondReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
int limit = intent.getIntExtra("limit", -10001);
//如果限制值为1000，则处理，否则交给下一个receiver处理
if(limit == 1000) {
String msg = intent.getStringExtra("msg");
Bundle b = getResultExtra(true);
String str = b.getString("new");
Toast.makeText(context,msg + "-----",Toast.LENGTH_SHORT).show();
abortBroadcast();
} else {
//添加信息发送给下一个Receiver
Bundle b = new Bundle();
b.putString("new","Message From SecondReceiver");
setResultExtras(b);
}
}
}
注册广播
<receiver android:name=".broadcast.FirstReceiver">
<intent-filter android:priority="10000">
</action name="com.action.ORDER_BROADCAST">
</intent-filter>
</receiver>
<receiver android:name=".broadcast.SecondReceiver">
<intent-filter android:priority="1000">
</action name="com.action.ORDER_BROADCAST">
</intent-filter>
</receiver>
测试代码就暂时不写了，android发送广播的代码。简单的很
基于UML的代码
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public enum Level {
FIRST_LEVEL,
SECOND_LEVEL,
THIRD_LEVEL
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public class Request {
//请求的等级
public Level getRequestLevel(){
return Level.THIRD_LEVEL;
}
String request;
public Request(String _request){
this.request = _request;
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public class Response {
private String responce;
public Response(String _responce){
this.responce = _responce;
}
public void toResult(){
System.out.println("处理的请求是:"+responce);
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public abstract class Handler {
private Handler nextHandler;
//设置下一个处理的对象
public void setNext(Handler _handler){
this.nextHandler = _handler;
}
//每个处理者都有个处理的级别
protected abstract Level getHandlerLevel();
//每个处理者都必须去实现处理任务
protected abstract Response echo(Request request);
//每个处理者都必须对请求做出处理
public final Response handleMessage(Request request){
Response response = null;
//判断是否是自己处理的级别
if(this.getHandlerLevel().equals(request.getRequestLevel())){
response = this.echo(request);
}else{
if(this.nextHandler != null){
response = this.nextHandler.handleMessage(request);
}else{
//没有适当处理者，业务自行处理
}
}
return response;
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public class ConcreteHandler1 extends Handler{
@Override
protected Level getHandlerLevel() {
// TODO Auto-generated method stub
return Level.FIRST_LEVEL;
}
@Override
protected Response echo(Request request) {
// TODO Auto-generated method stub
return new Response(this.getClass().getName()+"\t"+request.getRequestLevel());
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public class ConcreteHandler2 extends Handler{
@Override
protected Level getHandlerLevel() {
// TODO Auto-generated method stub
return Level.SECOND_LEVEL;
}
@Override
protected Response echo(Request request) {
// TODO Auto-generated method stub
return new Response(this.getClass().getName()+request.getRequestLevel()));
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public class ConcreteHandler3 extends Handler{
@Override
protected Level getHandlerLevel() {
// TODO Auto-generated method stub
return Level.THIRD_LEVEL;
}
@Override
protected Response echo(Request request) {
// TODO Auto-generated method stub
return new Response(this.getClass().getName()+request.getRequestLevel());
}
}
package src.com.zzf.designpattern.chainofresponsibilitypattern.demo3;
public class Test {
public static void main(String[] args) {
Handler concreteHandler1 = new ConcreteHandler1();
Handler concreteHandler2 = new ConcreteHandler2();
Handler concreteHandler3 = new ConcreteHandler3();
concreteHandler1.setNext(concreteHandler2);
concreteHandler2.setNext(concreteHandler3);
Response response = concreteHandler1.handleMessage(new Request("发送请求"));
response.toResult();
}
}
责任链模式应用和注意事项
责任链模式在java或者android中的应用是非常广泛的，在android中的事件传递，广播。在javaEE中的servlet的过滤器Filter等都有应用。
责任链模式非常显著的将请求和结果进行了分离，由每一级决定谁去处理，处理者则不需要去了解具体实现类的全貌。但是它也会带来性能问题，即每一个请求下去，如果链比较长，这个时候不可避免的会影响性能
责任链模式中setNext函数尽可能的添加约束，超过这约束之后，则不允许建立连接，避免无意识的去破坏系统的性能
欢迎继续访问，我的博客
1178
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
