jdk动态代理invoke方法自动运行原因

想要知道 invoke方法为什么会自动调用我们先要来了解一下这个方法
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)

首先 该方法来自于接口InvocationHandler ，该接口中仅有一个invoke方法 ，该方法中有三个参数

* @param   proxy the proxy instance that the method was invoked 

这是接口源码注释中对第一个参数proxy的解释：方法被调用的代理实例   我们可以认为它就是一个代理实例

但是代理又是什么呢？这时候可能有小伙伴蒙了。
代理实例其实是代理类本身的一个实例，下面是我自己写的一个动态代理小案例

这是一个接口，动态代理必须有一个接口的存在

public interface PorxyInte { 
   
    public void test();
}

这是一个实现了接口的实现类，写的有些简便，主要看起来清晰

public class ProImp implements PorxyInte { 
   
    @Override
    public void test() { 
   
        System.out.println("test");
    }
}

  ProImp proImp = new ProImp();//创建了实例类对象
        PorxyInte porxyInte =(PorxyInte) Proxy.newProxyInstance(ProImp.class.getClassLoader(), ProImp.class.getInterfaces(), new InvocationHandler() { 
   
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
   
                System.out.println("..."+proxy.getClass().getName());//输出proxy对象的字节码文件名
                Method[] declaredMethods = this.getClass().getDeclaredMethods();
                for (Method declaredMethod : declaredMethods) { 
   
                    System.out.println(declaredMethod.getName());
                }

                method.invoke(proImp,null);
                return null;
            }
        });
        System.out.println(porxyInte.getClass().getName());//输出实现类的字节码文件名
        porxyInte.test();

com.sun.proxy.$Proxy0 // 实现类的字节码文件名
...com.sun.proxy.$Proxy0// 参数proxy的字节码文件名

在这边我们发现我自己定义的实现类和参数proxy的字节码文件名是一致的

而根据前面对参数proxy的注释定义，我们不难得出$Proxy0就是一个代理类

那么为什么我调用了.newProxyInstance方法会生成一个代理对象呢？

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

  Class<?> cl = getProxyClass0(loader, intfs);

public final class $Proxy0 extends Proxy
	implements PorxyInte
{ 
   

	private static Method m1;
	private static Method m3;
	private static Method m2;
	private static Method m0;
    // 看到这个构造方法, 调用了父类Proxy构造方法，将我们得invocationhandler实例传值过去
    //那这个构造方法触发的时机就是在 
    // proxy得代理方法中 return cons.newInstance(new Object[]{h}); 通过反射来执行代理类得构造方法，
    //从而将invocationhandler实例从代理类赋值到父类，
    //也就是为什么在下面test方法中在super.h 这个不会产生空指针得重要原因
	public $Proxy0(InvocationHandler invocationhandler)
	{ 
   
		super(invocationhandler);
	}

	public final boolean equals(Object obj)
	{ 
   
		try
		{ 
   
			return ((Boolean)super.h.invoke(this, m1, new Object[] { 
   
				obj
			})).booleanValue();
		}
		catch (Error ) { 
    }
		catch (Throwable throwable)
		{ 
   
			throw new UndeclaredThrowableException(throwable);
		}
	}

	public final void test()
	{ 
   
		try
		{ 
   
			super.h.invoke(this, m3, null);
			return;
		}
		catch (Error ) { 
    }
		catch (Throwable throwable)
		{ 
   
			throw new UndeclaredThrowableException(throwable);
		}
	}

	public final String toString()
	{ 
   
		try
		{ 
   
			return (String)super.h.invoke(this, m2, null);
		}
		catch (Error ) { 
    }
		catch (Throwable throwable)
		{ 
   
			throw new UndeclaredThrowableException(throwable);
		}
	}

	public final int hashCode()
	{ 
   
		try
		{ 
   
			return ((Integer)super.h.invoke(this, m0, null)).intValue();
		}
		catch (Error ) { 
    }
		catch (Throwable throwable)
		{ 
   
			throw new UndeclaredThrowableException(throwable);
		}
	}

	static 
	{ 
   
		try
		{ 
   
			m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { 
   
				Class.forName("java.lang.Object")
			});
			m3 = Class.forName("cn.itcast.web.Test.PorxyInte").getMethod("test", new Class[0]);
			m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
			m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
		}
		catch (NoSuchMethodException nosuchmethodexception)
		{ 
   
			throw new NoSuchMethodError(nosuchmethodexception.getMessage());
		}
		catch (ClassNotFoundException classnotfoundexception)
		{ 
   
			throw new NoClassDefFoundError(classnotfoundexception.getMessage());
		}
	}
}

注意：我们可以发现这个生成的类继承了proxy 并且实现了我自己定义的那个接口
这是因为在调用getProxyClass0 传入的接口数组，他会将这个数组遍历，并且实现


这是他实现的test方法：

public final void test()
	{ 
   
		try
		{ 
   
			super.h.invoke(this, m3, null);
			return;
		}
		catch (Error ) { 
    }
		catch (Throwable throwable)
		{ 
   
			throw new UndeclaredThrowableException(throwable);
		}
	}

  	 super不难理解  是proxy类对象
  	 h ：但是h是什么我相信小伙伴们可能有点懵，这里留下个悬念，我们先把newProxyInstance方法聊完

	刚刚说过newProxyInstance第一步返回了$proxy引用对象

	第二步：

   //通过反射创建出构造器对象，并且传入constructorParams 类型参数
     private static final Class<?>[] constructorParams =
        { 
    InvocationHandler.class };
        
  final Constructor<?> cons = cl.getConstructor(constructorParams);//这是$proxy0的构造方法内部通过super(constructorParams) 创建父类对象
  

  

  

  //细心的小伙伴可能发现了，我们刚刚在$proxy中的h，在Proxy中进行了赋值
  //其实这个h就是我们在调用newProxyInstance方法是传进来的第三个参数
 
   final InvocationHandler ih = h;

最后一步：   return cons.newInstance(new Object[]{h});
通过反射 返回$proxy的实例

这个就是我们在掉用newProxyInstance方法所做的事情

 porxyInte.test();

	public final void test()
	{ 
   
		try
		{ 
   
			super.h.invoke(this, m3, null);
			return;
		}
		catch (Error ) { 
    }
		catch (Throwable throwable)
		{ 
   
			throw new UndeclaredThrowableException(throwable);
		}
	}

	return (String)super.h.invoke(this, m2, null);