先上一个标准用法
接口
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 文件之后，就能一清二楚的知道整个调用逻辑了