Java动态代理那些你容易忽略的细节

前言

本来是打算把java代理模式给写一下的,但是整理思路的时候发现这是一个庞大的工程,我需要讲清楚什么是代理模式;它的应用场景有哪些;代理又分为静态代理和动态代理,它们分别是如何实现的,区别又是什么,我还要举例,分析源码,emm。显然,我现在的时间安排是无法完成这个庞大的工程的,所以我就讲一下目前解决问题中遇到的动态代理吧(默认你大致了解代理模式)


为什么要写这篇文章

我最近在学习Retrofit2源码,而这个框架比较核心的一点就是动态代理,所以在这里把我学习过程中的一些我认为比较关键的地方整理出来,分享给有需要的童鞋。

Retrofit2的动态代理到底体现在哪里?请看下面代码

//retrofit的API接口对象
ApiService apiService;
//创建代理对象
 apiService = retrofit.create(ApiService.class);
//调用代理类中的方法
apiService.xxx();

这是retrofit.create方法的源码,很明显的动态代理

Java动态代理那些你容易忽略的细节_第1张图片
retrofit2源码.png


动态代理的本质是什么?

我的理解:

  • 提供一个代理来控制对象的访问;
  • 程序运行时动态生成代理类,这个代理类继承于Proxy,并且实现自定义的委托类的接口;
  • 丰富原始类的操作

动态代理的具体实现

本来是不想写一堆代码来说动态代理的代码是如何实现的,但是没办法,有些问题不通过举例无法说清楚,下面一起来看一个简单的例子吧:

学生每学期都需要参加期末考试的

public interface Student {
    //参加考试
    void exam();
}

学生分为很多专业的,其中计算机专业的学生需要参加计算机专业考试

public class ComputerStudent implements Student {
    private String name;

    public ComputerStudent(String name) {
        this.name = name;
    }

    @Override
    public void exam() {
        System.out.println(name + " 参加计算机专业考试");
    }
}

由于每个学生的专业能力不一致,有的需要在考试前刷刷题,有的需要去找学霸辅导一下(抱大腿),等等,总之每个学生在考试前都需要做一些事情。

如果现在需要定义很多不同特点的学生,你怎么做呢?如果去一个个定义不同的行为的话,那将是非常庞大的工作量,那有没有简单的办法呢?答案是有的,通过代理类就可以实现。

事实上我们没有必要去定义每个学生,因为每个学生的行为是没办法确定的,我们可以通过动态代理在它做这个动作的时候去实现他的特定行为。

public class Test {
    public static void main(String[] args){
        //生成$Proxy0的class文件
        //System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        //被代理类
        final Student jack =new ComputerStudent("jack");

        //生成代理对象
     Student jackProxy= (Student) Proxy.newProxyInstance(jack.getClass().getClassLoader(),
                jack.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("before exam do something");

                        //通过反射调用对象的方法
                        method.invoke(jack,args);

                        System.out.println("after exam do something");

                        return null;
                    }
                });

        //代理方法调用
        jackProxy.exam();
    }
}

当调用代理类的exam()方法,程序运行结果如下

Java动态代理那些你容易忽略的细节_第2张图片
结果.png

这里有个重点,通过代理类对象jackProxy去调用方法和接口实现类对象jack去调用方法是有明显区别的,通过代理方式去调用,可以在原来方法执行前后做一些其它操作,这就是代理模式的特点


那些你容易忽略的细节

首先回顾一下动态代理的实现流程:

  • 1、通过Proxy.newProxyInstance方法创建一个代理对象;
  • 2、在内部类InvocationHandlerinvoke()方法中做一些操作:利用反射调用被代理类(这里是ComputerStudent)中的方法,通常在这个调用方法前后还会做一些其它操作;
  • 3、代理对象jackProxy调用方法

对整个流程有个了解之后,下面来看一些细节问题。

Q1: Proxy.newProxyInstance中的3个参数到底是什么?为什么要穿入这3个参数?

系统接口定义如下:

