设计模式——责任链（ChainOfResponsibility）学习笔记

经验：一定要写才能学得会。

           先写测试。（《极限编程》）

以BBS论坛为例：

import com.linux_lihuafeng.dp.filter.MsgProcessor;

public class Main {

 public static void main(String []args){
  String msg = "大家好:),<script>,敏感词，被就业，看不见大家 ";     1
  MsgProcessor mp = new MsgProcessor();                                       6
  mp.setMsg(msg);                                                                              7
  String result = mp.process();                                                            8
  System.out.println(result);                                                                 9
 }
}

package com.bjsxt.dp.filter;

public class MsgProcessor {

 private String msg;                                                                  3
 
 public String getMsg() {                                                           4
  return msg;
 }

 public void setMsg(String msg) {                                             5
  this.msg = msg;
 }

 public String process(){                                                           2

 
  //process <>                                                                            10
  String result = msg.replace('<', '[').replace('>', ']');                  11
  

 

  //process   A

  //process   B

  //process   C                                                                          很麻烦，需要想一种办法将这个过程封装起来

  return result;                                                                          
 }
}

写的顺序：

 

很麻烦，需要想一种方法将这个过程封装起来

package com.bjsxt.dp.filter;

public interface Filter {

 //定义一系列规则来实现接口，接口的实现可以将字符串做任意的处理，反馈出一个新的字符串
 String doFilter(String str);
}

可以将每一个处理过成写成一个类，，来继承接口

package com.bjsxt.dp.filter;

public class HTMLFilter implements Filter{

 @Override

//doFilter是一个过滤规则
 public String doFilter(String str) {
  // TODO Auto-generated method stub
  //process <>
  String result = str.replaceAll("<", "[");
  result = result.replace(">", "]");
  return result;
 }

}

这时MsgProcessor类的process方法也会跟着变化

package com.bjsxt.dp.filter;

public class MsgProcessor {

 private String msg ="";
 
 public String getMsg() {
  return msg;
 } 
 

 public void setMsg(String msg) {
  this.msg = msg;
 }

 public String process(){
  String result = new HTMLFilter().doFilter(msg);
  //process <>
//  String result = msg.replaceAll("<", "[");
//  result = result.replace(">", "]");
//  //process the sensitive words
//  String []sen = {"被就业","搞基","敏感"};
  for(int i = 0 ; i < sen.length ; i++){
   result = result.replaceAll(sen[i], "就业");
   
  }
//  result = result.replace("被就业", "就业");
  
  return result;
 }
}

再次添加一个过程如：B

package com.bjsxt.dp.filter;

public class SensitiveFilter implements Filter{

 @Override
 public String doFilter(String str) {
  
  String result = str ;
  String []sen = {"被就业","搞基","敏感"};
  for(int i = 0 ; i < sen.length ; i++){
   result = result.replaceAll(sen[i], "就业");
   
  }
  return result;
 }

}

package com.bjsxt.dp.filter;

public class MsgProcessor {

 private String msg ="";
 
 public String getMsg() {
  return msg;
 }
 

 public void setMsg(String msg) {
  this.msg = msg;
 }

 public String process(){
  String result = new HTMLFilter().doFilter(msg);
  result = new SensitiveFilter().doFilter(msg);
  //process <>
//  String result = msg.replaceAll("<", "[");
//  result = result.replace(">", "]");
//  //process the sensitive words
//  String []sen = {"被就业","搞基","敏感"};
//  for(int i = 0 ; i < sen.length ; i++){
//   result = result.replaceAll(sen[i], "就业");
//   
//  }
//  result = result.replace("被就业", "就业");
  
  return result;
 }
}

根据以上规律得知，，我们一直添加过滤规则，，，那么我们可以建一个Filters数组，，来保存filters

修改代码如下：

package com.bjsxt.dp.filter;

public class MsgProcessor {

 private String msg ="";
 
 
 private Filter []filters  = {new HTMLFilter() , new SensitiveFilter()};
 
 public String getMsg() {
  return msg;
 }
 

 public void setMsg(String msg) {
  this.msg = msg;
 }

 public String process(){
//  String result = new HTMLFilter().doFilter(msg);
//  result = new SensitiveFilter().doFilter(msg);

  String result = msg ;
  for(int i = 0 ; i < filters.length ; i++){
   result = filters[i].doFilter(result);
  }

for循环的另一种写法

//  for(Filter f:filters){
//   result = f.doFilter(result);
//  }

  return result;

}

}

当多个消息进入在一起的时候，，构成了filter链   {new HTMLFilter（），  new SensitiveFilter（）， 。。。}    优点：过滤规则可任意排序、任意扩展

对于下面的情况，需要在一条责任链之间插入一条责任链：

 

解决方案：增加一个FilterChain类

package com.bjsxt.dp.filter;

import java.util.ArrayList;
import java.util.List;

public class FilterChain {

 List<Filter> filters = new ArrayList<Filter>();
 
 public FilterChain  addFilter(Filter filter) {
  this.filters.add(filter);

  return this;
 }
 public String doFilter(String str) {
  String result = str ;
  for(Filter f:filters){
  result = f.doFilter(str);
  }
  return result ;
 }
}

相应地还需要修改：

package com.bjsxt.dp.filter;

public class Main {

