闲来无事，撸撸源码
食用方法
直接看代码吧。。
package com.test.demo.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 每个代理对象 内部都有一个实现了InvocationHandler接口的 类的实例
*
* InvocationHandler 顾名思义就是 代理对象的方法调用的处理类(调用它的invoke方法)
*
* @author lizhecao 2018/4/19
* @version 1.0
*/
public class InvocationHandlerImpl implements InvocationHandler {
// 目标对象
private Object target;
public InvocationHandlerImpl(Object target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 代理方法简单地打下日志，这其实就是spring aop的简单实现
System.out.println("start");
// 调用目标对象的实际方法
Object result = method.invoke(target, args);
System.out.println("end");
return result;
}
/**
* 通过Proxy.newProxyInstance 生成代理对象（重要的方法）
*/
public Object getProxy() {
return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
target.getClass().getInterfaces(), this);
}
public static void main(String[] args) {
// 实例化目标对象
User user = new UserImpl();
// 用目标对象实例化InvocationHandler
InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(user);
// 生成代理对象
User proxyUser = (User) invocationHandler.getProxy();
// 调用代理对象的方法，实际上就是调用了invocationHandler的invoke方法
proxyUser.sayHello();
}
}
package com.test.demo.proxy;
/**
* 目标类的接口，jdk动态代理的类一定要实现某一个接口
*
* @author lizhecao 2018/4/19
* @version 1.0
*/
public interface User {
void sayHello();
}
package com.test.demo.proxy;
/**
* 目标对象的具体类
*
* @author lizhecao 2018/4/19
* @version 1.0
*/
public class UserImpl implements User {
@Override
public void sayHello() {
System.out.println("hello");
}
}
运行了InvocationHandlerImpl中的main方法我们会得到结果：
start
hello
end
理解原理
通过上面的例子可以看到，生成代理对象的重点是
Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
target.getClass().getInterfaces(), this);
这个方法，我们进入这个方法看看jdk动态代理的具体实现。
去繁就简，删掉一些不关注的东西，有兴趣的自己一一过下
/**
* 返回指定接口的代理类实例，并分配方法的调用给指定的invocationHandler
*
* @param loader 用来define代理类的 类加载器
* @param interfaces 代理类要实现的接口（这里也说明了jdk动态代理对象必须实现接口）
* @param h 用来分配方法调用的 invocation handler
* @return 一个实现了特定接口，用特定的class loader define的包含特定的invocation hanlder的代理类的实例
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// 不允许hanlder 为空（不然搞啥）
Objects.requireNonNull(h);
// 防止接口被改
final Class<?>[] intfs = interfaces.clone();
/*
* 查找或生产指定代理类（也就是说有缓存机制）（这里是重点，生产了代理类的Class！！）
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* 用我们的handler 作为proxy class的构造方法的参数，创建proxy class实例
*/
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});
}
继续看这个getProxyClass0(loader, intfs) 是怎么生产代理类的
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
// 接口的数量不能超过65535个（呵呵）
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
// 从WeakCache的缓存中获取，如果没有就创建
return proxyClassCache.get(loader, interfaces);
}
这里是通过WeakCache缓存了代理类的实例，就是这货
/**
* a cache of proxy classes
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
这里简单讲下WeakCache，不然没玩过的朋友可能看不下去了。
WeakCache<K, P, V> 缓存的是<key, sub-key> -> value这样的键值对，key和value是弱引用的，sub-key是强引用的（当然，这不重要）K， P， V分别表示key，参数，value的类型。有人会好奇，那sub-key呢？参数用来干嘛？我们重点看它的构造方法
/**
* @param subKeyFactory 一个这样 (key, parameter) -> sub-key 的函数
* @param valueFactory 一个那样 (key, parameter) -> value的函数
*/
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}
可以看到，只要传入两个函数类，就可以通过key 和 parameter 分别生成 sub-key和value了，这样我们就可以理解生成代理对象的这一句
// 第一次获取proxy class就会通过loader 和 interfaces 分别生成缓存的subkey 和 value， 并且返回value
return proxyClassCache.get(loader, interfaces);
那么我们也知道了这个value是通过valueFactory生成的，参数是loader 和 interface，那么看下proxyClassCache的实例化方法： new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) 就知道了这个ProxyClassFactory类就是真正实现了(loader, interface) -> proxyClass 的函数式类了，赶紧看下
/**
* 使用给定的ClassLoader 和 接口数组来 生成，define，返回代理类的函数工厂
*/
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// 所有代理类名称的前缀（有时候debug不是会经常看到这个名称吗哈哈）
private static final String proxyClassNamePrefix = "$Proxy";
// 代理类名称的后面跟着的整数（自增的序列）
private static final AtomicLong nextUniqueNumber = new AtomicLong();
// 真正搞事情的地方
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* 验证下Class loader根据类的名称 解析出来的 class跟我们传进来的是否一样（相当于看下是不是同一个loader加载的吧）
*/
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
// 如果不一样，抛异常（loader说我不认识这个接口class）
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* 验证是否接口（又强调了一定要是接口吧）
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* 验证是否重复
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}
String proxyPkg = null; // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
/*
* 这下面一大段就是确定下代理类要放在哪个包下
* 如果存在非public的接口，那么proxy class就要放在跟她同一个目录下
* 而且非public的接口一定要在同一个目录下（不然放哪里都有问题）
*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}
// 如果接口都public，那么就是放到com.sun.proxy 包下
if (proxyPkg == null) {
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
/*
* 用原子数字自增产生的一个代理类的唯一的代号
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* 上面啪啦啪啦一大堆，其实都是一些验证啊，确定包的位置啊，名称啊的细碎的东西
* 下面这一句才是重点，通过ProxyGenerator产生了代理类的 class 文件的字节数组
*/
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// 最后通过native方法 来生成Class 对象
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
ProxyGenerator 是sun.misc包里面的方法，没有开源，所以我们简单撸一下即可
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) {
ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2);
// 生成class文件的字节数组
final byte[] var4 = var3.generateClassFile();
// 如果saveGeneratedFiles为true，那么将.class文件写到硬盘中
if (saveGeneratedFiles) {
// 省略具体保存文件方法
}
return var4;
}
看下这个保存文件的条件
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();
也就是说只要我们设置了这个"sun.misc.ProxyGenerator.saveGeneratedFiles" 系统值为true就可以保存文件了
话不多说来看看jdk动态代理给我们自动生成的这个class文件长什么样吧，用以下代码来测试
package com.test.demo.proxy;
import sun.misc.ProxyGenerator;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 写代理类文件到磁盘中
*
* @author lizhecao 2018/4/20
* @version 1.0
*/
public class ProxyClassGen {
public static void main(String[] args) throws IOException {
// // 第一种方法，直接将生成的字节数组写到文件中
// byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy33", UserImpl.class.getInterfaces());
//
// try(FileOutputStream outputStream = new FileOutputStream(
// "/Users/lizhecao/java/demo/src/main/java/com/test/demo/proxy/$Proxy33.class")) {
// outputStream.write(bytes);
// }
// 第二种方法，设置系统属性值，有jdk自动写
System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
ProxyGenerator.generateProxyClass("$Proxy34", UserImpl.class.getInterfaces());
}
}
运行之后可以看到在项目的根目录下产生了$Proxy34.class 这么一个文件，用ide直接打开可以看到如下内容
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
import com.test.demo.proxy.User;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy34 extends Proxy implements User {
private static Method m1;
private static Method m3;
private static Method m2;
private static Method m0;
public $Proxy34(InvocationHandler var1) throws {
super(var1);
}
// 除了接口方法之外，还实现了Object的equals, hashCode和toString方法
public final boolean equals(Object var1) throws {
try {
return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
// 实现了我们的User接口的sayHello方法
public final void sayHello() throws {
try {
// 内部其实就是调用了invokeHandler实例的invoke方法
// 在最下面可以看到m3 就是通过反射获取的User接口的sayHello Method
// Class.forName("com.test.demo.proxy.User").getMethod("sayHello");
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)).intValue();
} 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.test.demo.proxy.User").getMethod("sayHello");
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动态代理就已经是拨开云雾见青天，一清二楚了
感谢以下的博主分享：
JDK动态代理实现原理
本文由博客群发一文多发等运营工具平台 OpenWrite 发布
网友评论