面试必问系列之JDK动态代理

扫描文末二维码或者微信搜索公众号小李不秃，即可关注微信公众号，获取到更多 Java 相关内容。

1. 带着问题去学习

面试中经常会问到关于 Spring 的代理方式有哪两种？大家异口同声的回答：JDK 动态代理和 CGLIB 动态代理。

这两种代理有什么区别呢？JDK 动态代理的类通过接口实现，CGLIB 动态代理是通过子类来实现的。

那 JDK 动态代理你了到底了解多少呢？有去看过代理对象的 class 文件么？下面两个关于 JDK 动态代理的问题你能回答上来么？

  • 问题1：为什么 JDK 动态代理要基于接口实现？而不是基于继承来实现？
  • 问题2：JDK 动态代理中，目标对象调用自己的另一个方法，会经过代理对象么？

小李带着大家更深入的了解一下 JDK 的动态代理。

2. JDK 动态代理的写法

  • JDK 动态代理需要这几部分内容：接口、实现类、代理对象。
  • 代理对象需要继承 InvocationHandler，代理类调用方法时会调用 InvocationHandler 的 invoke 方法。
  • Proxy 是所有代理类的父类，它提供了一个静态方法 newProxyInstance 动态创建代理对象。
public interface IBuyService {
     void buyItem(int userId);
     void refund(int nums);
}

 

@Service
public class BuyServiceImpl implements IBuyService {
    @Override
    public void buyItem(int userId) {
        System.out.println("小李不秃要买东西！小李不秃的id是： " + userId);
    }
    @Override
    public void refund(int nums) {
        System.out.println("商品过保质期了，需要退款，退款数量 ：" + nums);
    }
}

 

public class JdkProxy implements InvocationHandler {

    private Object target;
    public JdkProxy(Object target) {
        this.target = target;
    }
    // 方法增强
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(args);
        Object result = method.invoke(target,args);
        after(args);
        return result;
    }
    private void after(Object result) { System.out.println("调用方法后执行！！！！" ); }
    private void before(Object[] args) { System.out.println("调用方法前执行！！！！" ); }

    // 获取代理对象
    public <T> T getProxy(){
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }
}

 

public class JdkProxyMain {
    public static void main(String[] args) {
        // 标明目标 target 是 BuyServiceImpl
        JdkProxy proxy = new JdkProxy(new BuyServiceImpl());
        // 获取代理对象实例
        IBuyService buyItem = proxy.getProxy();
        // 调用方法
        buyItem.buyItem(12345);
    }
}

查看运行结果

调用方法前执行！！！！
小李不秃要买东西！小李不秃的id是： 12345
调用方法后执行！！！！

我们完成了对目标方法的增强，开始对代理对象进行一个更全面的分析。

3. 剖析代理对象并解答问题

剖析代理对象的前提得是有代理对象，动态代理的对象是在运行时期创建的，我们就没办法通过打断点的方式进行分析了。但是我们可以通过反编译 .class 文件进行分析。如何获取到 .class 文件呢？

通过在代码中添加：System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true") ，就能够实现将动态代理对象的 class 文件写入到磁盘中。代码如下：

public class JdkProxyMain {
    public static void main(String[] args) {
        // 代理对象的 class 文件写入到磁盘中
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        // 标明目标 target 是 BuyServiceImpl
        JdkProxy proxy = new JdkProxy(new BuyServiceImpl());
        // 获取代理对象实例
        IBuyService buyItem = proxy.getProxy();
        // 调用方法
        buyItem.buyItem(12345);
    }
}

在项目的根目录下多了一个 $Proxy0.class 文件

看一下这个文件的内容

