实现自己的JDK动态代理- 2020-11-1 22:19- 设计模式: 设计模式,动态代理,JDK

jdk动态代理其实很简单，一般看过jdk动态代理生成的源码就明白了。

接口：HelloService
真实被代理类：HelloServiceImpl
自定义Proxy类（模拟原生Proxy类）：MyProxy
自定义InvocationHandler（模拟InvocationHandler类）：MyInvocationHandler
自定义ClassLoader（模拟ClassLoader）：MyClassLoader

自定义动态代理 流程梳理

1.动态生成 代理类 .java文件
2.将java文件编译成class文件
3.将class文件加载进jvm

真实对象

  2. /**
  3.  * 接口类
  4.  *
  5.  * @Author Bai
  6.  * @Date 2020-10-26 14:25
  7.  */
  8. public interface HelloService {
  9.     void say(String msg);
  10. }

实现自己的Proxy类

  1. import javax.tools.JavaCompiler;
  2. import javax.tools.StandardJavaFileManager;
  3. import javax.tools.ToolProvider;
  4. import java.io.File;
  5. import java.io.FileWriter;
  6. import java.lang.reflect.Constructor;
  7. import java.lang.reflect.Method;
  9. /**
  10.  * 实现自己的Proxy类
  11.  *
  12.  * @Author Bai
  13.  * @Date 2020-11-08 12:14
  14.  */
  15. public class MyProxy {
  16.     public static final String ln = "\r\n";
  18.     public static Object newProxyInstance(MyClassLoader classLoader, Class<?>[] interfaces, MyInvocationHandler h) {
  19.         try {//1、动态生成源代码.java 文件
  20.             String src = generateSrc(interfaces);
  21.             System.out.println(src);
  22.             // 2、Java 文件输出磁盘
  23.             String filePath = MyProxy.class.getResource("").getPath();
  24.             System.out.println(filePath);
  25.             File f = new File(filePath + "$Proxy0.java");
  26.             FileWriter fw = new FileWriter(f);
  27.             fw.write(src);
  28.             fw.flush();
  29.             fw.close();
  30.             // 3、把生成的.java 文件编译成.class 文件
  31.             JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  32.             StandardJavaFileManager manage = compiler.getStandardFileManager(null, null, null);
  33.             Iterable iterable = manage.getJavaFileObjects(f);
  34.             JavaCompiler.CompilationTask task = compiler.getTask(null, manage, null, null, null, iterable);
  35.             task.call();
  36.             manage.close();
  37.             //4、编译生成的.class 文件加载到 JVM 中来
  38.             Class proxyClass = classLoader.findClass("$Proxy0");
  39.             Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
  40.             f.delete();
  41.             //5、返回字节码重组以后的新的代理对象
  42.             return c.newInstance(h);
  43.         } catch (Exception e) {
  44.             e.printStackTrace();
  45.         }
  46.         return null;
  47.     }
  49.     private static String generateSrc(Class<?>[] interfaces) {
  50.         StringBuffer sb = new StringBuffer();
  51.         sb.append("package com.xy.blog.test.poxy.my.jdkdynamic;" + ln);
  52.         sb.append("import com.xy.blog.test.poxy.my.jdkdynamic.MyInvocationHandler;" + ln);
  53.         sb.append("import com.xy.blog.test.poxy.my.jdkdynamic.MyProxy;" + ln);
  54.         sb.append("import com.xy.blog.test.poxy.HelloService;" + ln);
  55.         sb.append("import java.lang.reflect.*;" + ln);
  56.         sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
  57.         sb.append("MyInvocationHandler h;" + ln);
  58.         sb.append("public $Proxy0(MyInvocationHandler h) { " + ln);
  59.         sb.append("this.h = h;");
  60.         sb.append("}" + ln);
  61.         for (Method m : interfaces[0].getMethods()) {
  62.             Class<?>[] params = m.getParameterTypes();
  63.             StringBuffer paramNames = new StringBuffer();
  64.             StringBuffer paramValues = new StringBuffer();
  65.             StringBuffer paramClasses = new StringBuffer();
  66.             for (int i = 0; i < params.length; i++) {
  67.                 Class clazz = params[i];
  68.                 String type = clazz.getName();
  69.                 String paramName = toLowerFirstCase(clazz.getSimpleName());
  70.                 paramNames.append(type + " " + paramName);
  71.                 paramValues.append(paramName);
  72.                 paramClasses.append(clazz.getName() + ".class");
  73.                 if (i > 0 && i < params.length - 1) {
  74.                     paramNames.append(",");
  75.                     paramClasses.append(",");
  76.                     paramValues.append(",");
  77.                 }
  78.             }
  79.             sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
  80.             sb.append("try{" + ln);
  81.             sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
  82.             sb.append((hasReturnValue(m.getReturnType()) ? "return " : "") + "this.h.invoke(this,m,new Object[]{" + paramValues + "});" + ln);
  83.             sb.append("}catch(Error _ex) { }");
  84.             sb.append("catch(Throwable e){" + ln);
  85.             sb.append("throw new UndeclaredThrowableException(e);" + ln);
  86.             sb.append("}");
  87.             sb.append(getReturnEmptyCode(m.getReturnType()));
  88.             sb.append("}");
  89.         }
  90.         sb.append("}" + ln);
  91.         return sb.toString();
  92.     }
  94.     private static boolean hasReturnValue(Class<?> clazz) {
  95.         return clazz != void.class;
  96.     }
  98.     private static String toLowerFirstCase(String src) {
  99.         char[] chars = src.toCharArray();
  100.         chars[0] += 32;
  101.         return String.valueOf(chars);
  102.     }
  104.     private static String getReturnEmptyCode(Class<?> returnClass) {
  105.         if (returnClass == void.class) {
  106.             return "";
  107.         } else {
  108.             return "return null;";
  109.         }
  110.     }
  112. }

