静态代理与动态代理

  • 静态代理: 由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。
  • 动态代理: 在实现阶段不用关心代理类,而在运行阶段才指定哪一个对象。

代理模式

代理模式,顾名思义,即一个客户不想或者不能直接访问一个对象,需要通过一个称为代理的第三方对象来实现间接引用。代理对象的作用就是客户端和目标对象
之间的一个中介,通过代理对象可以隐藏不让用户看到的内容或实现额外的服务。

代理机制应用的场景有很多:比如在代理对象中实现缓存,验证,权限控制等功能,真正的业务逻辑封装在真实对象中。RMI远程方法调用也用到了代理。当你调用一个远程方法的时候,相当于调用这个方法的代理对象,
在代理对象中封装了网络请求等部分,真实对象存在于另一个进程上。重构老旧代码的时候也常常会用到代理模式。

代理分两种:静态代理和动态代理

情境

假设,有个汽车类具有移动停止两个方法,我们要怎么在不改动源码的情况下:

1.添加日志

2.添加事务

IMovable.java

public interface IMovable { void move(); void stop();}

Car.java

public class Car implements IMovable { @Override public void move() { System.out.println; } @Override public void stop() { System.out.println; }}

静态代理

静态代理即在代码中手动实现代理模式。代理模式涉及到三个角色:

真实对象RealSubject、抽象主题Subject、代理对象Proxy

image.png

image.png

public class ProxyTest {
    public static void main(String[] args) {
        new Proxy("hello").request();
    }
}
interface Subject {
    void request();
}
class Proxy implements Subject{
    String str;
    RealSubject subject;
    public Proxy(String string) {
        str = string;
        subject = new RealSubject(str);
    }
    @Override
    public void request() {
        System.out.println("代理对象验证机制....");
        subject.request();
    }

}

class RealSubject implements Subject{
    String str;
    public RealSubject(String string) {
        str = string;
    }
    @Override
    public void request() {
        System.out.println("真实对象打印str: " + str);
    }

}

输出:

代理对象验证机制....
真实对象打印str: hello

上面的代码模拟了一个代理对象实现验证机制的过程。可以看到,代码很简单,代理模式也很好理解。
(我们在真实生活中不也有代理么,,比如黄牛,帮你买到你买不到的火车票)

继承

CarLog.java

public class CarLog extends Car { @Override public void move() { System.out.println("开始执行move"); super.move(); System.out.println("执行move完成"); } @Override public void stop() { System.out.println("开始执行stop"); super.stop(); System.out.println("执行stop完成"); }}

Client.java

public class Client { public static void main(String[] args) { IMovable log = new CarLog(); log.move(); log.stop(); }}
  • 从上面的代码可以看出,我们定义了一个类并且继承于Car
  • 重写父类中的方法,在super前后加入打印日志的代码

运行截图:

图片 1静态代理_继承_日志.png

CarTransaction.java

public class CarTransaction extends Car { @Override public void move() { System.out.println("move事务开始"); super.move(); System.out.println("move事务提交"); } @Override public void stop() { System.out.println("stop事务开始"); super.stop(); System.out.println("stop事务提交"); }}

运行结果:

图片 2静态代理_继承_事务.png

  • 很明显,对于事务的做法与日志的做法一致

CarLog2Trans.java

public class CarLog2Trans extends CarTransaction{ @Override public void move() { System.out.println("开始执行move"); super.move(); System.out.println("执行move完成"); } @Override public void stop() { System.out.println("开始执行stop"); super.stop(); System.out.println("执行stop完成"); }}

运行结果:

图片 3静态代理_继承_先日志后事务.png

CarTrans2Log.java

public class CarTrans2Log extends CarLog { @Override public void move() { System.out.println("move事务开始"); super.move(); System.out.println("move事务提交"); } @Override public void stop() { System.out.println("stop事务开始"); super.stop(); System.out.println("stop事务提交"); }}

运行结果:

图片 4静态代理_继承_先事务后日志.png

  • 从上面代码可以看出如果我们添加功能的话,就要创建新的类

