`

责任链模式_过滤器模式

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

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

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);

相关推荐

    责任链模式(Chain of Responsibility Pattern) 1. 责任链模式概述 1.1 定义 1.2 基本思想 2. 责任链模式的结构 3. 责任链模式的UML类图 4. 责任链模

    责任链模式(Chain of Responsibility Pattern) 1. 责任链模式概述 1.1 定义 ...9.1 责任链模式与装饰器模式 9.2 责任链模式与组合模式 9.3 责任链模式与命令模式 10. 实战案例:ATM取款流程 11. 总结

    责任链模式 ChainFilter

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

    责任链模式demo

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

    责任链模式小demo

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

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

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

    设计模式-拦截过滤器

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

    责任链模式在过滤器链中的实现.pdf

    文档支持目录章节跳转同时还支持阅读器左侧大纲显示和章节快速定位,文档内容完整、条理清晰。文档内所有文字、图表、函数、目录等元素均显示正常,无任何异常情况,敬请您放心查阅与使用。文档仅供学习参考,请勿...

    深入浅出JAVA责任链模式

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

    责任链模式

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

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

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

    23钟设计模式之责任链模式

    责任链模式是一种行为设计模式,它允许将请求沿着处理者对象的链式结构传递,直到某个对象能处理这个请求。在这个模式中,每个处理者对象都包含对下一个处理者的引用,可以将请求直接传递给下一个处理者,或者根据...

    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....

    23设计模式软件工程设计模式详解:创建型、结构型与行为型模式在Java编程中的应用与实例分析

    结构型模式涵盖适配器模式、桥接模式、过滤器模式、组合模式、装饰器模式、外观模式、享元模式和代理模式,用于处理类与对象的组合。行为型模式涉及责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘...

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

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

Global site tag (gtag.js) - Google Analytics