设计模式-静态代理与动态代理

2018-08-05 本文已影响8人请叫我张懂

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

情境

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

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("汽车停止");
    }
}

静态代理

继承

1.添加日志

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(调用父类中的方法)前后加入打印日志的代码

运行截图:

静态代理_继承_日志.png

2.添加事务

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事务提交");
    }
}

运行结果:

静态代理_继承_事务.png

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

3.先添加日志再开启事务

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完成");
    }
}

运行结果:

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

4.先开启事务再添加日志

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事务提交");
    }
}

运行结果:

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

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

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

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

接口(聚合)

1.添加日志

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(movable);
        log.move();
        log.stop();
    }
}

从上面的代码可以看出，我们实现了IMovable接口(目标接口)，并传入了需要被代理的对象

2.添加事务

CarTransactionProxy.java

public class CarTransactionProxy implements IMovable {
private IMovable movable;

public CarTransactionProxy(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 transaction = new CarTransactionProxy(movable);
        transaction.move();
        transaction.stop();
    }
}

3.先添加日志再开启事务

Client.java

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

4.先开启事务再添加日志

Client.java

public class Client {
    public static void main(String[] args) {
        IMovable movable = new Car();
        IMovable log = new CarLogProxy(movable);
        IMovable transaction = new CarTransactionProxy(log);
        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 = (IMovable) 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 = (IMovable) 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();
    }
}

运行结果:

动态代理.PNG

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

动态代理源码解析

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

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(), e);
        }
        ...
        
}

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还有较多疑惑，之后会进行总结更新)

参考博文:

https://www.cnblogs.com/liuyun1995/p/8144676.html

https://www.jianshu.com/p/9f5566b5e7fb

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

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 = (IMovable) 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();
}

运行结果:

获取$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
在静态代码块中，可以看到我们接口定义的 move 和 stop 分别为 m4 和 m3
所以在我们调用代理对象时，就使用 InvocationHandler 回调出去，而 invoke 方法正是由我们实现的。

设计模式-静态代理与动态代理

情境

静态代理

继承

1.添加日志

2.添加事务

3.先添加日志再开启事务

4.先开启事务再添加日志

接口(聚合)

1.添加日志

2.添加事务

3.先添加日志再开启事务

4.先开启事务再添加日志

动态代理

动态代理源码解析

猜你喜欢

热点阅读