13518219792
JDK动态代理的原理是什么，针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。
成都创新互联长期为成百上千客户提供的网站建设服务，团队从业经验10年，关注不同地域、不同群体，并针对不同对象提供差异化的产品和服务；打造开放共赢平台，与合作伙伴共同营造健康的互联网生态环境。为七里河企业提供专业的做网站、成都网站制作，七里河网站改版等技术服务。拥有十多年丰富建站经验和众多成功案例,为您定制开发。
java对设计模式--代理模式的实现，只能针对接口进行代理。代理模式：提供一个代理对象来持有目标对象的引用，通过对代理对象的操作可以达到操作目标对象的目的。使用代理模式主要是使用者不想或者不能直接操作目标对象，需要一个代理的中间对象来维持联系。例如Mybatis中Mapper接口并没有实现类，因此使用者不能直接操作实现类，所以会产生一个代理Mapper。又例如Spring AOP中的Bean，使用者想对Bean的使用进行增强或者其他处理，于是Spring需要返回一个的代理Bean来完成目的。
一接口：
public interface ITodo {
void doString(String desc);
}一实现：
public class Todo implements ITodo {
@Override
public void doString(String desc) {
System.out.println("doString: " + desc);
}
}目标，对接口的原有方法进行增强。实现方式：JDK动态代理
一代理工具类：
public class ProxyInstance implements InvocationHandler {
// 代理目标，即被代理类
private Object target;
// 代理类持有被代理类
public ProxyInstance(Object target) {
this.target = target;
}
public T getProxy(){
// 获取实例方式，这里使用newProxyInstance
return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
// 这里为代理的处理流程
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("proxy before");
Object obj=method.invoke(target,args);
System.out.println("proxy after");
return obj;
}
} public class Test {
public static void main(String[] args) {
// 开启保存代理中生成文件的代码
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
ITodo todo = new ProxyInstance(new Todo()).getProxy();
todo.doString("------ nothing-------- ");
}
}proxy before doString: ------ nothing-------- proxy after
通过控制台就可以看到接口原有的方法被增强了，方法执行之前和执行之后执行其他代码。这就是JDK的动态代理功能。JDK动态代理的使用组件：一接口、一实现、一代理工具类，并且需要遵循以下规则：
作为参数传入
代理类需要使用Proxy的构造方法获取实例
一般使用newProxyInstance
定义代理处理逻辑
用于通过反射生成代理类的方法
因此只能代理接口中已定义的方法
接口的所有方法都会被重写为final类型
用于加载新生成的代理类$Proxy{n}
参数1： 类加载器
参数2： 接口Class数组
参数3： InvocationHandler接口实现类
构造参数为被代理类实现的接口
代理类调用的对象是Proxy类产生的实例,与被代理类不是一个对象
每次调用都需要通过反射来调用
public Object invoke(Object proxy, Method method, Object[] args)
proxy为JDK生成的代理对象$Proxy{n}对象,因此是动态的，只存在于内存中
Method为JDK例如反射获取的调用方法
args为调用方法的参数
因为该类是生成的，所有需要类加载器从新加载
对上面的示例，查看其生成的代理类源码如下
package com.sun.proxy;
import cn.tinyice.demo.proxy.jdk.ITodo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
// 代理对象集成java.lang.reflect.Proxy并实现了被代理对象的父接口
// 这里调整了方法位置，便于分析
public final class $Proxy0 extends Proxy implements ITodo {
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
static {
// 需要对接口的equals、toString、hashCode和 目标方法进行重写，因此先获取原方法的运行时表示java.lang.reflect.Method
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("cn.tinyice.demo.proxy.jdk.ITodo").getMethod("doString", Class.forName("java.lang.String"));
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
// 构造器入参：InvocationHandler实例即代理类实例
public $Proxy0(InvocationHandler var1) throws {
// 判断InvocationHandler不为空，然后赋给变量h
super(var1);
}
// ----------------------------------------- 代理主要关注点： 目标方法 重写 ------------------------
public final void doString(String var1) throws {
try {
// super.h=InvocationHandler实例，调用其invoke方法,该方法为用户重写的方法
// 三个参数来源确定： proxy=this,method = target的method,args=参数的Object数组（发生类型转换）
super.h.invoke(this, m3, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
// ----- equals、toString、hashCode 重写，实质调用 InvocationHandler的对应方法-------
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 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 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);
}
}
}源码部分主要分为四部分
新生成的代理类定义为：public final class $Proxy0 extends Proxy implements ITodo {...},就是重新生成一个新的接口实现类，对原有实现类进行功能复制、增强。
equals、hashCode、toString这三个方法是Object方法，主要是验证Java对象的唯一性，与原来的实现类已经不是一个内存地址了以及其他操作。
doString是原有实现类的方法
InvocationHandler就是使用者编写的代码，这一步就是切入
所有被重写的方法都变为了final类型。所有的方法都调用了InvocationHandler的invoke方法。因此这个invoke方法就是增强的核心方法。
了解以上内容基本可以知道JDK动态代理的底层原理了。一句话：重写方法调用自定义的invoke来实现增强
调用入口：获取代理类
public static Object newProxyInstance(ClassLoader loader,Class[] interfaces, InvocationHandler h) throws IllegalArgumentException { ... }核心代吗
Class cl = getProxyClass0(loader, intfs);
↓
proxyClassCache.get(loader, interfaces)
proxyClassCache在Proxy类中静态定义