情境: 有四辆汽车A,B,C,D,A汽车要做到先添加日志再开启事务,B汽车要做到先开启事务再添加日志,C汽车只需要添加日志,D汽车只需要开启事务

显然为了完成这样的功能使用继承的方式,我们必须要有四个类才能完成,哪有没有更好的方式呢?

JDK动态代理实现

动态代理时较为高级的一种代理模式。典型的应用有Spring AOP,RMI。

在上面的静态代理模式中,真实对象是事先存在的,并且作为代理对象的内部成员属性。一个真实的对象必须对应一个代理对象,如果真实对象很多的话会导致类膨胀。

另外,如何在事先不知道真实对象的情况下使用代理代理对象,这都是动态代理需要解决的问题。

比如有n个类需要在执行前打印几行日志,而这n个类是无法通过源代码修改的(从jar包中引入的)。通过静态代理实现的话将会有n个新的代理类产生,而使用动态代理的话,只需一个类即可。

动态代理的实现方式有很多,我们只讨论JDK中的动态代理实现。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class DynamicProxyTest {
    public static void main(String[] args) {
        Subject subject = (Subject) new DynamicProxy().bind(new RealSubject("hello"));
        subject.request();
    }
}

interface Subject {
    void request();
}

class RealSubject implements Subject{
    String str;
    public RealSubject(String string) {
        str = string;
    }
    @Override
    public void request() {
        System.out.println("真实对象打印str: " + str);
    }
}

class DynamicProxy implements InvocationHandler {
    Object object;
    public Object bind(Object object) {
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), 
                object.getClass().getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("代理对象验证...");
        return method.invoke(object, args);
    }
}

输出:

代理对象验证...
真实对象打印str: hello

可以看到,动态代理实现了与静态代理一样的功能,但他的优点在于代理的真实对象不是确定的,可以在运行时指定,增大了灵活性。如果我们有很多的真实对象需要代理访问,并且他们代理对象中的内容
都实现了相同的功能,那么我们只需要一个动态代理类即可。

接口

CarLogProxy.java

public class CarLogProxy implements IMovable { private IMovable movable; public CarLogProxy(IMovable movable) { this.movable = movable; } @Override public void move() { System.out.println("开始执行move"); movable.move(); System.out.println("执行move完成"); } @Override public void stop() { System.out.println("开始执行stop"); movable.stop(); System.out.println("执行stop完成"); }}

Client.java

public class Client { public static void main(String[] args) { IMovable movable = new Car(); IMovable log = new CarLogProxy; log.move(); log.stop(); }}
  • 从上面的代码可以看出,我们实现了IMovable接口,并传入了需要被代理的对象

CarTransactionProxy.java

public class CarTransactionProxy implements IMovable {private IMovable movable;

public CarTransactionProxy(IMovable movable) { this.movable = movable;}@Overridepublic void move() { System.out.println("move事务开始"); movable.move(); System.out.println("move事务提交");}@Overridepublic void stop() { System.out.println("stop事务开始"); movable.stop(); System.out.println("stop事务提交");}

}

Client.java

public class Client { public static void main(String[] args) { IMovable movable = new Car(); IMovable transaction = new CarTransactionProxy; transaction.move(); transaction.stop(); }}

Client.java

public class Client { public static void main(String[] args) { IMovable movable = new Car(); IMovable transaction = new CarTransactionProxy; IMovable log = new CarLogProxy(transaction); log.move(); log.stop(); }}

Client.java

public class Client { public static void main(String[] args) { IMovable movable = new Car(); IMovable log = new CarLogProxy; IMovable transaction = new CarTransactionProxy; transaction.move(); transaction.stop(); }}
  • 从3与4的Client可以看出,使用聚合的办法就只要用两个类就能实现需求
  • 显然,使用实现目标接口的方式进行代理,让代理和被代理对象之间都可以相互灵活转换
  • 所以一般静态代理使用聚合的方式进行实现,使用继承的方式多多少少有些过于笨重

想必认真的人都看的出来,静态代理的方式随着功能的增多,必然要生成更多的代理对象,这样不利于维护。而且,就目前的要求来看,对 move()stop() 两个方法添加日志,其中代码出现了冗余的情况,无法复用。那么有什么方式可以解决呢?

