标签：generator 参数 做了 security stream dac throwable void 自己
先上一个标准用法
接口
public interface Dog { void run(); int eatCount(); boolean eta(String name); }
实现
public class GunDog implements Dog { @Override public void run() { System.out.println("----------------飞奔"); } @Override public int eatCount() { return 5; } @Override public boolean eta(String name) { return false; } }
必须可少的 InvocationHandler 实现
public class MyInvocationHandler implements InvocationHandler { Object target; // 这个为 需要 被 代理 的对象 public void setTarget(Object target){ this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // proxy 为动态代理生产的对象 // 运行的方法 // 方法对应的参数 // 此处的逻辑完全自己掌控，经常的写法包含 写一些 逻辑 ，再 method.invoke(target , args) , 再写一下逻辑 //放回值为方法的放回，可以为 method.invoke(target , args) 的返回值 ，也可以完全 根据 自己需求来写 return null; } }
使用
public class MyProxyFactory { public static Object getProxy(Object target){ InvocationHandler invocationHandler = new MyInvocationHandler(); ((MyInvocationHandler) invocationHandler).setTarget(target); Object o = Proxy.newProxyInstance(target.getClass().getClassLoader() , target.getClass().getInterfaces() , invocationHandler); return o; } public static void main(String[] args) { Dog dog = new GunDog(); Dog proxy = (Dog) MyProxyFactory.getProxy(dog); proxy.run(); System.out.println(proxy.eatCount()==null?null:proxy.eatCount()); proxy.eta("fish"); } }
简单的说明一下把，什么是代理 和 代理模式什么的，我就不说了
就先来看一下，这个代理对象到底是怎样的
public class ZTest { public static void main(String[] args) { m1(); } public static void m1(){ byte[] proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Dog.class}); try (FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class")) { fileOutputStream.write(proxy0s); fileOutputStream.close(); } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }
这样会生产一个 $Proxy0.class 的文件(在哪里自己直接文件搜，看的很，不细说) 。 用itellij idea 打开 这个.class文件
import com.xsz.impl.proxy.Dog; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.lang.reflect.UndeclaredThrowableException; public final class $Proxy0 extends Proxy implements Dog { private static Method m1; private static Method m3; private static Method m4; private static Method m2; private static Method m5; private static Method m0; public $Proxy0(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final void run() throws { try { super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final boolean eta(String var1) throws { try { return (Boolean)super.h.invoke(this, m4, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final Integer eatCount() throws { try { return (Integer)super.h.invoke(this, m5, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m3 = Class.forName("com.xsz.impl.proxy.Dog").getMethod("run"); m4 = Class.forName("com.xsz.impl.proxy.Dog").getMethod("eta", Class.forName("java.lang.String")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m5 = Class.forName("com.xsz.impl.proxy.Dog").getMethod("eatCount"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
这个就是代理对象 反编译后 得到的java 文件的样子了 ，这个 处理 重写 hashCode ，toString ，equals 方法，没什么好说的。
重要的点一，这个对象实现了Dog接口，且重写里面的方法 ，run ，eatCount ，eta
重要点二 ，有 Method 类型的 私有静态 变量 ，在static 构造函数中直接 赋值（赋值简单明白）
重要点三，有一个 InvocationHandler 的构造函数。
再回过头来看 Object o = Proxy.newProxyInstance(target.getClass().getClassLoader() , target.getClass().getInterfaces() , invocationHandler); 做了什么（源码）
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h); final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } /* * Look up or generate the designated proxy class. */ Class<?> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { cons.setAccessible(true); return null; } }); } return cons.newInstance(new Object[]{h}); } catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString(), e); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString(), t); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString(), e); } }
简单分析（这个结合我们$Proxy0 文件看）
返回的是代理对象，代理对象进行调用时 ，如调用 proxy.eta("fish") ，实际调用参考 $Proxy0 文件
这个时后，我们在看看 第二个参数 m4是什么 。
m4 为 静态私有方法，赋值为 static构造函数 中 赋值。
真实 调用就是 我们自己写的 InvocationHandler 中的 invoke 方法。返回结果 直接被 代理对象放回
也就是，我们可以在自己的 InvocationHandler 的实现的invoke中，任意写自己的逻辑。
我个人以前也不太懂代理对象长啥样，怎么就是那样调用的，我想看了 $Proxy0 文件之后，就能一清二楚的知道整个调用逻辑了
还有一点，运行这个程序是会报错的，具体报错原因我就不细说了，反正就是直接返回null造成的
标签：generator 参数 做了 security stream dac throwable void 自己
原文地址：https://www.cnblogs.com/sxrtb/p/14528319.html
