public class ProxySubject implements InvocationHandler {
private Object target;
/**
* @param obj
* 真实对象
* @return 代理对象
*/
public Object bind(Object obj) {
this.target = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
}
/*
* 返回调用实例方法的返回值
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return method.invoke(target);
}
}
动态代理实现原理
//动态代理类的参数类型
private static final Class<?>[] constructorParams ={ InvocationHandler.class };
protected InvocationHandler h;
//构造方法私有化,不允许外部实例化对象,单例设计
private Proxy() {
}
//有参的也被被封装起来,用protecct貌似是为了方便吧子类调用
protected Proxy(InvocationHandler h) {
Objects.requireNonNull(h);
this.h = h;
}
//提供统一的获取代理类的实例方法(摘要主要的方法,其他省略)
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException {
//类似有getClass,Class.forName()的一个获取Class对象的方法
Class<?> cl = getProxyClass0(loader, intfs);
//反射获得构造
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
//代理类返回实例化对象
return cons.newInstance(new Object[]{h});
}
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}
//它将通过proxyclassfactory创建代理类
// 给定的接口存在,从缓存中获取
return proxyClassCache.get(loader, interfaces);
}
private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
KeyFactory获得类加载器和接口
ProxyClassFactory 获得真正的代理类
//这是代理类工厂类
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
//定义的名字前缀
private static final String proxyClassNamePrefix = "$Proxy";
// 生成的数,跟在$Proxy这个名字之后,JDK动态代理类的名字都是 $ProxyN (N=0,1,2,3,4,5,6,7,8)
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<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
//判断Class对象是否代表的是一个接口
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;
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");
}
}
}
if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//产生本地字节文件
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
//按照产生的字节码文件来产生动态代理类
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);
} catch (ClassFormatError e) {
throw new IllegalArgumentException(e.toString());
}
}
}
public static byte[] generateProxyClass(final String name,
Class[] interfaces)
{
ProxyGenerator gen = new ProxyGenerator(name, interfaces);
// 这里动态生成代理类的字节码,比较复杂
final byte[] classFile = gen.generateClassFile();
// 把所生成的代理类的字节码保存到硬盘上
if (saveGeneratedFiles) {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
try {
FileOutputStream file =
new FileOutputStream(dotToSlash(name) + ".class");
file.write(classFile);
file.close();
return null;
} catch (IOException e) {
throw new InternalError(
"I/O exception saving generated file: " + e);
}
}
});
}
// 返回代理类的字节码
return classFile;
}
JNI调用原生态方法
private static native Class<?> defineClass0(ClassLoader loader, String name,byte[] b, int off, int len);