Client.java

public class Client { public static void main(String[] args) { IMovable movable = new Car(); IMovable logProxy =  Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开始执行" + method.getName; Object invoke =method.invoke(movable, args); System.out.println("执行" + method.getName; return invoke; } }); logProxy.move(); logProxy.stop(); System.out.println(); IMovable transProxy =  Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println(method.getName() + "开启事务"); Object invoke = method.invoke(logProxy, args); System.out.println(method.getName() + "事务提交"); return invoke; } }); transProxy.move(); transProxy.stop(); }}

运行结果:

图片 5动态代理.PNG

  • 从运行结果来看,我们使用动态代理实现了上面静态代理的例子,且没有编写多余的类
  • 从上面的代码可以看出,要使用动态代理就必须要有目标接口
  • InvocationHandler 的方法中可以获取要执行的 Method 实例
  • 通过 Method 的实例可以通过反射来执行,不过要传入被代理对象
  • 在反射前后可以进行添加日志和事务的操作
  • 而且也可以灵活的让进行代理对象与被代理对象之间的转换
  • 由于使用了反射,对性能有一定的损耗

动态代理原理

我们通过观察java.lang.reflect.Proxy的源码来了解动态代理的原理。下面的代码截取自openjdk7-b147 (安利一个不错的搜索java源码的网站:http://grepcode.com)

image.png

上面的方法截取自Proxy.newProxyInstance,可以看到,调用getProxyClass方法获取到一个代理类class对象,然后使用该class对象通过反射方法实例化一个对象返回。

接下来观察getProxyClass方法。

image.png

这部分代码截取自getProxyClass,先从缓存中查询是否已经生成过对应的class,若有,则直接返回该对象,没有,则继续下一步生成class

image.png

这部分代码是代理类class对象的生成过程。其中:

byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);这行代码调用ProxyGenerator.generateProxyClass返回了代理类class对象的字节码byte序列,
proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);这一行则进行了类加载的工作,最终生成了代理类class对象。

image.png

generateProxyClass,其中的gen.generateClassFile()方法实现了字节码的生成。

image.png

generateClassFile方法的实现。开头调用的三个addProxyMethod方法将object类中的hashcode、equals、toString方法重写,故对这三个方法的调用会传递到InvocationHandler.invoke方法当中。
注意,除了上述三个方法之外,调用代理类中Object定义的其他方法不会传递到invoke方法当中,也就是说,调用这些方法会执行Object中的默认实现。

如果想要查看ProxyGenerator.generateProxyClass这个方法在运行时产生的代理类中写了些什么,可以在main方法中加入:

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

运行时会将生成的class文件保存到硬盘当中:$Proxy0.class

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

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

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

  public final boolean equals(Object paramObject)
  {
    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 void request()
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

  public final int hashCode()
  {
    try
    {
      return ((Integer)this.h.invoke(this, m0, null)).intValue();
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

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

  static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m3 = Class.forName("Subject").getMethod("request", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      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());
    }
  }
}

上面的代码很好理解。可以看到equals、hashCode、toString以及我们Subject接口request方法的实现中都是调用了InvocationHandler.invoke方法,而这个InvocationHandler实例就是我们在Proxy.newProxyInstance中传入的对象。

综上,可以看到实现动态代理的几个步骤:

1.实现InvocationHandler

2.获得动态代理类,这一步又涉及到运行时代理类字节码的生成和类加载

3.通过反射机制(getConstructor(InvocationHandler.class))获取代理类的实例并返回该对象

4.调用代理对象的目标方法(也就是request方法,代理类也实现了Subject这个接口),调用转发到InvocationHandler.invoke方法当中,执行invoke的逻辑(我们自己的InvocationHandler实现)

至此,我们就了解了动态代理的运行原理。动态代理的机制也有一些缺陷,比如他代理的必须是接口方法。看一下我们上面生成的$Proxy0.class,可知这个代理类已经默认继承了类Proxy,所以,他只能通过实现我们提供的接口来代理我们的方法。在invoke方法中,我们可以通过对传入的代理类、方法和参数来进行判断,对不同的方法实现不同的业务逻辑。

动态代理源码解析

对于动态代理的源码其实最重要的就是下面两个方法,我们下面开始对他们进行深入分析,做到知其然知其所以然。

Proxy.newProxyInstance 部分代码

