关于拦截器的一点总结

拦截器，本质上是由反射（动态代理）完成的。

手写一个简单的拦截器来了解拦截器工作的流程。

拦截器执行的步骤大体如下。

1：声明拦截器要拦截的目标，以及拦截器。

2：将拦截器与目标绑定。生成代理类。

3：执行代理类的invoke方法。

4：在代理类中声明拦截器的处理器（将被代理对象，被代理对象的方法，参数传入）

5：执行拦截器的方法并将拦截器的处理器作为参数传入拦截器。

6：执行处理器的方法。

声明拦截目标接口及实现类。声明拦截器，并且声明bind及普通执行方法，并为普通执行方法绑定处理器。

package target;

public interface Target {

public void sayHello();
}

package target;
public class TargetImpl implements Target {
@Override
public void sayHello() {
System.out.println("hello, world fuck your asshole!");
}
}

声明处理器，并声明处理器执行方法，方法中是执行反射处来的被代理对象真正执行的方法。

package invocation;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Invocation {
private Object object;
private Method method;
private Object[] args;
public Invocation(Object object,Method method,Object[] args){
this.object=object;
this.method=method;
this.args=args;
}
public Object doWork() throws IllegalAccessException, IllegalArgumentException, InvocationTargetException{
return method.invoke(object, args);
}

}

声明拦截器

package interceptor;

import java.lang.reflect.InvocationTargetException;

import invocation.Invocation;

public interface Interceptor {
public Object bind(Interceptor this,Object object);
public Object dosomething(Invocation invocation) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;

}

声明代理类并在invoke方法中执行拦截器方法。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import interceptor.Interceptor;
import invocation.Invocation;

public class ProxyTarget implements InvocationHandler{
private Object object;
private Interceptor interceptor;
public ProxyTarget(Object object,Interceptor interceptor){
this.object=object;
this.interceptor=interceptor;
}
public static Object bind(Object object,Interceptor interceptor){
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), new ProxyTarget(object,interceptor));
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Invocation invocation = new Invocation(object,method,args);
return interceptor.dosomething(invocation);
}

}

声明拦截器的实现类，如Log，当然也可以加上比如事物之类的。

package interceptor;

import java.lang.reflect.InvocationTargetException;

import invocation.Invocation;
import target.ProxyTarget;

public class LogInterceptor implements Interceptor {

@Override
public Object bind(Object object) {
return ProxyTarget.bind(object, this);
}

@Override
public Object dosomething(Invocation invocation) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
System.out.println("do some Log");
return invocation.doWork();
}

}

测试

package test;

import org.junit.Test;

import interceptor.Interceptor;
import interceptor.LogInterceptor;
import target.Target;
import target.TargetImpl;

public class test {
@Test
public void test(){
Interceptor i = new LogInterceptor();
Target target = new TargetImpl();
target = (Target) i.bind(target);
target.sayHello();
}
}

测试结果