阅读 193

"秒懂"代理模式 -- java

分享人: 元哥

1、代理模式

  • 设计模式中的结构型设计模式

  • 从字面意思理解,代理即A替B完成某件事。例如媒婆帮靓仔找一个广州的女朋友,那么媒婆就是代理方,代理的事情就是帮忙介绍男女朋友;靓仔就是委托方,委托的事情就是找一个广州的女朋友。

1)、静态代理

  • 静态代理类图

    image.png

  • Code实现

image.png

image.png

image.png
image.png
image.png

  • 在这里我们会先声明一个Target接口,声明的方法就是findGirlFriend。
  • 然后声明一个类Handsome表示靓仔,实现Target接口的方法findGirlFriend
  • 接着声明一个类MiddleProxy表示媒婆,持有一个目标接口Target的对象,并且实现Target接口的方法。在这个方法中调用持有对象的方法的前后进行增强。增强的效果就是本来靓仔得自己一个人去做找女朋友这件事;但有了媒婆就先让她展示她的资源,然后靓仔找一个自己喜欢的广州的女朋友,最后媒婆给联系方式。
优点
  • 在调用的时候我们不用知道MiddleProxy是如何实现的,只需要知道被代理即可。对例子而言,靓仔不需要知道媒婆这个代理是怎么帮忙找女朋友的,反正有了媒婆就能找到女朋友。
缺点
  • 代理类和委托类实现了相同的接口,代理类和委托类实现了相同的方法。如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。

    • 举个例子。上述的需求是靓仔要找个广州的女朋友,那现在假如靓仔还有个特殊的需求,要找个广州的男朋友,委托类Handsome和代理类Proxy都需要实现findBoyFriend()方法。

      image.png

  • 静态代理类只能为特定的接口服务。如想要为多个接口服务则需要建立很多个代理类。

    • 如上的代码是只为HandsomeMan类的访问提供了代理,但是如果还要为其他类如PrettyGril类提供代理的话,就需要我们再次添加代理PrettyGril的代理类。

      image.png

    • 在举个开发中的例子:在调用具体实现类之前,需要打印日志等信息,这样我们只需要添加一个代理类,在代理类中添加打印日志的功能,然后调用实现类,这样就避免了修改具体实现类。满足我们所说的开闭原则。但是如果想让每个实现类都添加打印日志的功能的话,就需要添加多个代理类,以及代理类中各个方法都需要添加打印日志功能。

2)、动态代理

a)、jdk动态代理
  • 动态代理类图

image.png

  • Code实现

image.png

image.png

image.png

image.png

  • 同样的使用前面的例子,需求是靓仔让媒婆帮忙找女朋友。因此Target接口、Handsome类不变。
  • 但在实现MiddleProxy媒婆这个类的时候,会去实现InvocationHandler这个类,实现的方法就是invoke方法和一个newProxyInstance方法。newProxyInstance是通过Java的反射类Proxy生成一个参数传进来对象的代理;invoke方法就是成员属性target中的所有成员方法进行增强。(可能你们会有很多疑问点,会在后面一一描述解决)
解决静态代理的问题
  • 当有新使用动态代理

    • 对比类图

    image.png

    image.png

    • 1)使用静态代理,当HandsomeMan类中有新的方法例如findBoyFriend()需要代理,相应findBoyFriend()方法需要在MiddleProxy类中进行实现;而使用动态代理,在MiddleProxy中不需要实现

    • 2)

      ![image-20191212212233267](/Users/cvter/Library/Application Support/typora-user-images/image-20191212212233267.png)

      image.png

      • 使用静态代理。当有新的委托方时,例如靓女也需要找媒婆介绍男朋友,这时候有个PrettyGirl类,那么由于先前的Target接口类中声明的方法是findGrilFriend, 而我们需要的是findBoyFriend,Target接口不再适用,因此会导致MidlleProxy方法不再适用,需要新建新的目标接口和代理类来满足需求。
      • 使用动态代理,newProxyInstance无论传进来的对象是什么,持有的对象始终是Object,就只需要再写新的接口,不要需要再写新的代理类。
JDK动态代理是怎么实现的

image.png

