//责任链---要么承担责任作出响应,要么向下传递请求。

//责任链模式屏蔽了请求的处理过程,你发起一个请求到底是谁处理的,这个你不用关心,只要你把请求抛给责任链的第一个处理者,最终会返回一个处理结果(当然也可以不做任何处理),作为请求者可以不用知道到底是需要谁来处理的,这是责任链模式的核心
缺点: 调试有点小不爽

public class Main { 


 public static void main(String[] args) { 

 String msg = "adfasdf,斯蒂芬森的 敏感 >"; 


 MsgProcessor mp = new MsgProcessor(); 

 mp.setMsg(msg); 

 msg = mp.process(); 

 System.out.println(msg); 

 } 


} 


public class MsgProcessor { 

 private String msg; 


 /** 

 * 问题:这里的过滤规则会老是被动态的指定 

 * @return 

 */ 

 public String process(){ 

 //处理html tag 

 msg = msg.replace("<", "[") 

 .replace(">", "]"); 


 //process sensetive word 

 msg = msg.replace("敏感", "**"); 


 return msg; 

 } 


 public String getMsg() { 

 return msg; 

 } 

 public void setMsg(String msg) { 

 this.msg = msg; 

 } 


} 


/*process里面的流程因需求的不同而不同,所以最好能想要的时候就插上,不想要的时候就拔去,基于这种需求,接口是最好的方式 

*/ 


//下面是改进的东西 


public interface Filter { 

 String doFilter(String msg); 

}//这相当于一个标准件,是这类东西的接口规则 


public class HTMLFilter implements Filter { 


 public String doFilter(String msg) { 


 //处理html tag 

 msg = msg.replace("<", "[") 

 .replace(">", "]"); 


 return msg; 

 } 


}//这是一个接口的实现,也就是一个被解耦的外部功能 


public class MsgProcessor { 

 private String msg; 


 //定义 插座,插座里面当然是放接口的实现,所以改动的地方只有插座 

 Filter[] filters = new Filter[]{new HTMLFilter(),new SensetiveFilter()}; 


 public String process(){//这个里面就是如何来用这个插座,你可以顺序的用 


 for(Filter f : filters){ 

 msg = f.doFilter(msg); 

 } 

 return msg; 

 } 


 public String getMsg() { 

 return msg; 

 } 

 public void setMsg(String msg) { 

 this.msg = msg; 

 } 


} 


//再改进,插座升级,原来简单的数组插座,被封装成一个类,并让他更加智能化 

public class FilterChain { 


 List<Filter> filters = new ArrayList<Filter>();//数组形式的责任链,他通过一个index来驱动请求向下执行 


 public FilterChain add(Filter f){ 

 filters.add(f); 

 return this; //返回this的好处是:可以链式编程 

 } 


 public String doFilter(String msg){ 

 for(Filter f : filters){ 

 f.doFilter(msg); 

 } 

 return msg; 

 } 


} 

//注意,这里MsgProcessor是业务逻辑类,不过在这个例子中有些多余,因为业务太简单 

public class Main { 


 public static void main(String[] args) { 

 String msg = "adfasdf,操,爱上对方答复 < 敏感 >"; 


 MsgProcessor mp = new MsgProcessor(); 

 mp.setMsg(msg); 

 FilterChain filterChain = new FilterChain();//插座是个类,所以要new 出来 

 filterChain.add(new HTMLFilter()) 

 .add(new SensetiveFilter()); 

 msg = mp.process(filterChain); 

 System.out.println(msg); 

 } 

} 


/*注意:在我们的生活中,一个插座是可以插到另外一个插座上面去的,这意味着插座也是一个接口的实现,所以我们的FilterChain可以这样 

*/ 

public class FilterChain implements Filter 


/* 

需求又要变更了,我们现在的Filter 拥有了两个过滤功能,一个是在消息过去的时候过滤,一个是在消息回来的时候过滤。要求Filter中的两个过滤功能一个第i个位置被调用,一个在第n-i个位置被调用,也就是经过一个来回。。。。。 

怎么办呢,我们想到堆栈的方式,也就是嵌套,把嵌套盒子的左边看成一个过滤网,盒子右边看成一个过滤网,那么嵌套就很形象的解决了这个问题。 

*/ 

public class FilterChain {//因为是数组型责任链,那么他来维护这个index,并导致请求向下传递 


 List<Filter> filters = new ArrayList<Filter>(); 

 int index = -1; 

 public FilterChain add(Filter f){ 

 filters.add(f); 

 return this; //返回this的好处是:可以链式编程 

 } 


 public void doFilter(Request request,Response response,FilterChain fc){ 

 filters.get(++index).doFilter(request, response, fc); 

 } 

}//这个插座永远管理着遍历的规则,这里的遍历规则就是遍历下一个 