 public static void main(String []args){
  String msg = "大家好:),<script>,敏感，被就业，网络授课没感觉，因为看不见大家 ";
  MsgProcessor mp = new MsgProcessor();
  mp.setMsg(msg);
  FilterChain fc = new FilterChain();
  //
  
  fc.addFilter(new HTMLFilter()).addFilter(new SensitiveFilter());
  
  mp.setFc(fc);
  String result = mp.process();
  System.out.println(result);
 }
}

package com.bjsxt.dp.filter;

public class MsgProcessor {

 private String msg ;
 
 
 private FilterChain fc ;
// private Filter []filters  = {new HTMLFilter() , new SensitiveFilter()};
 
 public String getMsg() {
  return msg;
 }
 

 public FilterChain getFc() {
  return fc;
 }

 public void setFc(FilterChain fc) {
  this.fc = fc;
 }

 public void setMsg(String msg) {
  this.msg = msg;
 }

 public String process(){
//  String result = new HTMLFilter().doFilter(msg);
//  result = new SensitiveFilter().doFilter(msg);

//  String result = msg ;
//  for(int i = 0 ; i < filters.length ; i++){
//   System.out.println();
//   result = filters[i].doFilter(result);
//  }
//  for(Filter f:filters){
//   result = f.doFilter(msg);
//  }
  
  return fc.doFilter(msg);
 }
}
 

对于以下情况：

信息由客户端处理后，传到服务器端

信息再由服务器端处理后，传到客户端

先完成对请求的处理：

package com.bjsxt.dp.filter;

public interface Filter {

 //定义一系列规则来实现接口，接口的实现可以将字符串做任意的处理，反馈出一个新的字符串
 void doFilter(Request request, Response response);
}



package com.bjsxt.dp.filter;

import java.util.ArrayList;
import java.util.List;

public class FilterChain implements Filter{

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

 public FilterChain addFilter(Filter filter) {
  this.filters.add(filter);
  return this ;
 }
 public String doFilter(String str) {
  String result = str ;
  
  return result ;
 }
 @Override
 public void doFilter(Request request, Response response) {
  
  for(Filter f:filters){
    f.doFilter(request,response);
   }
  
 }
}

package com.bjsxt.dp.filter;

public class HTMLFilter implements Filter{

 @Override
 public void doFilter(Request request, Response response) {
 
  request.requestStr = request.requestStr.replaceAll("<", "[").replaceAll(">","]");
  
  
 }

}

package com.bjsxt.dp.filter;

public class SensitiveFilter implements Filter{

 @Override
 public void doFilter(Request request, Response response) {
  // TODO Auto-generated method stub
  String []sen = {"被就业","搞基","敏感"};
  for(int i = 0 ; i < sen.length ; i++){
   request.requestStr = request.requestStr.replaceAll(sen[i], "就业");
   
  }
 }

}

分析解决方得知，，可在doFilter方法中加一条链条FilterChain chain   该链条可以获取所有的filter  ，也就是加一个index之后  就可以

得到该filter的下一个filter了。从而达到先处理request  HTMLFilter        resquest SensitiveFilter    之后处理  Response  SensitiveFilter    Response  HTMLFilter  的目的了

经过分析之后，，代码再次修改如下：

package com.bjsxt.dp.filter;

public class Main {

 public static void main(String []args){
  String msg = "大家好:),<script>,敏感，被就业，网络授课没感觉，因为看不见大家 ";
//  MsgProcessor mp = new MsgProcessor();
//  mp.setMsg(msg);
  Request request = new Request();
  request.setRequestStr(msg);
  Response response = new Response();
  response.setResponseStr("response");
  FilterChain fc = new FilterChain();
  //
  
//  fc.addFilter(new HTMLFilter()).addFilter(new SensitiveFilter());
  
  fc.addFilter(new HTMLFilter()).addFilter(new SensitiveFilter());

  fc.doFilter(request, response, fc);
//  mp.setFc(fc);
//
//  String result = mp.process();
  System.out.println(request.getRequestStr());
  System.out.println(response.getResponseStr());
  
  
  
 }
}

package com.bjsxt.dp.filter;

public interface Filter {

 //定义一系列规则来实现接口，接口的实现可以将字符串做任意的处理，反馈出一个新的字符串
 void doFilter(Request request, Response response, FilterChain chain);
 
}

package com.bjsxt.dp.filter;

public class HTMLFilter implements Filter{

 @Override
 public void doFilter(Request request, Response response, FilterChain chain) {
 
  request.requestStr = request.requestStr.replaceAll("<", "[").replaceAll(">","]")+"---HTMLFilter() --requrst";
  chain.doFilter(request, response, chain);
  response.responseStr = response.responseStr += "---HTMLFilter()  ---response";
  
  
 }

}

package com.bjsxt.dp.filter;

public class HTMLFilter implements Filter{

 @Override
 public void doFilter(Request request, Response response, FilterChain chain) {
 
  request.requestStr = request.requestStr.replaceAll("<", "[").replaceAll(">","]")+"---HTMLFilter() --requrst";
  chain.doFilter(request, response, chain);
  response.responseStr = response.responseStr += "---HTMLFilter()  ---response";
  
  
 }

}



经验：先学脉络  后学细节

学框架，应该先学框架、后学思想