public final class $Proxy0 extends Proxy implements IBuyService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    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 buyItem(int var1) throws  {
        try {
            super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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 void refund(int var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    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("com.example.springtest.service.IBuyService").getMethod("buyItem", Integer.TYPE);
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.example.springtest.service.IBuyService").getMethod("refund", Integer.TYPE);
            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 继承了 Proxy 类并且实现了 IBuyService 接口。那问题 1 的答案就出来了：动态代理对象默认继承了 Proxy 对象，而且 Java 不支持多继承，所以 JDK 动态代理要基于接口来实现。

$Proxy0 重写了 IBuyService 接口的方法，还有 Object 的方法。在重写的方法中，统一调用 super.h.invoke 方法。super 指的是 Proxy，h 代表 InvocationHandler，这里就是 JdkProxy。所以这里调用的是 JdkProxy 的 invoke 方法。

所以每次调用 buyItem 方法的时候，会先打印出 调用方法前执行！！！！。

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before(args);
// 通过反射调用方法
Object result = method.invoke(target,args);
after(args);
return result;
}
private void after(Object result) { System.out.println("调用方法后执行！！！！" ); }
private void before(Object[] args) { System.out.println("调用方法前执行！！！！" ); }

问题 2 还没解决呢，接着往下看

@Service
public class BuyServiceImpl implements IBuyService {
    @Override
    public void buyItem(int userId) {
        System.out.println("小李不秃要买东西！小李不秃的id是： " + userId);
        refund(100);
    }
    @Override
    public void refund(int nums) {
        System.out.println("商品过保质期了，需要退款，退款数量 ：" + nums);
    }
}

上面这段代码中，在 buyItem 调用内部的 refund 方法，那这个内部调用方法是否走代理对象呢？看一下执行结果：

调用方法前执行！！！！
小李不秃要买东西！小李不秃的id是： 12345
商品过保质期了，需要退款，退款数量 ：100
调用方法后执行！！！！

确实是没有走代理对象，其实我们期待的结果是下面这样的

调用方法前执行！！！！
小李不秃要买东西！小李不秃的id是： 12345
调用方法前执行！！！！
商品过保质期了，需要退款，退款数量 ：100
调用方法后执行！！！！
调用方法后执行！！！！

那为什么会造成这种差异呢？

因为内部调用 refund 方法的调用，相当于 this.refund（100），而这个 this 指的是 BuyServiceImpl 对象，而不是代理对象，所以refund 方法没有得到增强。

4. 总结和延伸

  • 本篇文章了解了 JDK 动态代理的使用，通过分析 JDK 动态代理生成对象的 class 文件，解决了两个问题：

    • 问题1：为什么 JDK 动态代理要基于接口实现？而不是基于继承来实现？
    • 解答：因为 JDK 动态代理生成的对象默认是继承 Proxy ，Java 不支持多继承，所以 JDK 动态代理要基于接口来实现。
    • 问题2：JDK 动态代理中，目标对象调用自己的另一个方法，会经过代理对象么？
    • 解答：内部调用方法使用的对象是目标对象本身，被调用的方法不会经过代理对象。

  • 我们知道了 JDK 动态代理内部调用是不走代理对象的。那对于 @Transactional 和 @Async 等注解不起作用是不是就搞清楚为啥了？

  • 因为 @Transactional 和 @Async 等注解是通过 Spring AOP 来进行实现的，如果动态代理使用的是 JDK 动态代理，那么在方法的内部调用该方法中其它带有该注解的方法，由于此时调用的不是动态代理对象，所以注解失效。

  • 上面这些问题就是 JDK 动态代理的缺点，那 Spring 如何避免这个问题呢？就是另个一个动态代理：CGLIB 动态代理，我会在下篇文章进行分析。

5. 参考

  • https://juejin.im/post/5d8a0799f265da5b7a752e7c#heading-6
  • https://blog.csdn.net/varyall/article/details/102952365

6. 猜你喜欢

扫描下方二维码即可关注微信公众号小李不秃，一起高效学习 Java。

posted @ 2020-06-20 19:09  小李不秃  阅读(2587)  评论(0)  编辑  收藏  举报