• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

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

开发技术 开发技术 3周前 (06-20) 25次浏览

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

1. 带着问题去学习

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

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

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

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

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

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

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

2. JDK 动态代理的写法

  • JDK 动态代理需要这几部分内容:接口、实现类、代理对象。
  • 代理对象需要继承 InvocationHandler,代理类调用方法时会调用 InvocationHandlerinvoke 方法。
  • Proxy 是所有代理类的父类,它提供了一个静态方法 newProxyInstance 动态创建代理对象。

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

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> 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
调用方法后执行!!!!

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

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

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 文件

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

看一下这个文件的内容

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 动态代理要基于接口来实现。

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

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

所以每次调用 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 还没解决呢,接着往下看

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

@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 方法没有得到增强

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

4. 总结和延伸

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

    • 问题1:为什么 JDK 动态代理要基于接口实现?而不是基于继承来实现?
    • 解答:因为 JDK 动态代理生成的对象默认是继承 Proxy ,Java 不支持多继承,所以 JDK 动态代理要基于接口来实现。
    • 问题2:JDK 动态代理中,目标对象调用自己的另一个方法,会经过代理对象么
    • 解答:内部调用方法使用的对象是目标对象本身,被调用的方法不会经过代理对象。
  • 我们知道了 JDK 动态代理内部调用是不走代理对象的。那对于 @Transactional 和 @Async 等注解不起作用是不是就搞清楚为啥了?

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

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

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

5. 参考

6. 猜你喜欢

  • JSON的学习和使用

  • 学习反射看这一篇就够了

  • 并发编程学习(一)Java 内存模型

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

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


喜欢 (0)