 public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException{ ... Class<?> cl = getProxyClass0(loader, intfs); try { ... final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; ... return cons.newInstance(new Object[]{h}); }catch (IllegalAccessException|InstantiationException e) { throw new InternalError(e.toString; } ... }
  • loader 定义代理类的类加载器
  • interfaces 代理类要实现的接口列表
  • h 指派方法调用的调用处理程序(注:动态代理的关键)
  • 将其他多余的部分代码忽略,找核心的代码(因为有些偏底层我也看不懂 -.- )
  • getProxyClass0(loader, intfs); 获得代理类
  • cl.getConstructor(constructorParams); 获得代理类的构造方法
  • cons.newInstance(new Object[]{h}); 反射生成代理对象,并传入 InvocationHandler

所以我们往下看看它是如何得到代理对象的

Proxy.getProxyClass0 代码

 private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory; private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // If the proxy class defined by the given loader implementing // the given interfaces exists, this will simply return the cached copy; // otherwise, it will create the proxy class via the ProxyClassFactory return proxyClassCache.get(loader, interfaces);
  • 注释翻译: 如果存在给定接口的给定装入器定义的代理类存在,则只返回缓存的副本;否则,它将通过proxyclassfactory创建代理类

所以我们就要进一步分析 (proxyClassCache)WeakCache 类是怎么进行缓存的。(个人能力有限对于WeakCache还有较多疑惑,之后会进行总结更新)

参考博文:

知道了是得到创建代理类,我们继续往下分析

InvocationHandler.java

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
  • proxy 在其上调用方法的代理实例
  • method 对应于在代理实例上调用的接口方法的 Method 实例,目标对象被调用的方法
  • args 包含传入代理实例上方法调用的参数值的对象数组

InvocationHandler用来连接代理对象与目标对象

分析代理类对象我们可以使用如下代码获取代理类$Proxy0.class文件

 public static void main(String[] args) { System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); System.out.println("$Proxy0.class: "+Proxy.getProxyClass(Inter.class.getClassLoader(), Inter.class)); // IMovable movable = new Car(); IMovable logProxy =  Proxy.newProxyInstance(Car.class.getClassLoader(), Car.class.getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("开始执行" + method.getName; Object invoke =method.invoke(movable, args); System.out.println("执行" + method.getName; return invoke; } }); logProxy.move(); logProxy.stop();}

运行结果:

图片 6获取$Proxy0.class文件运行截图.png

  • System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); 打开保存开关
  • System.out.println("$Proxy0.class全名: "+Proxy.getProxyClass(IMovable.class.getClassLoader(), IMovable.class)); 可以通过打印信息获取class在项目中路径
  • 关于这个类是如何生成的,需要往下跟踪 Proxy.getProxyClass0方法中的proxyClassCache.get(loader, interfaces),这与缓存相挂钩未进行详细分析。

在得到 $Proxy0.class 之后我们可以使用一些工具将class进行反编译,这里我使用了JD_GUI

$Proxy0.java部分代码

public final class $Proxy0 extends Proxy implements IMovable{ private static Method m1; private static Method m4; private static Method m2; private static Method m3; private static Method m0; public $Proxy0(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } ... public final void move() throws { try { this.h.invoke(this, m4, null); return; } catch ... } public final void stop() throws { try { this.h.invoke(this, m3, null); return; } catch ... } ... static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m4 = Class.forName("com.zzz.proxy.IMovable").getMethod("move", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); m3 = Class.forName("com.zzz.proxy.IMovable").getMethod("stop", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]); return; } catch ... }}
  • 构造方法传入InvocationHandler
  • 在静态代码块中,可以看到我们接口定义的 movestop 分别为 m4m3
  • 所以在我们调用代理对象时,就使用 InvocationHandler 回调出去,而 invoke 方法正是由我们实现的。

本文由365bet体育在线官网发布于网络编程,转载请注明出处:静态代理与动态代理

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。