java之静态代理与动态代理

先看看静态代理是如何操作的

定义接口：

 public interface Person {
     public void sayHello(String content, int age);
     public void sayGoodBye(boolean seeAgin, double time);
 }

实际的类：

 public class Student implements Person{

     @Override
     public void sayHello(String content, int age) {
         // TODO Auto-generated method stub
         System.out.println("student say hello" + content + " "+ age);
     }

     @Override
     public void sayGoodBye(boolean seeAgin, double time) {
         // TODO Auto-generated method stub
         System.out.println("student sayGoodBye " + time + " "+ seeAgin);
     }
14  }

代理类：

 public class ProxyTest implements Person{

     private Person o;

     public ProxyTest(Person o){
         this.o = o;
     }

     @Override
     public void sayHello(String content, int age) {
         // TODO Auto-generated method stub
         System.out.println("ProxyTest sayHello begin");
         //在代理类的方法中 间接访问被代理对象的方法
         o.sayHello(content, age);
         System.out.println("ProxyTest sayHello end");
     }

     @Override
     public void sayGoodBye(boolean seeAgin, double time) {
         // TODO Auto-generated method stub
         System.out.println("ProxyTest sayHello begin");
         //在代理类的方法中 间接访问被代理对象的方法
         o.sayGoodBye(seeAgin, time);
         System.out.println("ProxyTest sayHello end");
     }

 public static void main(String[] args) {
         // TODO Auto-generated method stub
         //s为被代理的对象，某些情况下 我们不希望修改已有的代码，我们采用代理来间接访问
         Student s = new Student();
         //创建代理类对象
         ProxyTest proxy = new ProxyTest(s);
         //调用代理类对象的方法
         proxy.sayHello("welcome to java", 20);
         System.out.println("******");
         //调用代理类对象的方法
         proxy.sayGoodBye(true, 100);

     }

 }

可以看到，静态代理类要求实现与实际类型相同的接口，这个虽然在某些情况下有使用场景，但是其实扩展起来很麻烦，需要一个个的进行重载，相比之下，动态代理就好多了。

动态代理也需要一个代理类，实现特定的接口InvocationHandler：

 public class MyInvocationHandler implements InvocationHandler{

     private Object object;

     public MyInvocationHandler(Object object){
         this.object = object;
     }

     @Override
     public Object invoke(Object proxy, Method method, Object[] args)
             throws Throwable {
         // TODO Auto-generated method stub
         System.out.println("MyInvocationHandler invoke begin");
         System.out.println("proxy: "+ proxy.getClass().getName());
         System.out.println("method: "+ method.getName());
         for(Object o : args){
             System.out.println("arg: "+ o);
         }
         //通过反射调用 被代理类的方法
         method.invoke(object, args);
         System.out.println("MyInvocationHandler invoke end");
         return null;
     }

     public static void main(String [] args){
         //创建需要被代理的类
         Student s = new Student();
         //这一句是生成代理类的class文件，前提是你需要在工程根目录下创建com/sun/proxy目录，不然会报找不到路径的io异常
         System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
         //获得加载被代理类的 类加载器
         ClassLoader loader = Thread.currentThread().getContextClassLoader();
         //指明被代理类实现的接口
         Class<?>[] interfaces = s.getClass().getInterfaces();
         // 创建被代理类的委托类,之后想要调用被代理类的方法时，都会委托给这个类的invoke(Object proxy, Method method, Object[] args)方法
         MyInvocationHandler h = new MyInvocationHandler(s);
         //生成代理类
         Person proxy = (Person)Proxy.newProxyInstance(loader, interfaces, h);
         //通过代理类调用 被代理类的方法
         proxy.sayHello("yujie.wang", 20);
         proxy.sayGoodBye(true, 100);
         System.out.println("end");
     }

 }

这个灵活性就好多了，不用关心自己代理的类到底有多少方法，只用实现一个invoke方法，去做自己想做的事情就好，如果需要根据特定的方法做事情，可能就需要根据method判断了，不如静态代理写在重载方法中感觉好。

那么，java到底是怎么实现动态代理的，不妨反编译一下，拿到的结果如下，可以看到其实是jvm帮你做了静态代理的事情：

 public final class $Proxy0 extends Proxy implements Person{
   private static Method m4;
   private static Method m1;
   private static Method m0;
   private static Method m3;
   private static Method m2;

   public $Proxy0(InvocationHandler paramInvocationHandler)
     throws
   {
     super(paramInvocationHandler);
   }
    //实现了Person接口的方法，这就是我们调用这个方法Proxy.newProxyInstance必须提供第二个参数的作用
   public final void sayGoodBye(boolean paramBoolean, double paramDouble)
     throws
   {
     try
     {
     // 我们看到通过调用代理类的方法时，最终方法都会委托给InvocationHandler实现类的invoke方法
     // m4为代理类通过反射获得的Method
       this.h.invoke(this, m4, new Object[] { Boolean.valueOf(paramBoolean), Double.valueOf(paramDouble) });
       return;
     }
     catch (Error|RuntimeException localError)
     {
       throw localError;
     }
     catch (Throwable localThrowable)
     {
       throw new UndeclaredThrowableException(localThrowable);
     }
   }

   public final boolean equals(Object paramObject)
     throws
   {
     try
     {
       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();
     }
     catch (Error|RuntimeException localError)
     {
       throw localError;
     }
     catch (Throwable localThrowable)
     {
       throw new UndeclaredThrowableException(localThrowable);
     }
   }

   public final int hashCode()
     throws
   {
     try
     {
       return ((Integer)this.h.invoke(this, m0, null)).intValue();
     }
     catch (Error|RuntimeException localError)
     {
       throw localError;
     }
     catch (Throwable localThrowable)
     {
       throw new UndeclaredThrowableException(localThrowable);
     }
   }
   //实现了Person接口的方法，这就是我们调用这个方法Proxy.newProxyInstance必须提供第二个参数的作用
   public final void sayHello(String paramString, int paramInt)
     throws
   {
     try
     {
       // 我们看到通过调用代理类的方法时，最终方法都会委托给InvocationHandler实现类的invoke方法
       // m4为代理类通过反射获得的Method
       this.h.invoke(this, m3, new Object[] { paramString, Integer.valueOf(paramInt) });
       return;
     }
     catch (Error|RuntimeException localError)
     {
       throw localError;
     }
     catch (Throwable localThrowable)
     {
       throw new UndeclaredThrowableException(localThrowable);
     }
   }

   public final String toString()
     throws
   {
     try
     {
       return (String)this.h.invoke(this, m2, null);
     }
     catch (Error|RuntimeException localError)
     {
       throw localError;
     }
     catch (Throwable localThrowable)
     {
       throw new UndeclaredThrowableException(localThrowable);
     }
   }

   static
   {
     try
     {//代理类通过反射 获得的接口方法Method
       m4 = Class.forName("com.yujie.proxy.dynamic.Person").getMethod("sayGoodBye", new Class[] { Boolean.TYPE, Double.TYPE });
       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
       //代理类通过反射 获得的接口方法Method
       m3 = Class.forName("com.yujie.proxy.dynamic.Person").getMethod("sayHello", new Class[] { Class.forName("java.lang.String"), Integer.TYPE });
       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
       return;
     }
     catch (NoSuchMethodException localNoSuchMethodException)
     {
       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());
     }
     catch (ClassNotFoundException localClassNotFoundException)
     {
       throw new NoClassDefFoundError(localClassNotFoundException.getMessage());
     }
   }
 }

本文参考了https://blog.csdn.net/u011784767/article/details/78281384