手写JDK动态代理
一，JDK动态代理
在纯手写动态代理前，首先分析一套标准JDK动态代理的执行流程。
1，目标类顶层接口
public interface ProxyInterface {
public void targetMethod();
}2，目标类
public class JDKProxyTarget implements ProxyInterface{
@Override
public void targetMethod() {
System.out.println("代理方法...");
}
}3，代理类
public class JDKProxy {
private ProxyInterface proxyInterface;
public JDKProxy(ProxyInterface proxyInterface) {
this.proxyInterface = proxyInterface;
}
public Object instanceProxy() {
System.out.println("代理方法开始...");
ProxyInterface instance = (ProxyInterface) Proxy.newProxyInstance(
proxyInterface.getClass().getClassLoader(),
proxyInterface.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
method.invoke(proxyInterface, args);
System.out.println("代理方法结束...");
return null;
}
});
return instance;
}
}4，测试类
public class JDKProxyTest {
public static void main(String[] args) throws Exception {
JDKProxy proxy = new JDKProxy(new JDKProxyTarget());
ProxyInterface proxyInterface = (ProxyInterface) proxy.instanceProxy();
System.out.println(proxyInterface.getClass());
proxyInterface.targetMethod();
}
}
5，代码解析
a，Proxy.newInstance()方法
* 第一个参数为目标类的类加载器
* 第二个参数为目标类的接口集合，JDK动态代理目标类必须实现一个接口，这是为了保证生成的代理类和目标类之前的强一致性关系
* 第三个参数为InvocationHandler接口的实现类，这里直接通过匿名内部类实现，重写了invoke方法
b，InvocationHandler接口实现类
* 实现该类必须重写invoke()方法，动态代理实现在代理类中该接口的实现类调用该方法，并在该方法中反射执行该方法完成整个动态代理流程；
* 第一个参数为生成的动态代理对象；
* 第二个参数为动态代理在客户端执行的方法；
* 第三个参数为该方法的参数列表；
* 通过反射来完成方法调用；
c，通过a步骤后，JDK会虚拟生成一个$Proxy0类，该类也实现了目标类实现的接口，从而多态返回该虚拟类对象，可以通过代码输出该类
* 代码
public class JDKProxyTest {
public static void main(String[] args) throws Exception {
JDKProxy proxy = new JDKProxy(new JDKProxyTarget());
ProxyInterface proxyInterface = (ProxyInterface) proxy.instanceProxy();
System.out.println(proxyInterface.getClass());
proxyInterface.targetMethod();
byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{ProxyInterface.class});
FileOutputStream outputStream = new FileOutputStream("E:\\$Proxy0.class");
outputStream.write(bytes);
outputStream.close();
}
}* $Proxy0类 --- 生成为.class文件，直接通过IDEA进行反编译
public final class $Proxy0 extends Proxy implements ProxyInterface {
private static Method m1;
private static Method m2;
private static Method m3;
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})).booleanValue();
} 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 void targetMethod() throws {
try {
super.h.invoke(this, m3, (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", new Class[]{Class.forName("java.lang.Object")});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("com.gupao.designpattern.proxy.jdk.ProxyInterface").getMethod("targetMethod", new Class[0]);
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
d， 可以看到该虚拟类继承Proxy类并实现了目标类顶层接口，并反射获取了目标类中的所有方法的Method对象；
e， 同时，虚拟类也同时重写了目标类的所有方法，并通过下列方式进行调用
super.h.invoke(this, m3, (Object[])null);super ： 指该代理类的超类，也就是Proxy；
h ： 点进源码可以看到这样一行声明
protected InvocationHandler h;在虚拟类的构造器中，也获取了InvocationHandler的引用，所以，这里的h，指的也就是在匿名内部类定义的实现类对象；
h.invoke()：就是调用匿名内部类中重写的invoke()方法，分别传递参数该对象(this)，执行的方法(method)，方法参数(null)；
二，手写动态代理步骤分析
从上面标准的JDK动态流程可以看出，手写动态代理，需要这样几个类
1，SelfProxy类，定义newInstance()方法，进行代理对象创建
* 在该方法中首先需要输出代理类的.java文件
* 编译该.java文件生成.class文件
* 通过类加载器加载该.class文件
* 生成该.class文件的事例对象作为代理对象返回
2，SelfInvocationHandler接口，定义invoke()方法，在代理类中进行目标方法调用
* 在.java文件中，定义构造器，传递该类引用
* 通过SelfInvocationHandler实现类对象调用invoke()方法，实现代理方式的方法调用
3，SelfClassloader，自定义类加载器，继承JDK的ClassLoader类，实现自定义的加载方式
4，SelfJDKProxy，实现SelfInvocationHandler接口，重写invoke()方法，实现最终方法运行
三，手写动态代理代码实现
1，目标类顶层接口
public interface SelfProxyInterface {
public void targetMethod();
}2，目标类
public class SelfJDKProxyTarget implements SelfProxyInterface{
@Override
public void targetMethod() {
System.out.println("代理方法...");
}
}3，SelfClassLoader类 -- 自定义类加载器，加载.class到JVM内存中
public class SelfClassLoader extends ClassLoader{
private File classPathFile;
public SelfClassLoader() {
String classPath = SelfClassLoader.class.getResource("").getPath();
this.classPathFile = new File(classPath);
}
@Override
protected Class findClass(String name) throws ClassNotFoundException {
String className = SelfClassLoader.class.getPackage().getName() + "." + name;
if (null != classPathFile) {
File classFile = new File(classPathFile, name + ".class");
if (classFile.exists()) {
FileInputStream in = null;
ByteArrayOutputStream out = null;
try {
in = new FileInputStream(classFile);
out = new ByteArrayOutputStream();
byte[] bytes = new byte[1024];
int len;
while((len = in.read(bytes)) != -1) {
out.write(bytes, 0, len);
}
return defineClass(className, out.toByteArray(), 0, out.size());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (null != in) {
in.close();
}
if (null != out) {
out.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
return null;
}
}
4，SelfProxy类 -- 生成虚拟代理类，创建代理对象
public class SelfProxy {
private static final String ENTER = "\r\n";
public static Object newInstance(SelfClassLoader classLoader, Class[] interfaces, SelfInvocationHandler h) {
try {
// 动态生成源代码
String srcClass = generateSrc(interfaces);
// 输出Java文件
String filePath = SelfProxy.class.getResource("").getPath() + "$ProxyO.java";
System.out.println(filePath);
FileWriter fileWriter = new FileWriter(filePath);
fileWriter.write(srcClass);
fileWriter.flush();
fileWriter.close();
// 编译Java文件为class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
Iterable iterable = fileManager.getJavaFileObjects(filePath);
JavaCompiler.CompilationTask task = compiler.getTask(null, fileManager, null, null, null, iterable);
task.call();
fileManager.close();
// 加载编译生成的class文件到JVM
Class proxyClass = classLoader.findClass("$ProxyO");
Constructor constructor = proxyClass.getConstructor(SelfInvocationHandler.class);
// 删掉虚拟代理类
File file = new File(filePath);
file.delete();
// 返回字节码重组以后的代理对象
return constructor.newInstance(h);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private static String generateSrc(Class[] interfaces) {
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("package com.gupao.designpattern.proxy.self;" + ENTER + ENTER);
stringBuilder.append("import com.gupao.designpattern.proxy.jdk.ProxyInterface;" + ENTER);
stringBuilder.append("import java.lang.reflect.Method;" + ENTER);
stringBuilder.append("public class $ProxyO implements " + interfaces[0].getName() + "{" + ENTER);
stringBuilder.append("SelfInvocationHandler h;" + ENTER);
stringBuilder.append("public $ProxyO(SelfInvocationHandler h) {" + ENTER);
stringBuilder.append("this.h = h;" + ENTER);
stringBuilder.append("}" + ENTER);
for (Method method : interfaces[0].getMethods()) {
stringBuilder.append("public " + method.getReturnType().getName() + " " + method.getName() + "() {" + ENTER);
stringBuilder.append("try {" + ENTER);
stringBuilder.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + method.getName() + "\", new Class[]{});" + ENTER);
stringBuilder.append("this.h.invoke(this, m, null);" + ENTER);
stringBuilder.append("} catch(Throwable able) {" + ENTER);
stringBuilder.append("able.getMessage();" + ENTER);
stringBuilder.append("}" + ENTER);
stringBuilder.append("}" + ENTER + ENTER);
}
stringBuilder.append("}" + ENTER);
return stringBuilder.toString();
}
}该类代码的具体步骤在注释中已经写明；
5，查看生成的.java文件
package com.gupao.designpattern.proxy.self;
import com.gupao.designpattern.proxy.jdk.ProxyInterface;
import java.lang.reflect.Method;
public class $ProxyO implements com.gupao.designpattern.proxy.self.SelfProxyInterface {
SelfInvocationHandler h;
public $ProxyO(SelfInvocationHandler h) {
this.h = h;
}
public void targetMethod() {
try {
Method m = com.gupao.designpattern.proxy.self.SelfProxyInterface.class.getMethod("targetMethod", new Class[]{});
this.h.invoke(this, m, null);
} catch (Throwable able) {
able.getMessage();
}
}
}6，查看生成的.class文件
package com.gupao.designpattern.proxy.self;
import java.lang.reflect.Method;
public class $ProxyO implements SelfProxyInterface {
SelfInvocationHandler h;
public $ProxyO(SelfInvocationHandler var1) {
this.h = var1;
}
public void targetMethod() {
try {
Method var1 = SelfProxyInterface.class.getMethod("targetMethod", new Class[0]);
this.h.invoke(this, var1, (Object[])null);
} catch (Throwable var2) {
var2.getMessage();
}
}
}7，SelfInvocationHandler接口，定义invoke()方法
public interface SelfInvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args);
}
8，SelfJdkProxy，定义newInstance()方法创建代理对象，并实现InvocationHandler接口，重写invoke()方法，通过反射实现方法最终运行
public class SelfJDKProxy implements SelfInvocationHandler{
private SelfProxyInterface proxyInterface;
public SelfJDKProxy(SelfProxyInterface proxyInterface) {
this.proxyInterface = proxyInterface;
}
public Object instanceProxy() {
System.out.println("代理方法开始...");
SelfProxyInterface instance = (SelfProxyInterface) SelfProxy.newInstance(
new SelfClassLoader(),
proxyInterface.getClass().getInterfaces(), this);
return instance;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) {
try {
method.invoke(proxyInterface, args);
System.out.println("代理方法结束...");
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}9，客户端执行
public class SelfTest {
public static void main(String[] args) {
SelfJDKProxy proxy = new SelfJDKProxy(new SelfJDKProxyTarget());
SelfProxyInterface proxyInterface = (SelfProxyInterface) proxy.instanceProxy();
System.out.println(proxyInterface);
proxyInterface.targetMethod();
}
}
10，总结
整个手写动态代理以说明问题为目的，整个流程中所有环境创建都是按照最简单方式在运行，旨在熟悉整个JDK动态代理的执行流程和底层实现；