image.png

  • 我们来对比静态代理和动态代理。在静态代理中target对象一个是MiddleProxy类的对象,而在动态代理中target对象是$Proxy0类的对象。

  • 我们知道静态代理的MiddleProxy类是怎么做的,因为是我们声明的;但$Proxy0类原先是不存在,但是他是在调用newProxyInstance方法后生成,而方法中实现的是通过反射类Proxy.newProxyInstance。

    public Object newProxyInstance(Object target) {
    	this.target = target;
    	return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    复制代码
  • 我们来通过特殊的方式,将$Proxy0类的字节码也就是class输出到文件,然后经过idea反编译得到以下

    public final class $Proxy0 extends Proxy implements Target {
        private static Method m1;
        private static Method m2;
        private static Method m3;
        private static Method m0;
        public $Proxy0(InvocationHandler var1) throws  {...}
        public final boolean equals(Object var1) throws  {...}
        public final String toString() throws  {...}
        public final void findGrilFriend() throws  {
            try {
                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  {...}
        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("proxy.dynamic_proxy.Target").getMethod("findGrilFriend");
                m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            } catch (NoSuchMethodException var2) {
                throw new NoSuchMethodError(var2.getMessage());
            } catch (ClassNotFoundException var3) {
                throw new NoClassDefFoundError(var3.getMessage());
            }
        }
    }
    复制代码
    • 代码有点儿多我们不要慌。首先我们看到$Proxy0类继承Proxy,并实现Target接口,那么它肯定实现了findGrilFriend方法。

    • 那么我们来大胆猜想,$Proxy0类是通过反射类Proxy.newProxyInstance()生成的,方法接收的参数就是Target接口对象,那么如果方法接收的参数是其他接口对象,例如BTarget接口对象,里面实现的方法findBoyFriend,那么$Proxy0类就会去实现BTarget接口的方法。因此可以认为,动态代理是静态代理的升级版,在程序运行过程中会动态根据传入的接口对象,动态生成指定接口对象的代理类$Proxy0的对象。

    • 接下来,我们继续看findGrilFriend方法,调用的是 super.h.invoke(this, m3, (Object[])null); super.h 是 Proxy类的成员属性(InvocationHandler),在Proxy.newProxyInstance()生成$Proxy0会传this对象。

      public $Proxy0(InvocationHandler var1) throws  {
      	super(var1);
      }
      复制代码
      public class MiddleProxy implements InvocationHandler {
        public Object newProxyInstance(Object target) {
          this.target = target;
          return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                                        target.getClass().getInterfaces(), 
                                        this);
        }
        ....
      }
      复制代码
    • m3是声明的findGrilFriend()方法

      image.png

    • 总结一下过程:

      • a)经过反射类Proxy.newProxyInstance()生成的了$Proxy0类和对象,并且$Proxy0对象持有MiddleProxy对象。
      • b)当调用findGirlFriend方法,调用的是$Proxy0类中的方法,super.h.invoke()
      • c)会再调用MiddleProxy类中的invoke方法,由于动态的传进来的HandsomeMan对象,其中会调用Object obj = method.invoke(target, args);
优缺点
  • 优点:解决了静态代理中冗余的代理实现类问题。
  • 缺点:JDK 动态代理是基于接口设计实现的,如果没有接口,会抛异常
b)、cglib动态代理
  • 类图

    image.png

  • 代理类

    image.png

  • 动态生成具体的代理类code

public class HandsomeMan?EnhancerByCGLIB?596495c6 extends HandsomeMan implements Factory {
  	...省略很多代码
    final void CGLIB$findGrilFriend$0() {
        super.findGrilFriend();
    }

    public final void findGrilFriend() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (var10000 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }

        if (var10000 != null) {
            var10000.intercept(this, CGLIB$findGrilFriend$0$Method, CGLIB$emptyArgs, CGLIB$findGrilFriend$0$Proxy);
        } else {
            super.findGrilFriend();
        }
    }
}
复制代码

image.png

  • 总结一下流程;

    • 1)首先我们通过newProxyInstance动态生成代理类HandsomeMan?EnhancerByCGLIB?和对象

      public class MiddleProxy implements MethodInterceptor {
        public Object newProxyInstance(Object target){
          //工具类
          Enhancer enhancer=new Enhancer();
          //设置被代理的对象,也可以理解为设置父类,因为动态代理类是继承了被动态代理类。
          enhancer.setSuperclass(target.getClass());
          //设置回调函数
          enhancer.setCallback(this);
          //创建子类的动态代理类对象
          return enhancer.create();
        }
      ....
      }
      复制代码
    
    复制代码
  • 2)在子类HandsomeMan?EnhancerByCGLIB?对象调用findGirlFriend方法时,会调用MiddleProxy类的intercept方法

    • 3)在MiddleProxy类的intercept方法中,会在调用父类方法前后进行增强

      public class MiddleProxy implements MethodInterceptor {
        ....
        public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
          System.out.println("这里有很多单身的人.深圳、广州、东莞你找一个喜欢的。");
          Object obj = methodProxy.invokeSuper(o, objects);
          System.out.println("给你喜欢的这个人的联系方式。");
          return obj;
        }
      }
      复制代码
区别
  • 由于 JDK 动态代理限制了只能基于接口设计,而对于没有接口的情况,JDK 方式解决不了;

  • CGLib 采用了非常底层的字节码技术,其原理是通过字节码技术为一个类创建子类,并在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑,来完成动态代理的实现。

  • 但是 CGLib 在创建代理对象时所花费的时间却比 JDK 多得多,所以对于单例的对象,因为无需频繁创建对象,用 CGLib 合适,反之,使用 JDK 方式要更为合适一些。 同时,由于 CGLib 由于是采用动态创建子类的方法,对于 final 方法,无法进行代理。

优点:没有接口也能实现动态代理,而且采用字节码增强技术,性能也不错。 缺点:技术实现相对难理解些。

注意:对于从Object中继承的方法,CGLIB代理也会进行代理,如hashCode()equals()toString()等,但是getClass()wait()等方法不会,因为它是final方法,CGLIB无法代理。