重学设计模式——代理模式之手写JDK动态实现
代理模式
为其他对象提供一种代理以控制对这个对象的访问。
最重要的三要素：
- 有执行者、被代理人
- 对被代理人来说，这件事是一定要去做，但是自己因为某些原因暂时不能去做，只能通过代理来做
- 代理能获取到被代理人的资料（拿到被代理人的引用）
动态代理
动态代理通过反射机制动态地生成代理者的对象，我们在code的时候不必要关心代理谁，代理谁我们将在执行阶段来决定。JDK为我们已提供了很方便的动态代理接口InvocationHandler。
先来定义一个场景，我要去申请专利，这个时候就可以通过专利代理人来进行专利申请。那么我就是被代理者，专利代理人就是代理。
业务接口
public interface Person {
void apply();
}
业务实现类
public class Apkcore implements Person {
@Override
public void apply() {
System.out.println("apkcore开始申请专利");
}
}
业务处理类（专利代理人）
public class PatentAgent implements InvocationHandler {
private Person mPersion;
public Object getInstance(Person persion) {
this.mPersion = persion;
Class clazz = persion.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(mPersion, args);
after();
return result;
}
private void after() {
System.out.println("申请提交成功了");
}
private void before() {
System.out.println("准备申请专利的材料");
}
}
测试类
public static void main(String[] args) {
PatentAgent patentAgent = new PatentAgent();
Person person = (Person) patentAgent.getInstance(new Apkcore());
person.apply();
}
可以看到生成的结果为：
准备申请专利的材料
apkcore开始申请专利
申请提交成功了
到此，使用JDK给我们提供的InvocationHandler实现动态代理就已经完成了。
动态代理的实现原理
我们可以打印一下测试中得到的person对象
PatentAgent patentAgent = new PatentAgent();
Person person = (Person) patentAgent.getInstance(new Apkcore());
System.out.println(person.getClass());
person.apply();
可以看到输出结果为class com.sun.proxy.$Proxy0
我们在生成的class中，是不能找到这个$Proxy0的，它只是JVM在内存中生成的动态代理类。
那么我们可以把这个类用一个文件写出来。
//获取字节码内容
byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{Persion.class});
FileOutputStream os = null;
try {
String path = "$Proxy0.class";
File file = new File(path);
if (file.exists()) {
file.delete();
}
os = new FileOutputStream("$Proxy0.class");
os.write(data);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != os) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
可以在根目录下生成$Proxy0.class文件，打开这个文件
public final class $Proxy0 extends Proxy implements Person {
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});
} 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);
}
}
//这是person.apply方法调用的地方
public final void apply() throws {
try {
//是调用了父类的h的invoke方法
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);
} 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"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
//m3就是apply方法，另外三个都是Object的方法，可以忽略不看
m3 = Class.forName("com.apkcore.proxy.blog.Person").getMethod("apply");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
可以看到，主要就看apply方法，这是我们调用的方法super.h在父类Proxy中
protected InvocationHandler h;
而我们在PatentAgent中，使用Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this)这个this就是PatentAgent，它是个InvocationHandler的实现类，所以可以知道，super.h.invoke其实就是调用了PatentAgent中的invoke方法，而invoke的第二个参数m3就是m3 = Class.forName("com.apkcore.proxy.blog.Person").getMethod("apply");，所以我们在PatentAgent中调用method.invoke(mPersion, args)就相当于mPerson.apply方法。
动态代理的过程：
- Proxy通过传递给它的参数(interface/invocationHandler)生成代理类$Proxy0
- Proxy通过传递给它的参数(ClassLoade)来加载生成的代理类$Proxy0的字节码文件
手写JDK动态代理
我们先看源码中InvocationHandler
public interface InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
所以我们可以模仿着实现自己的InvocationHandler
public interface MyInvocationHandler {
Object invoke(Object proxy, Method method, Object[] args)
throws Throwable;
}
那么对应的，我们的动态代理PatentAgent要改为
public class MyPatentAgent implements MyInvocationHandler {
private Person mPersion;
public Object getInstance(Person persion) {
this.mPersion = persion;
Class clazz = persion.getClass();
return MyProxy.newProxyInstance(new MyClassLoader(), clazz.getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object result = method.invoke(mPersion, args);
after();
return result;
}
private void after() {
System.out.println("申请提交成功了");
}
private void before() {
System.out.println("准备申请专利的材料");
}
}
其中的ClassLoader与Proxy都使用自己的而不是JDK提供的。
public class MyProxy {
public static Object newProxyInstance(MyClassLoader classLoader, Class[] interfaces, MyPatentAgent h) {
return null;
}
}
public class MyClassLoader extends ClassLoader{
}
生成java文件并保存
由上面的知识我们可以知道，我们要先在运行时生成一个$Proxy0这样的java文件
public class MyProxy {
private static final String ln = "\r\n";
public static Object newProxyInstance(MyClassLoader classLoader, Class[] interfaces, MyPatentAgent h) {
if (h == null) {
throw new NullPointerException();
}
//1.生成源代码$MyProxy0这个源文件
//为了实现方便，默认只代理一个接口
String proxySrc = generateSrc(interfaces[0]);
//2.保存到文件
String filePath = MyProxy.class.getResource("").getPath();
File f = new File(filePath + "$MyProxy0.java");
FileWriter fw = null;
try {
fw = new FileWriter(f);
fw.write(proxySrc);
fw.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != fw) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
private static String generateSrc(Class interfaces) {
Method[] methods = interfaces.getMethods();
StringBuilder sb = new StringBuilder();
sb.append("package ")
.append(MyProxy.class.getPackage().getName()).append(";").append(ln)
.append("import java.lang.reflect.Method;").append(ln)
.append("public class $MyProxy0 implements ").append(interfaces.getName()).append("{").append(ln)
.append("MyInvocationHandler h;").append(ln)
.append("public $MyProxy0(MyInvocationHandler h) {").append(ln)
.append("this.h = h;").append(ln)
.append("}").append(ln);
for (Method method : methods) {
sb.append("public ")
//使用最简单的不传参的方法
.append(method.getReturnType().getName()).append(" ").append(method.getName())
.append(" () {").append(ln)
.append("try {").append(ln)
.append("Method m = ").append(interfaces.getName()).append(".class.getMethod(\"").append(method.getName()).append("\",new Class[]{});").append(ln)
.append("this.h.invoke(this,m,null);").append(ln)
.append("}catch(Throwable throwable){ }").append(ln)
.append("}").append(ln);
}
sb.append("}");
return sb.toString();
}
}
append手写代码的时候，可以边写边生成，查看哪里写得有问题
调用
public static void main(String[] args) {
MyPatentAgent patentAgent = new MyPatentAgent();
// Person person = (Person)
patentAgent.getInstance(new Apkcore());
// System.out.println(person.getClass());
// person.apply();
}
}
来进行文件的生成，生成的文件在
然后把这个java文件复制到我们的工程中，可以查看我们是否写漏或者写错。
生成的$MyProxy0文件内容如下
package com.apkcore.proxy.blog.custom;
import java.lang.reflect.Method;
public class $MyProxy0 implements com.apkcore.proxy.blog.Person {
MyInvocationHandler h;
public $MyProxy0(MyInvocationHandler h) {
this.h = h;
}
public void apply() {
try {
Method m = com.apkcore.proxy.blog.Person.class.getMethod("apply", new Class[]{});
this.h.invoke(this, m, null);
} catch (Throwable throwable) {
}
}
}
把java文件编译成class文件
JavaCompiler：jdk用来编译java的源程式，提供在运行期动态编译java代码为字节码的功能
//3.编译源代码，并生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
Iterable iterable = manager.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
task.call();
manager.close();
运行测试代码，就会在编译目录下生成一个class文件。如图
将class文件中的内容，加载到JVM中
现在我们已经得到了我们所需要的class文件，只需要把它加载到jvm中即可
//4.将class文件中的内容动态加载到JVM中
//5.返回被代理的代理对象
Class proxyClass = classLoader.findClass("$MyProxy0");
Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
return constructor.newInstance(h);
整个MyProxy的代码如下
public class MyProxy {
private static final String ln = "\r\n";
public static Object newProxyInstance(MyClassLoader classLoader, Class[] interfaces, MyPatentAgent h) {
if (h == null) {
throw new NullPointerException();
}
//1.生成源代码$MyProxy0这个源文件
//为了实现方便，默认只代理一个接口
String proxySrc = generateSrc(interfaces[0]);
//2.保存到文件
String filePath = MyProxy.class.getResource("").getPath();
File f = new File(filePath + "$MyProxy0.java");
FileWriter fw = null;
try {
fw = new FileWriter(f);
fw.write(proxySrc);
fw.flush();
//3.编译源代码，并生成class文件
JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager manager = compiler.getStandardFileManager(null, null, null);
Iterable iterable = manager.getJavaFileObjects(f);
JavaCompiler.CompilationTask task = compiler.getTask(null, manager, null, null, null, iterable);
task.call();
manager.close();
//4.将class文件中的内容动态加载到JVM中
//5.返回被代理的代理对象
Class proxyClass = classLoader.findClass("$MyProxy0");
Constructor constructor = proxyClass.getConstructor(MyInvocationHandler.class);
return constructor.newInstance(h);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != fw) {
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return null;
}
private static String generateSrc(Class interfaces) {
Method[] methods = interfaces.getMethods();
StringBuilder sb = new StringBuilder();
sb.append("package ")
.append(MyProxy.class.getPackage().getName()).append(";").append(ln)
.append("import java.lang.reflect.Method;").append(ln)
.append("public class $MyProxy0 implements ").append(interfaces.getName()).append("{").append(ln)
.append("MyInvocationHandler h;").append(ln)
.append("public $MyProxy0(MyInvocationHandler h) {").append(ln)
.append("this.h = h;").append(ln)
.append("}").append(ln);
for (Method method : methods) {
sb.append("public ")
//使用最简单的不传参的方法
.append(method.getReturnType().getName()).append(" ").append(method.getName())
.append(" () {").append(ln)
.append("try {").append(ln)
.append("Method m = ").append(interfaces.getName()).append(".class.getMethod(\"").append(method.getName()).append("\",new Class[]{});").append(ln)
.append("this.h.invoke(this,m,null);").append(ln)
.append("}catch(Throwable throwable){ }").append(ln)
.append("}").append(ln);
}
sb.append("}");
return sb.toString();
}
}
可以知道，我们现在只需要在MyClassLoader中findClasss进行加载
public class MyClassLoader extends ClassLoader{
private File baseDir;
public MyClassLoader() {
this.baseDir = new File(MyClassLoader.class.getResource("").getPath());
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
String className = MyClassLoader.class.getPackage().getName()+"."+name;
if (null!=baseDir) {
File classFile = new File(baseDir,name.replaceAll("\\.","/")+".class");
if (classFile.exists()){
FileInputStream in = null;
ByteArrayOutputStream out = null;
try {
//先把class文件转化为字节流
in = new FileInputStream(classFile);
out = new ByteArrayOutputStream();
byte[] buff = new byte[1024];
int len;
while ((len = in.read(buff)) != -1) {
out.write(buff, 0, len);
}
//使用defineClass把字节流传jvm中
return defineClass(className, out.toByteArray(), 0, out.size());
} catch (Exception e) {
e.printStackTrace();
} finally {
if (null != in) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null!=out){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
return super.findClass(name);
}
}
运行测试代码
public static void main(String[] args) {
MyPatentAgent patentAgent = new MyPatentAgent();
Person person = (Person)
patentAgent.getInstance(new Apkcore());
System.out.println(person.getClass());
person.apply();
}
class com.apkcore.proxy.blog.custom.$MyProxy0
准备申请专利的材料
apkcore开始申请专利
申请提交成功了
这时我们发现，在我们的编译目录下是有$MyProxy0.,java和.class两个文件存在的，我们也可以在使用完之后增加一个删除语句，分别在MyProxy和MyClassLoader的finally语句中加入文件delete()方法就行了
总结
通过手写了JDK的动态代理，对代理模式的动态代理认识又加深了一步，原理就是拿到被代理对象的引用，然后获取它的接口，jdk代理重新生成一个类，同时实现我们给的代理对象所实现的接口，把被代理的对象引用也拿到了，重新动态生成一个class字节码，然后编译。
参考
手写jdk动态代理
我的掘金
下面是我的公众号，欢迎大家关注我