public class SensetiveFilter implements Filter{ 


 public String doFilter(Request request,Response response,FilterChain fc) { 

 //process sensetive word 

 request.requestStr = request.requestStr.replace("敏感", "**");//---过滤网 

 //下面这句话也可以不写,因为是否驱动向下传递完全取决于你自己 

 fc.doFilter(request, response, fc);//由fc驱动下一个 

 //response dosomething----过滤网 

 return request.requestStr; 

 } 

}



//--------------------------另一个维度来看责任链-------------------------------------------------------------------

来自设计模式之禅

中国古代对妇女制定了“三从四德”的道德规范,“三从”是指“未嫁从父、既嫁从夫、夫死从子”。
所以我们先定义一个女人类

public class Women { 

 private int type; //1--未出嫁 2--出嫁 3---夫死 

 private String request = ""; 


 public Women(int type,String request){ 

 this.type= type; 

 this.request = request; 

 } 

 .......setter/getter 

}



夫,父,子都可以出来Women的请求,但请求的方式不同,所以这里拥有方法级别的变量

public interface IHandler{ 

 public void HandlerMessage(IWomen women); 

} 

public class Father implements IHandler{ 

 public void HandlerMessage(IWomen women){ 

 System.out.println("女儿的请示"+women.getRequest()); 

 System.out.println("父亲的答复是:同意"); 

 } 

} 

。。。。。。 


public class Client{ 

 public static void main(String[] args){ 

 Random rand = new Random(); 

 ArrayList<IWomen> list = new ArrayList(); 

 for(int i=0;i<5;i++){ 

 list.add(new Women(rand.nextInt(4)),"我要出去逛街"); 

 } 

 IHandler father = new Father(); 

 IHandler husband = new Hasband(); 

 IHandler son = new Som(); 

 for(IWomen women:list){ 

 if(women.getType() ==1){ 

 System.out.println("----女儿向父亲请示"); 

 father.HandleMessage(women); 

 }else if(women.getType() == 2){ 

 System.out.println("----妻子向丈夫请示"); 

 hasband.HandleMessage(women); 

 }else if(women.getType == 3){ 

 System.out.println("----母亲向儿子请示"); 

 son.HandleMessage(women); 

 }else{ 

 //暂时什么也不做 

 } 

 } 

 } 

}



注意:上面有这么多if..else....显然不怎么好,我们应该把if..else分解到各自的类中,如果不是自己管的范围,那么向下传递,把传递分散到每个类中,而不是想上面一样用一个额外的类来维护。。。filterChain其实也是一个额外维护传递的类哈。。。。
改进。。。

public abstract class Handler{ 

 private int level =0; 

 private Handler nextHandler; //下一个责任人 

 public Handler(int level){ 

 this.level = level; 

 } 

 public final void HandlerMessage(IWomen women){ //哈哈,这里是模板方法哈,把算法定死了 

 if(women.getType() == this.level){ 

 this.response(women); 

 }else{ 

 if(this.nextHandler !=null){ 

 this.nextHandler.HandlerMessage(women); 

 }else{ 

 System.out.println("-------不处理----"); 

 } 

 } 

 } 

 //每个相应不同哈 

 public abstract void response(IWomen women); 

} 


public class Father extends Handler{ 

 public Father(){ 

 super(1); 

 } 


 public void response(IWomen women){ 

 System.out.println("--女儿请示父亲--"); 

 System.out.println(women.getRequest()); 

 System.out.println("父亲的答复:同意"); 

 } 

} 

...... 

public class Client{ 

 public static void main(String[] args){ 

 Random rand = new Random(); 

 ArrayList<IWomen> list = new ArrayList(); 

 for(int i=0;i<5;i++){ 

 list.add(new Women(rand.nextInt(4)),"我要出去逛街"); 

 } 

 Handler father = new Father(); 

 Handler husband = new Hasband(); 

 Handler son = new Som(); 

 father.setNext(husband); 

 husband.setNext(son); 

 for(IWomen women:list){ 

 father.HandlerMessage(women); 

 } 

 } 

}



经验例子:责任链在实际的项目中使用也是比较多的,我曾经做过这样一个项目,界面上有一个用户注册功能,注册用户分两种,一种是VIP 用户,也就是在该单位办理过业务的,一种是普通用户,一个用户的注册要填写一堆信息,VIP 用户只比普通用户多了一个输入项:VIP 序列号,注册后还需要激活, VIP 和普通用户的激活流程也是不同的,VIP 是自动发送邮件到用户的邮箱中就算激活了,普通用户要发送短信才能激活,为什么呢?获得手机号码以后好发广告短信呀!这个功能项目组就采用了责任链模式,甭管从前台传递过来的是VIP 用户信息还是普通用户信息,统一传递到一个处理入口,通过责任链来完成任务的处理