关于拦截器的一点总结

拦截器，本质上是由反射（动态代理）完成的。
手写一个简单的拦截器来了解拦截器工作的流程。
拦截器执行的步骤大体如下。
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();
    }
}

测试结果