57-透过字节码生成审视Java动态代理运作机制

透过字节码生成审视Java动态代理运作机制

public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("From real subject");
    }
}

public class DynamicSubject implements InvocationHandler {
    private Object sub;
    public DynamicSubject(Object obj) {
        this.sub = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before calling:"+method);
        //表示对于真正的目标方法的调用
        //this.sub:表示调用那个对象的method方法，这个对象是：RealSubject
        //args:真正对象所需要的参数
        method.invoke(this.sub,args);
        System.out.println("after calling:"+method);
        return null;
    }
}

public class Client {
    public static void main(String[] args) {
        //该句会生成动态代理时，所生成的字节码文件，写到磁盘上，就是在58节中图2中if()里面的判断条件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
        RealSubject rs = new RealSubject();
        InvocationHandler ds = new DynamicSubject(rs);
        Class<?> cls = rs.getClass();
        /**
         * cls.getClassLoader() 获取加载rs.class对象的类加载器
         * cls.getInterfaces 获取rs 所实现的接口
         * ds表示DynamicSubject(rs);对于任何的subject的调用，都会转向DynamicSubject里面
         */
       //该方法一次性生成所代理的代理类对象 两步：1.生成代理类本身，2.然后生成该代理类代理的对象或实例。
       //★★★subject这个对象实际指向的是$Proxy0，而$Proxy0的父类是Proxy，
       //所以当执行下面的subject.request()方法;实际就是执行的$Proxy0($Proxy0.class)实例中
       //的request方法。
        Subject subject  = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),
                                                           cls.getInterfaces(),ds);
        subject.request();

        System.out.println(subject.getClass());
        System.out.println(subject.getClass().getSuperclass());
    }
}
运行结果：
	//1.打印的其实就是 m3
   before calling:public abstract void jvm.bytecode.Subject.request()
   From real subject
   //2.打印的其实就是 m3
   after calling:public abstract void jvm.bytecode.Subject.request()
   class com.sun.proxy.$Proxy0
   class java.lang.reflect.Proxy

• 动态代理期间所生成的class文件：

  • 除了下面的 equals、toString、hashCode方法需要走动态代理，Object类中剩下的方法都没有任何改变

  public final class $Proxy0 extends Proxy implements Subject {
      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);
          }
      }
  
      public final void request() throws  {
          try {
             //super实际就是DynamicSubject类，然后invoke就是调用DynamicSubject中的invoke方法
             //this:当前对象$Proxy0;
             //m3:对应接口的相关方法
             //(Object[])null ，然后request方法没有参数，所以就为null
              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 = Class.forName("jvm.bytecode.Subject").getMethod("request");
              m0 = Class.forName("java.lang.Object").getMethod("hashCode");
          } catch (NoSuchMethodException var2) {
              throw new NoSuchMethodError(var2.getMessage());
          } catch (ClassNotFoundException var3) {
              throw new NoClassDefFoundError(var3.getMessage());
          }
      }
  }