`

责任链模式_过滤器模式

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

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

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 用户信息还是普通用户信息,统一传递到一个处理入口,通过责任链来完成任务的处理


分享到:
评论
1 楼 JamesQian 2014-06-19  
Line:103

f.doFilter(msg);
是否需要修改为
msg = f.doFilter(msg);

相关推荐

    责任链模式demo

    责任链模式(Chain of ...通过责任链模式,过滤器可以灵活地组合和扩展,实现多种功能的拦截和处理,同时保持代码结构清晰,符合开闭原则。在实际开发中,掌握过滤器的使用能有效提高Java Web应用的功能性和可维护性。

    责任链模式小demo

    责任链模式是一种设计模式,它允许我们通过定义一系列处理对象(过滤器)形成一个链,这些对象依次处理请求,而发送者无需知道哪个对象具体处理请求。这种模式将请求的发送者与接收者解耦,增加了系统的灵活性和可...

    设计模式之责任链模式(Chain)

    例如,在Web开发中,过滤器(Filter)机制就是一种典型的责任链模式应用,每个过滤器可以对请求进行预处理或后处理,决定是否继续传递给下一个过滤器。 总结来说,责任链模式是一种有效的解耦手段,它提供了一种...

    责任链模式 ChainFilter

    总结起来,"责任链模式 ChainFilter"是一种让多个对象有机会处理请求的设计模式,它通过建立一个过滤器链,实现了请求的顺序处理。在IT行业中,特别是在Web开发中,这种模式被广泛应用于权限控制、日志记录、性能...

    设计模式-拦截过滤器

    拦截过滤器模式(Interceptor Filter Pattern)基于责任链模式,通过创建一个过滤器链,每个过滤器都实现一个共同的接口,这个接口定义了对请求进行处理的方法。当请求到达时,它会依次通过这个过滤器链,每个过滤器...

    深入浅出JAVA责任链模式

    ### 深入浅出JAVA责任链模式 #### 一、引言 责任链模式是一种在软件设计领域中常见的设计模式之一,它主要用于处理请求的传递过程,通过一系列的处理者对象来完成请求的处理任务。本文将详细介绍JAVA中的责任链...

    责任链模式

    ### 责任链模式详解 #### 概述 责任链模式是一种常用的行为设计模式,其核心在于构建一系列处理者对象来处理特定的请求。在这一模式中,每个处理者对象都能够选择处理请求或者将其传递给下一个处理者,从而形成一...

    名为责任链或者拦截器或者过滤器的简单模拟

    以上的这些功能,通过一种名为责任链或者拦截器或者过滤器(语义上的区别而技术上没有什么区别,知道做了什么就行了)的设计模式可以实现,那么就来看看什么是责任链的设计模式。 以下内容参考北京尚学堂的马士兵...

    Java设计模式责任链模式共7页.pdf.zip

    在Java编程中,责任链模式被广泛应用于事件处理、命令模式实现以及过滤器系统等场景。 首先,让我们深入理解责任链模式的基本概念。在责任链模式中,通常有一个或多个处理者(Handler)类,每个处理者都有一个处理...

    责任链设计模式开发的demo

    责任链设计模式是一种行为设计模式,它允许将请求沿着处理者对象的链进行发送,每个对象都可以选择处理请求或将其...在给定的代码示例中,开发者已经实现了一个简单的责任链模式,这对于学习和理解该模式非常有帮助。

    [行为型模式] 责任链模式的理解

    责任链模式是一种行为设计模式,它允许我们把请求沿着处理者链进行传递,直到某个处理者处理这个请求。这种模式让请求的发送者和接收者解耦,因为发送者无需知道哪个对象会处理请求,而接收者也无需知道请求来自哪里...

    java设计模式之责任链(chain of responsibility)

    而MVC框架中的过滤器(Filter)机制也是责任链模式的一个典型应用,多个过滤器按照顺序执行,处理HTTP请求。 总的来说,责任链模式通过将请求的发送者与接收者解耦,使得系统更具有扩展性和灵活性。开发者可以根据...

    Java中的责任链设计模式.docx

    在Spring框架中,除了过滤器链,还有其他地方运用了责任链模式,例如AOP(面向切面编程)中的通知链。通过定义不同的通知类型(前置通知、后置通知、异常通知等),Spring可以按照预设的顺序执行这些通知,形成一个...

    管道过滤器的实现java

    这个模式基于“责任链”概念,允许我们创建一系列相互连接的过滤器,每个过滤器执行特定的操作,然后将结果传递给下一个过滤器。在Java中,我们可以使用`java.io`包中的`FilterInputStream`、`FilterOutputStream`等...

    Java设计模式之责任链模式(Chain of Responsibility模式)介绍

    6. **应用场景**:责任链模式常用于事件处理、过滤器系统(如HTTP中间件)、权限控制等领域。例如,在Web应用中,多个过滤器可以组成一个链,依次处理请求,每个过滤器可以决定是否继续传递请求给下一个过滤器。 7....

    JAVA设计模式之责任链模式详解

    4. **应用场景**:责任链模式适用于需要多级审批、过滤器系统、事件处理等场景。例如,在Web开发中,过滤器链可以用来处理HTTP请求,每个过滤器可以进行如身份验证、权限检查、数据格式校验等操作,只有当所有过滤器...

    第17章_职责链模式.ppt

    在实际应用中,职责链模式可以广泛应用于事件驱动系统、工作流系统等场景,例如在Web应用程序中,请求可能经过过滤器链,每个过滤器负责处理特定的任务,如身份验证、日志记录、数据校验等,直到请求到达最终的目标...

    JAVA代码实现管道过滤器

    - **责任链模式**:过滤器链也可以被视为责任链模式的应用,每个过滤器都是链上的一个节点,决定是否处理数据或传递给下一个过滤器。 5. **最佳实践**: - **错误处理**:确保每个过滤器都有适当的错误处理机制,...

    J2EE 设计模式精解_EN

    1. **过滤器链**:拦截过滤器模式的核心是过滤器链,它按顺序执行每个过滤器。请求首先经过一系列预定义的过滤器,然后到达业务处理组件,最后返回响应时也会经过相应的后处理过滤器。 2. **过滤器接口**:每个过滤...

Global site tag (gtag.js) - Google Analytics