关于动态代理invoke()方法的理解

public interface Dao {  
    public void show ();
    public Object show2();
}

class DaoImpl implements Dao {
    @Override
    public void show() {        
        System.out.println("我是show()");
    }
    @Override
    public Object show2() {
        System.out.println("我是show2()");
        return "111";
    }
}

public class Demo {
    @Test
    public void show() {
        Dao dao = new DaoImpl();
        InvocationHandler h = new DaoHandler(dao);      
        Class[] interfaces = { Dao.class };
        Dao d = (Dao) Proxy.newProxyInstance(this.getClass().getClassLoader(),
                interfaces, h);
        System.out.println(d.show2());
    }
}
class DaoHandler implements InvocationHandler {
    Dao dao = null;
    public DaoHandler(Dao dao) {
        super();
        this.dao = dao;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("代理开始");
        Object result = method.invoke(dao);
        System.out.println("代理结束");
        return null;
    }
}

//Proxy类开始有这样的一个定义
private final static Class[] constructorParams = { InvocationHandler.class };
protected InvocationHandler h;

protected Proxy(InvocationHandler h) {
    this.h = h;
}

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {

    // Proxy类的方法getProxyClass，特别长....根据传入的接口的Class对象与类加载器创建$proxy0类
    Class cl = getProxyClass(loader, interfaces);

    // 通过反射带参数构造传入h实例化$proxy0，$proxy0类的带参构造内部为super(h)，其实就是给Proxy的成员h赋值，并返回此对象
    Constructor cons = cl.getConstructor(constructorParams);
    return (Object) cons.newInstance(new Object[] { h });
}

//$proxy0的源码
public final class $Proxy0 extends Proxy implements Subject {  
    private static Method m1;  
    private static Method m0;  
    private static Method m3;  
    private static Method m2;  
  
    static {  
        try {  
            m1 = Class.forName("java.lang.Object").getMethod("equals",  
                    new Class[] { Class.forName("java.lang.Object") });  
  
            m0 = Class.forName("java.lang.Object").getMethod("hashCode",  
                    new Class[0]);  
  
            m3 = Class.forName("接口的实现类的路径").getMethod("实现类的方法",  
                    new Class[0]);  
  
            m2 = Class.forName("java.lang.Object").getMethod("toString",  
                    new Class[0]);  
  
        } catch (NoSuchMethodException nosuchmethodexception) {  
            throw new NoSuchMethodError(nosuchmethodexception.getMessage());  
        } catch (ClassNotFoundException classnotfoundexception) {  
            throw new NoClassDefFoundError(classnotfoundexception.getMessage());  
        }  
    } //static  
  
    public $Proxy0(InvocationHandler invocationhandler) {  
        super(invocationhandler);  
    }  
  
    @Override  
    public final boolean equals(Object obj) {  
        try {  
            return ((Boolean) super.h.invoke(this, m1, new Object[] { obj })) .booleanValue();  
        } catch (Throwable throwable) {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  
  
    @Override  
    public final int hashCode() {  
        try {  
            return ((Integer) super.h.invoke(this, m0, null)).intValue();  
        } catch (Throwable throwable) {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  
  
    public final void 接口的实现类的方法() {  
        try {  
            super.h.invoke(this, m3, null);  
            return;  
        } catch (Error e) {  
        } catch (Throwable throwable) {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  
  
    @Override  
    public final String toString() {  
        try {  
            return (String) super.h.invoke(this, m2, null);  
        } catch (Throwable throwable) {  
            throw new UndeclaredThrowableException(throwable);  
        }  
    }  
}  

package cn.icast_03;

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

public class ProxyFactory {

    private Object obj;//目标对象
    private BeforeAdvice before;
    private AfterAdvice after;

    public Object newProxyInstance() {

        Object object = Proxy.newProxyInstance(
                this.getClass().getClassLoader(), obj.getClass()
                        .getInterfaces(), new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method,
                            Object[] args) throws Throwable {

                        if (before != null) {
                            before.before();
                        }
                        //result即为接口的真实实现类的返回值
                        Object result = method.invoke(obj, args);
                        
                        if (after != null) {
                            after.after();
                        }

                        return result;
                    }
                });
        //object即为代理对象
        return object;
    }

    public ProxyFactory() {
        super();
        // TODO Auto-generated constructor stub
    }

    public ProxyFactory(Object obj, BeforeAdvice before, AfterAdvice after) {
        super();
        this.obj = obj;
        this.before = before;
        this.after = after;
    }

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }

    public BeforeAdvice getBefore() {
        return before;
    }

    public void setBefore(BeforeAdvice before) {
        this.before = before;
    }

    public AfterAdvice getAfter() {
        return after;
    }

    public void setAfter(AfterAdvice after) {
        this.after = after;
    }

}
//前置增强
interface BeforeAdvice {
    public void before();
}
//后置增强
interface AfterAdvice {
    public void after();
}