实现自己的JDK动态代理handler

  2. import java.lang.reflect.Method;
  4. /**
  5.  * 实现自己的JDK动态代理handler
  6.  *
  7.  * @Author Bai
  8.  * @Date 2020-11-08 12:14
  9.  */
  10. public interface MyInvocationHandler {
  12.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  14. }

实现自己的classLoader

  1. import java.io.ByteArrayOutputStream;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  6. /**
  7.  * 实现自己的classLoader
  8.  *
  9.  * @Author Bai
  10.  * @Date 2020-11-08 12:45
  11.  */
  12. public class MyClassLoader extends ClassLoader {
  14.     private File classPathFile;
  16.     public MyClassLoader() {
  17.         String classPath = MyClassLoader.class.getResource("").getPath();
  18.         this.classPathFile = new File(classPath);
  19.     }
  21.     @Override
  22.     protected Class<?> findClass(String name) throws ClassNotFoundException {
  23.         String className = MyClassLoader.class.getPackage().getName() + "." + name;
  24.         if (classPathFile != null) {
  25.             File classFile = new File(classPathFile, name.replaceAll("\\.", "/") + ".class");
  26.             if (classFile.exists()) {
  27.                 FileInputStream in = null;
  28.                 ByteArrayOutputStream out = null;
  29.                 try {
  30.                     in = new FileInputStream(classFile);
  31.                     out = new ByteArrayOutputStream();
  32.                     byte[] buff = new byte[1024];
  33.                     int len;
  34.                     while ((len = in.read(buff)) != -1) {
  35.                         out.write(buff, 0, len);
  36.                     }
  37.                     return defineClass(className, out.toByteArray(), 0, out.size());
  38.                 } catch (Exception e) {
  39.                     e.printStackTrace();
  40.                 } finally {
  41.                     if (null != in) {
  42.                         try {
  43.                             in.close();
  44.                         } catch (IOException e) {
  45.                             e.printStackTrace();
  46.                         }
  47.                     }
  48.                     if (out != null) {
  49.                         try {
  50.                             out.close();
  51.                         } catch (IOException e) {
  52.                             e.printStackTrace();
  53.                         }
  54.                     }
  55.                 }
  56.             }
  57.         }
  58.         return null;
  59.     }
  60. }

实现HelloInvocationHandler

  1. import com.xy.blog.test.poxy.HelloService;
  2. import sun.misc.ProxyGenerator;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.lang.reflect.Method;
  8. /**
  9.  * JDK动态代理handler
  10.  *
  11.  * @Author Bai
  12.  * @Date 2020-10-26 14:52
  13.  */
  14. public class HelloMyInvocationHandler implements MyInvocationHandler {
  16.     /**
  17.      * 真实对象：被代理的对象引用
  18.      */
  19.     private Object target;
  21.     public HelloMyInvocationHandler(Object target) {
  22.         super();
  23.         this.target = target;
  24.     }
  26.     /**
  27.      * @param proxy  代理类
  28.      * @param method 目标方法
  29.      * @param args   入参
  30.      * @return
  31.      * @throws Throwable
  32.      */
  33.     @Override
  34.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  35.         System.out.println("MyInvocationHandler#invoke start");
  36.         //两者执行有何区别？target or proxy
  37.         //proxy 会造成死循环，猜测可能是因为invoke内部实现 需要生成proxy的实例，去调用proxy实例的invoke,就会造成循环调用
  38. //        Object invoke = method.invoke(proxy, args);
  39.         Object invoke = method.invoke(target, args);
  40.         System.out.println("MyInvocationHandler#invoke end");
  41.         return invoke;
  42.     }
  44.     /**
  45.      * 获取jdk生成的代理对象
  46.      *
  47.      * @return
  48.      */
  49.     public Object getProxy() {
  50.         //下面的写法会报错  因为第二个入参需要的是接口对象，而target是具体实现类的引用 并发接口
  51. //        return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{target.getClass()}, this);
  52.         //第一个入参 使用哪个loader将proxy对象加载到内存中，一般是跟被代理对象同个loader就可以
  53.         //第二个入参 proxy要代理的是哪些接口
  54.         Class<?> aClass = target.getClass();
  55.         return MyProxy.newProxyInstance(new MyClassLoader(), aClass.getInterfaces(), this);
  56.     }
  58.     private void saveProxyClass0() {
  59.         //通过反编译工具可以查看源代码
  60.         byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{HelloService.class});
  61.         try {
  62.             FileOutputStream os = new FileOutputStream("E://$Proxy0.class");
  63.             os.write(bytes);
  64.             os.close();
  65.         } catch (IOException e) {
  66.             e.printStackTrace();
  67.         }
  68.     }
  70. }

测试

  1.   /**
  2.      * 实现自己的jdk动态代理
  3.      */
  4.     @Test
  5.     public void jdkMyProxyTest() throws Throwable {
  6.         //真实对象
  7.         HelloService helloService = new HelloServiceImpl();
  8.         //代理handler
  9.         HelloMyInvocationHandler handler = new HelloMyInvocationHandler(helloService);
  10.         // 代理对象
  11.         HelloService helloProxyService = (HelloService) handler.getProxy();
  12.         //使用代理对象执行
  13.         System.out.println("--- helloProxyService.result ---");
  14.         helloProxyService.say("helloProxyService.自己的jdk动态代理");
  15.         helloProxyService.eat("累了 开吃");
  16.     }

**