利用JAVA反射原理手动实现一个拦截器(Interceptor)

实现一个拦截器必须要实现一下几个类：
1 目标类接口：目标类要实现的接口。

package com.lanvis.reflect;
public interface ITarget {
    public void doSthing();
    public void doOthing();
}

2 目标类：目标类是要被拦截的类。它实现了目标类接口。

package com.lanvis.reflect;
public class Target implements ITarget {
    public void doOthing() {
        System.out.println("doOthing");
    }
    public void doSthing() {
        System.out.println("doSthing");
    }
}

3 拦截器类：目标类中的方法被拦截之后，执行拦截器中的方法。

package com.lanvis.reflect;
public class Interceptor {
    public void before(){
        System.out.println("before");
    }
    public void after(){
        System.out.println("after");
    }
}

4 处理器类：正是处理器把拦截器和目标类耦合在一起。

package com.lanvis.reflect;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyHandler implements InvocationHandler{
    private Object object;
    private Interceptor interceptor=new Interceptor();
    public void setObject(Object object) {
        this.object = object;
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object result=null;   
        interceptor.before();
        result=method.invoke(object, args);
        interceptor.after();
        return result;
    }
}

5 代理类：程序执行时真正执行的是代理类，代理类是实现了拦截器的流程的类。

package com.lanvis.reflect;
import java.lang.reflect.Proxy;
public class MyProxy {
    public Object getProxy(Object object) {
        MyHandler myHandler = new MyHandler();
        myHandler.setObject(object);
        return Proxy.newProxyInstance(object.getClass().getClassLoader(),
                object.getClass().getInterfaces(), myHandler);
    }
}

6 测试类：用来测试拦截器成功与否。

package com.lanvis.reflect;
public class Test {
    public static void main(String[] args){
        ITarget target=new Target();
        MyProxy myProxy=new MyProxy();
        ITarget proxy=(ITarget)myProxy.getProxy(target);
        proxy.doSthing();
        proxy.doOthing();
    }
}

注：认真学习java反射机制，这很重要。