动态代理

主要是实现动态增强接口的功能
具体实现：

写一个接口，接口中封装了客户端需要的操作。
写一个委托类实现该接口
写一个代理类实现InvocationHandler接口，这个类中存在委托类的引用
客户端利用Proxy类的静态方法（反射技术），让接口关联代理实现类的对象，利用接口来调用方法，实际通过代理来访问委托类的方法。

静态代理

写一个接口A，定义一些功能
写一个类B，实现接口
写一个类C，实现接口，并且C的内部有一个B实例，构造方法中也需要传入一个B对象b，重写接口方法时实际上是调用b对象的对应方法，但是此时可以添加一些其他的操作，相当于加强了类。
图示

代码

  // 静态代理，定义了一个代理类并且内部包含接口的一个实现类，代理类再实现接口，
  // 并且通过内部的类实例调用方法，本身只用于加强方法
  public class SimpleStaticProxyDemo {
      static interface IService {
          public void sayHello();
      }

      static class RealService implements IService {
          @Override
          public void sayHello() {
              System.out.println("你好呀！！");
          }
      }

      static class TraceProxy implements IService {
          private IService realService;

          public TraceProxy(IService realService) {
              this.realService = realService;
          }

          @Override
          public void sayHello() {
              System.out.println("进入sayHello方法");
              realService.sayHello();
              System.out.println("退出sayHello方法");
          }
      }

      public static void main(String[] args) {
          IService realService = new RealService();
          IService proxyService = new TraceProxy(realService);
          proxyService.sayHello();
      }
  }

动态代理

JDK动态代理

代码

  import java.lang.reflect.*;

  public class SimpleJDKDynamicProxyDemo {
      static interface IService {
          public void sayHello();
      }

      static class RealService implements IService {
          @Override
          public void sayHello() {
              System.out.println("你好呀！！");
          }
      }

      static class SimpleInvocationHandler implements InvocationHandler {
          private Object realObject;

          public SimpleInvocationHandler(Object realObject) {
              this.realObject = realObject;
          }

          @Override
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              System.out.println("进入" + method.getName() + "方法");
              // 调用realObject对象的method方法，参数是args
              Object result = method.invoke(realObject, args);
              System.out.println("离开" + method.getName() + "方法");
              return result;
          }
      }

      public static void main(String[] args) throws Exception {
          IService realService = new RealService();
          // 通过Proxy.getProxyClass创建代理类定义，类定义会被缓存
          Class proxyClass = Proxy.getProxyClass(IService.class.getClassLoader(), new Class<?>[]{IService.class});
          // 获取代理类的构造方法，构造方法中会有一个InvocationHandler类型的参数
          Constructor constructor = proxyClass.getConstructor(new Class[]{InvocationHandler.class});
          // 创建InvocationHandler和IService对象
          InvocationHandler handler = new SimpleInvocationHandler(realService);
          IService proxyService = (IService) constructor.newInstance(handler);
          proxyService.sayHello();
      }
  }

本质上来看Proxy.getProxyClass会动态生成一个代理类，h是一个InvocationHandler类实例

  final class $Proxy0 extends Proxy implements SimpleJDKDynamicProxyDemo.IService {
      private static Method m1;
      private static Method m3;
      private static Method m2;
      private static Method m0;

      public $Proxy0(InvocationHandler paramInvocationHandler) {
          super(paramInvocationHandler);
      }

      public final boolean equals(Object paramObject) {
          return ((Boolean) h.invoke(this, m1, new Object[]{paramObject})).booleanValue();
      }

      public final void sayHello() {
          h.invoke(this, m3, null);
      }

      public final String toString() {
          return (String) h.invoke(this, m2, null);
      }

      public final int hashCode() {
          return ((Integer) h.invoke(this, m0, null)).intValue();
      }

      static {
          m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
          m3 = Class.forName("edu.hut.proxy.SimpleJDKDynamicProxyDemo$IService").getMethod("sayHello", new Class[0]);
          m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
          m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      }
  }

作用

可以实现一种方法模板，只需要传入接口的class和一个实现了接口的类对象，就可以增强对应的方法（比如打印日志）

动态代理

静态代理

动态代理

全站热榜