动态代理-进阶高级开发必学技能

关于代理模式的话题有很多, 在开发中经常用到的应该是静态代理模式,能很好的去耦合。 动态代理是代理模式的另外一种实现。

动态代理的区别在哪里? 动态代理有什么好处? 今天我们来分析下这些问题。

回顾静态代理

之前我们分析过一次静态代理, 用代理模式优雅地写代码 一个典型的代理模式的 Proxy类像下面这样,

public class Proxy implements Func {
    private Func mUser;

    public Proxy(Func user) {
        this.mUser = user;
    }

    public void read() {
        mUser.read();
    }
}

public class User implements Func {
    void read(){
    ....
    }
}

对于调用者来说,需要把构造好的实例传给代理,然后就可以用代理来替代操作真正的实例了。

静态代理的问题是, 在接口代码少的情况下一切没什么问题,但是当接口增加的时候, Proxy 类就需要响应的增加接口,比方上面的 Func 接口,

interface Func {
    void read();
}

public class User implements Func {
    public void read(){
        System.out.println("user read");
    }
}

刚开始可能只有一个 read()方法,后面慢慢发展到有了 write(),有了 mark(), 随着接口量的增加, Proxy的维护工作量也在逐步增加。 那么动态代理能怎么解决这种问题呢?

动态代理的实现

动态代理的实现步骤基本如下: · 定义一个公共接口(像 Func)和实现类(像 User),这部分跟静态代理一样 · 定义一个 DynamicProxy类实现 InvocationHandler 接口,这个Proxy类似于静态代理的 Proxy然而不用实现 Func接口 · 调用 Proxy类来构造代理对象

在动态代理的实现中有两个东西非常重要,一个是 Proxy类,一个是 InvocationHandler接口,都位于 reflect包下, 我们来看第二个步骤所定义的 DynamicProxy是怎样的吧

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

public class DynamicProxy implements InvocationHandler {

  private Func user;

  public DynamicProxy(Func user) {
    this.user = user;
  }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        System.out.println("before invoke user method");
        method.invoke(this.user, objects);
        System.out.println("after invoke user method");
        return null;
    }
}

它同样持有了委托对象实例,但是和静态代理不同, 它并没有实现委托对象的接口方法, 而只实现了 InvocationHandler的 invoke方法,然后调用了 method.invoke(this.user, objects); 可以留意下 invoke方法,后面我们继续分析, 这里再贴一下 Client类的代码,也就是使用 Proxy的地方,

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

public class Client {

  public static void main(String[] args) {
      Func user = new User();
      InvocationHandler handler = new DynamicProxy(user);
      Func proxyUser = (Func) Proxy.newProxyInstance(handler.getClass().getClassLoader(), user.getClass().getInterfaces(), handler);
      proxyUser.read();
  }
}

跟静态代理不同的地方在于,虽然这里也需要实例化一个委托类的对象,并传给 Proxy的构造方法, 但这里所实例化的是 InvocationHandler对象,而不是 DynamicProxy的对象。 到这里就完成了一个动态代理的代码,输出结果如下

before invoke user method user read after invoke user method

比较&分析

· 先来说第二个步骤的 DynamicProxy的实现, 可以发现跟静态代理不同的地方在于,静态代理需要实现 Func接口的 read()方法,而动态代理实现的是 InvocationHandler的 invoke方法, 静态代理需要在不同的接口中去调用 User 接口的不同方法, 而动态代理在invoke被调用的过程中不需要关心需要调用 User 的哪个具体方法, 方法被封装在 method对象中,而所需要的参数则在 Object[] objects, 直接调用就可以

 method.invoke(this.user, objects);

这里就意味着即使以后增加了 Func的接口,对于 DynamicProxy来说也不需要增加额外的维护量。

· Proxy.newProxyInstance干了什么 在静态代理里面,我们会直接用 new StaticProxy(user)构造出来的静态对象直接操作, 而在动态代理里面,我们操作的是 Proxy.newProxyInstance所构造出来的动态代理对象 proxyUser, 可能初次接触动态代理的同学在这里就概念混乱了, "难道代理类不是 new DynamicProxy出来的对象吗?" 其实不是的,如果把 proxyUser的类名打印出来的话, 它会以 $ProxyN的形式存在,N从0开始,这个就是动态代理所生成的真正代理对象, 动态代理的意义就在于这里,$ProxyN 这个对象是在运行时创建的, 如果用代码来解释的话,$ProxyN的代码会像下面这样

public final class $Proxy1 extends Proxy implements Func{
    private InvocationHandler h;
    private $Proxy1(){}
    public $Proxy1(InvocationHandler h){
        this.h = h;
    }
    public void read(){
        Method method = Subject.class.getMethod("read"); //创建method对象
        h.invoke(this, method, null); //调用了invoke方法
    }
}

这个才是真正的代理类。

原文发布于微信公众号 - Android每日一讲(gh_f053f29083b9)

原文发表时间:2018-06-08

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

扫码关注云+社区

领取腾讯云代金券