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

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

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

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

过滤器:

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