详情-思想者
JDK动态代理的理解与分析
发布于 2017-11-01 ,0条评论,482次浏览

前言

java的设计模式中有一项设计模式叫做代理模式,所谓代理模式,就是通过代理方来操作目标对象,而不是自己直接调用。代理又分为静态代理和动态代理,静态代理就是针对每个被代理对象写一个代理类,操作不够优雅;动态代理,可以根据接口动态的生成代理类,这动态生成的类不需要自己书写,jdk帮你完成了。无论是动态代理还是静态代理,最终都会产生一个代理类(class文件),里面都含有对被代理对象的封装,只是诞生的途径不一样。下面我在代码层面详细介绍一下这两种代理的实现和原理。

一、静态代理

1、创建手机接口 ,拥有打电话的行为

public interface MobilePhone {
    //打电话给jack
    void callJack();
}

2、创建实现类安卓手机,实现此接口

public class AndroidMobilePhone implements MobilePhone{
     private String name;
     private String age;

    public AndroidMobilePhone(String name, String age) {
        this.name = name;
        this.age = age;
    }
    //打电话给jack
    @Override
    public void callJack(){
         System.out.println(" hey boy! name="+name+",age="+age);
    }
}

3、创建静态代理类,实现此接口

public class AndroidMobileStaticProxyPhone implements MobilePhone{
     private MobilePhone amp;

    public AndroidMobileStaticProxyPhone(MobilePhone amp) {
        this.amp = amp;
    }
    //打电话给jack
    @Override
    public void callJack(){
        System.out.println("--静态代理前置--");
        amp.callJack();
        System.out.println("--静态代理后置--");
    }
}

从静态代理类AndroidMobileStaticProxyPhone 中,我们可以发现,他持有了MobilePhone 类型的对象,一旦将被代理对象传入,它就可以操作被代理对象了。

4、创建main方法调用

如果我们不使用代理,调用是这样的:

MobilePhone mp=new AndroidMobilePhone("杰克","23");
mp..callJack();

如果使用静态代理,调用变成如下方式:

 MobilePhone mp=new AndroidMobilePhone("杰克","23");
 MobilePhone staticProxy=new AndroidMobileStaticProxyPhone(mp);
 staticProxy.callJack();

从上述代码中,我们可以看出,静态代理其实就是通过一个包装类来调用目标对象而已。

二、动态代理

1、仍然沿用MobilePhone接口类
2、创建java.lang.reflect.InvocationHandler接口的实现类MobilePhoneHandler

public class MobilePhoneHandler<T> implements InvocationHandler {
    private T target;

    public MobilePhoneHandler(T target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //前置处理
        System.out.println("--动态代理前置处理--");
        Object obj=method.invoke(target,args);
        //后置处理
        System.out.println("--动态代理后置处理--");
        return obj;
    }
}

关于InvocationHandler ,源码注释如下:

* <p>Each proxy instance has an associated invocation handler.
 * When a method is invoked on a proxy instance, the method
 * invocation is encoded and dispatched to the {@code invoke}
 * method of its invocation handler.

即,每个代理实例都需要关联一个invocation handler,当一个方法被代理实例调用时,这个方法会被编码并发送到invocation handler中进行处理。这里所说的invocation handler即本文中刚刚创建的 MobilePhoneHandler 类。MobilePhoneHandler类所实现的invoke方法包装了对被代理对象的反射调用,后文中的动态代理类正是调用此invoke方法来调用被代理对象的方法。

3、创建main方法调用

MobilePhone mp=new AndroidMobilePhone("杰克","23");
InvocationHandler handler=new MobilePhoneHandler<MobilePhone>(mp);
MobilePhone mpProxy=(MobilePhone)Proxy.newProxyInstance(MobilePhone.class.getClassLoader(),new Class<?>[]{MobilePhone.class},handler );
mpProxy.callJack();

输出如下:

--动态代理前置处理--
 hey boy! name=杰克,age=23
--动态代理后置处理--

在输出内容的前置处理和后置处理中,我们可以加一些横向的处理逻辑,这样就变成了spring 的AOP。

关注Proxy.newProxyInstance这个方法调用,同样是来自于java.lang.reflect包里的类。看一下源码注释:

     * Returns an instance of a proxy class for the specified interfaces
     * that dispatches method invocations to the specified invocation
     * handler.  This method is equivalent to:
     * <pre>
     *     Proxy.getProxyClass(loader, interfaces).
     *         getConstructor(new Class[] { InvocationHandler.class }).
     *         newInstance(new Object[] { handler });
     * </pre>
     *

注释中表明,这个newProxyInstance方法返回了一个特定接口代理类的实例,这个代理实例将方法调用分配给特定的invocation handler。这个Proxy.newProxyInstance方法等同于如下调用:

 Proxy.getProxyClass(loader, interfaces). getConstructor(new Class[] { InvocationHandler.class }).newInstance(new Object[] { handler });

我们用debug方式跟踪一下代码,newProxyInstance方法最终会执行到Proxy的内部类ProxyClassFactory的apply方法:

long num = nextUniqueNumber.getAndIncrement();这一行使用cas生成一个自增长的序号 。
关注ProxyGenerator.generateProxyClass 方法:
此方法动态生成一个class文件,这个class文件就是我们所说的动态代理类! 我们用代码的方式将这个class文件写出来:

 byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", AndroidMobilePhone.class.getInterfaces());
        String path = "E:\\projectspace\\Test\\bin\\com\\proxy\\MobileProxy.class";
        try(FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(classFile);
            fos.flush();
            System.out.println("代理类class文件写入成功");
        } catch (Exception e) {
            System.out.println("写文件错误");
        }

到目录中找到此class文件:

反编先看一下反编译的类名和实现关系:

从此图中可以看出,动态代理类最终还是实现了我们的MobilePhone接口,即动态代理类也是MobilePhone接口的一个实现类,它也实现了callJack方法。如下:

红框标注this.h.invoke(this, m3, null);中的h正是我们上文中创建的MobilePhoneHandler类的对象。这样即可完成对被代理对象的调用。类的调用关系如下:

总结

我们再看一下之前main方法中的这一行:

MobilePhone mpProxy=(MobilePhone)Proxy.newProxyInstance(MobilePhone.class.getClassLoader(),new Class<?>[]{MobilePhone.class},handler );

现在可以得知Proxy.newProxyInstance返回的是动态生成的代理类$Proxy0的对象,也可以称作是MobilePhone 接口的一个实现类的对象。当调用mpProxy.callJack()时,其实是调用$Proxy0.callJack(),然后对照刚刚的类调用关系图,即可调用到被代理对象AndroidMobilePhone实例的callJack方法,从而实现了动态代理。

当我们具象的查看某一个动态代理class反编译文件时,比如$Proxy0,它内部就是采用静态代理的方式进行包装。其动态是体现在,能够在给定的接口和invocationHandler情况下,动态生成代理类,如$Proxy0,$Proxy1,$Proxy2等等,不必手动创建,使用起来更灵活。