public static Object newProxyInstance(ClassLoader loader,
                                          Class[] interfaces,
                                          InvocationHandler h)
  • loader :定义代理类的类加载器,这里要代理的是jack,所以用jack的类加载器
  • interfaces :是一个接口类的集合,具体来说是代理类实现的接口的集合,也是被代理类实现的接口的集合;
  • h :代理类对象调用方法时需要用到的一个接口对象,在系统生成的代理类内部会用到它。

到这里,我想细心的童鞋会想这个代理类到底是什么?似乎从头到尾没有露面过。的确是这样,即使你去翻遍源码你也找不到这个代理类,因为在动态代理模式中它是在运行时生成的,所以你在源码甚至.class中都找不到他的影子。

我先说结论:运行时动态生成的代理类叫做$Proxy0,关于这个类怎么看源码,很多介绍代理的文章都没有说清楚,读者也是一脸懵逼;如果你想要看它的内容,可以通过如下方法

public class Test {
    public static void main(String[] args){
        //生成$Proxy0的class文件
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        //被代理类
     Student jack =new ComputerStudent("jack");
        //生成代理对象
     Student jackProxy= (Student) Proxy.newProxyInstance();
}

在运行方法中添加这一行代码,在运行后会自动在项目根目录生成com文件夹,其中...\IdeaProjects\com\sun\proxy下会生成$Proxy0.class文件。注意:我是在IDEA上调试成功的,我在Android Studio上测试是没有生成的。暂时不知道原理,有了解的大佬可以科普一下。
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

代理类$Proxy0源码如下:

package com.sun.proxy;

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

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

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void exam() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("student.Student").getMethod("exam");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            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先说几个结论:

  • $Proxy0 继承了Proxy,实现了自定义的目标接口Student
  • $Proxy0定义了接口Student中的方法exam(),以及Object对象的几个方法equals()toString()hashCode()
  • 构造方法中传了InvocationHandler对象,并且在定义的方法中调用了它的invoke()方法

回到刚才的问题,Proxy.newProxyInstance为什么要穿入这3个参数?

        //生成代理对象
     Student jackProxy= (Student) Proxy.newProxyInstance(jack.getClass().getClassLoader(),
                jack.getClass().getInterfaces(),
                new InvocationHandler() );

因为代理对象是基于自定义接口Studentjack类加载器代理出来的。

Q2:InvocationHandler的作用及其invoke()方法等解释

当代理对象调用一个方法时,会回调执行InvocationHandler中的一个方法。

关于invoke()方法,在看了源码和反复代码验证之后,我做出的解释如下:

 /**
     * 这个方法不是我们显示的去调用,是系统生成的代理类$Proxy0中调用的
     *
     * @param proxy  代理对象:也就是Proxy.newProxyInstance返回的对象
     * @param method 要调用的方法
     * @param args   调用方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {}

注意:nvoke()不是显示调用的,是在代理类中去调用的

下面再来看一个问题

public class Test {
    public static void main(String[] args){
        //生成$Proxy0的class文件
        //System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

        //被代理类
        final Student jack =new ComputerStudent("jack");

        //生成代理对象
     Student jackProxy= (Student) Proxy.newProxyInstance(jack.getClass().getClassLoader(),
                jack.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                        System.out.println("before exam do something");

                        //通过反射调用对象的方法
                        method.invoke(jack,args);

                        System.out.println("after exam do something");

                        return null;
                    }
                });

        //方法调用
        jackProxy.exam();
    }
}

看一下InvocationHandlerinvoke()方法内部的调用

  //通过反射调用对象的方法
  method.invoke(jack,args);

这句代码的作用是通过反射调用一个方法,如果把实现类对象jack换成代理类对象proxy会发生什么?

结论:会循环报错,停不下来那种。因为proxy是代理实例,也就是这里的jackProxy,当这个对象的方法被调用的时候会触发InvocationHandlerinvoke()方法,而InvocationHandler内部又再次调用proxy的方法,如此不停循环。

动态代理的使用场景

优点:在运行时切入原始类,改变类的方法,这样可以丰富该方法的操作,比如在方法之前、之后做一些其它操作。

应用的话,比如Retrofit框架、AOP(面向切面编程)等等。

你可能感兴趣的:(Java动态代理那些你容易忽略的细节)