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

最新推荐文章于 2025-07-04 13:04:22 发布

原创最新推荐文章于 2025-07-04 13:04:22 发布 · 1.8k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #代理 #过滤器 #拦截器

java 专栏收录该内容

10 篇文章

订阅专栏

本文探讨了过滤器和拦截器的区别，过滤器侧重于请求处理，依赖容器调用；拦截器侧重于对象方法调用，通过动态代理实现。文中提供了具体的代码示例，展示了责任链模式和动态代理的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

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

过滤器:

/**
 * 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