public interface Service {
void print();
}
复制代码
public class MyService implements Service {
@Override
public void print() {
System.out.println("this is print");
}
}
复制代码
public class MyHandler implements InvocationHandler {
private Service service;
public MyHandler(Service service){
this.service = service;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("this is before!");
Object result = method.invoke(service, args);
System.out.println("this is after!");
return result;
}
}
复制代码
public static void main(String[] args) {
Service service = new MyService();
Service proxyInstance = (Service) Proxy.newProxyInstance(Demo.class.getClassLoader(), new Class[]{Service.class}, new MyHandler(service));
proxyInstance.print();
}
复制代码
若是不出意外的话，控制台会打印出以下信息java
this is before!缓存
this is printbash
this is after!app
这说明咱们写的方法，获得了加强！ide
不知道你们有没有想过，这行代码函数
Proxy.newProxyInstance(Demo.class.getClassLoader(), new Class[]{Service.class}, new MyHandler(service));
复制代码
返回的到底是个什么东西？源码分析
带着疑问，咱们先使用反射打印一下类名试试。post
System.out.println(proxyInstance.getClass().getName());
复制代码
获得的结果为ui
com.sun.proxy.$Proxy0
复制代码
很显然这个类并非咱们建立的。因此到这儿就应该想到了，动态代理实质，就是使用字节码技术，从新生成了一个新类，来达到加强的效果。this
那么加强的新类究竟是个怎样的类呢？咱们来挖掘一下动态代理的源码。
分析源码的时候我通常都是根据方法的参数和返回值，大体推敲一下方法的功能，这样能够快速找到关键方法。因此后面的代码都是被我精简过的，你们能够对比着源码阅读。
首先进入newProxyInstance方法，在去除掉业务不相干代码后以下：
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
Class<?> cl = getProxyClass0(loader, intfs);
final Constructor<?> cons = cl.getConstructor(constructorParams);
return cons.newInstance(new Object[]{h});
}
复制代码
也就是新类就算这个cl，弄清除cl是啥，动态代理的原理咱们就基本弄懂了。因此跟着这个目标，进入getProxyClass0方法。
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
return proxyClassCache.get(loader, interfaces);
}
复制代码
除去校验的方法外，只剩下一行代码。因此只能在进去看看。在进入以前，先看看proxyClassCache是啥。
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}
复制代码
如今在进入proxyClassCache的get方法里，进入get方法咋一看代码有点多，其实上面都是缓存相关处理（缓存的话我建议等看完主流程再回头看，那样更有助于理解缓存），咱们先跳过，直接看关键代码
while (true) {
if (supplier != null) {
V value = supplier.get();
if (value != null) {
return value;
}
}
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}
if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
supplier = factory;
}
}
}
复制代码
关键代码经简化后如上，这样就能清晰的看出supplier就是new Factory(key, parameter, subKey, valuesMap)的实例。因此进入supplier的get方法。
public synchronized V get() { // serialize access
try {
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
return value;
}
}
复制代码
进入get方法后，关键代码就一句valueFactory.apply(key, parameter)，而这个valueFactory就是上面在建立WeakCache时设置的ProxyClassFactory。因此进入ProxyClassFactory的apply方法。
在apply方法中，终于看到了建立代理类的关键方法
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
复制代码
其中proxyClassFile就是新类的字节码，而defineClass0方法，就是加载这个新类。对于字节码如何构造在这儿我就不深究了。感兴趣的能够本身研究。我更关心新类的结构。因此既然找到了新类的生成方法，咱们就将他打印到文件中瞧一瞧。
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
"ProxyService", new Class[]{Service.class}, Modifier.FINAL);
OutputStream outputStream = new FileOutputStream(new File("d:/JdkProxy.class"));
outputStream.write(proxyClassFile);
复制代码
在d盘下找到这个文件，直接用idea打开。
final class ProxyService extends Proxy implements Service {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public ProxyService(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 print() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
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);
}
}
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m3 = Class.forName("study.demo.jdk_proxy.Service").getMethod("print");
m2 = Class.forName("java.lang.Object").getMethod("toString");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
复制代码
不出意外就会看到如上代码了。其实看到这个代码后，jdk动态代理的本质内心就应该有底了。因此后面就不用再说下去了吧。
下一篇，分析一下cglib动态代理的本质