自己实现过滤器和拦截器框架

过滤器和拦截器从效果上来说是十分类似的,都是在执行某个动作之前或者之后可以执行其他的一些逻辑,但是侧重点不一样.

过滤器---侧重于请求,它依赖于容器的调用,以及告诉它将要过的得执行动作

拦截器---侧重于对象的方法,它是限制对象方法的调用所以是用动态代理来实现而不是装饰模式(装饰模式目的是增强功能),所以它不依赖环境,任何对象都可以由它代理,(需要知道被代理类的接口)   以下是代码:

过滤器:

/** * Created by Administrator on 14-2-17. * 过滤器 是过滤请求，核心是函数回调，栈的递归（责任链设计模式） * 拦截器是增强或者说限制类的方法调用。核心是java反射（动态代理） */interface  Fliter{        public void doFliter(String arg,FliterContext fliterContext);}class Fliter1 implements Fliter{    @Override    public void doFliter(String arg, FliterContext fliterContext) {        System.out.println("执行过滤器1");        fliterContext.doFliter(arg,fliterContext);        System.out.println("结束--执行过滤器1");    }}class Fliter2 implements Fliter{    @Override    public void doFliter(String arg, FliterContext fliterContext) {        System.out.println("执行过滤器2");        fliterContext.doFliter(arg,fliterContext);        System.out.println("结束--执行过滤器2");  }}class  FliterContext implements Fliter{    Iterator<Fliter> iterator = null;    public FliterContext(){        Fliter2 f2 = new Fliter2();        Fliter1 f1 = new Fliter1();        ArrayList<Fliter> arrayList = new ArrayList<Fliter>();        arrayList.add(f1);        arrayList.add(f2);        this.iterator =  arrayList.iterator();    }    @Override    public void doFliter(String arg, FliterContext fliterContext) {        if(iterator.hasNext()){            Fliter fliter = iterator.next();            fliter.doFliter(arg,fliterContext);        }else {            //调用action            System.out.println("调用Action");        }    }}

这里用到了责任链设计模式,(多个对象组成的链,用户的请求在链中传递,可以处理就处理,否则交给下一个对象),其实就是用栈来实现递归调用

测试:

public class test {    public static void main(String [] args){        FliterContext fc = new FliterContext();        fc.doFliter("dd",fc);    }}

执行结果:

执行过滤器1执行过滤器2调用Action结束--执行过滤器2结束--执行过滤器1

拦截器:

 

/** * Created by Administrator on 14-2-17. * 此拦截器 的依次执行是befor和after方法分别循环调用实现，主要是迭代器的使用，没有用栈递归 * 代理类由jdk提供的动态代理（动态代理设计模式）生成 */interface Interceptor{    public Object before();    public Object after();}class Interceptor1 implements Interceptor{    public Object before(){        System.out.println("开始-拦截器1");        return null;    }    public Object after(){        System.out.println("结束-拦截器1");        return null;    }}class Interceptor2 implements Interceptor{    public Object before(){        System.out.println("开始-拦截器2");        return null;    }    public Object after(){        System.out.println("结束-拦截器2");        return null;    }}interface Person{    public void sayHello();}class Person1 implements Person{    public void sayHello(){        System.out.println("你好");    }}class ProxyHandle implements InvocationHandler{    private Object object = null;    private ListIterator<Interceptor> interceptorIterator = null;    public ProxyHandle(Object object) {        this.object = object;        ArrayList<Interceptor> arrayList = new ArrayList<Interceptor>();        arrayList.add(new Interceptor1());        arrayList.add(new Interceptor2());        this.interceptorIterator = arrayList.listIterator();    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        Object oo = null;        while(interceptorIterator.hasNext()){            Interceptor interceptor = interceptorIterator.next();            interceptor.before();        }          oo =  method.invoke(object,args);        while (interceptorIterator.hasPrevious()){            Interceptor interceptor = interceptorIterator.previous();            interceptor.after();        }        return oo;    }    public  Object getProxy(){        return Proxy.newProxyInstance(Person1.class.getClassLoader(), Person1.class.getInterfaces(), this);    }}

这里迭代器的使用极大的简化了操作

测试:

public class test2 {    public static void main(String [] args){        Person1 p1 = new Person1();        ProxyHandle proxyHandle = new ProxyHandle(p1);        //Psrson1 必须实现接口 不然会出现类型转换错误        Person proxy = (Person) proxyHandle.getProxy();        proxy.sayHello();    }}

测试结果:

开始-拦截器1开始-拦截器2你好结束-拦截器2结束-拦截器1