性能文章>面试官:为什么jdk动态代理只能代理接口实现类?>

面试官:为什么jdk动态代理只能代理接口实现类?原创

3446025

 **本文首发于公众号【看点代码再上班】,欢迎围观,第一时间获取最新文章。**

原文地址:https://mp.weixin.qq.com/s/LWToCjGGP52_0cy9xkiHlQ

 

大家好,我是tin,这是我的第15篇原创文章

 

我们日常业务能够使用jdk动态代理编码的场景非常少,但是我们使用的框架用到jdk动态代理的却非常多,今天结合jdk动态代理源码讲一讲“为什么jdk动态代理只能代理接口?”,先上一个目录:

一、把jdk动态代理跑起来

顾名思义,jdk动态代理是jdk实现的一个功能,不需要第三方库支持,我们配置好依赖jdk到我们的工程即可使用,要把jdk动态代理跑起来,非常简单:

  • 业务目标对象实现接口;

  • 实现InvocationHandler接口;

  • 使用Proxy.newProxyInstance生成代理对象;

 

定义业务BookFacade接口:

BookFacadeImpl接口实现:

 

定义MyInvocationHandler实现InvocationHandler接口:

package com.tin.example.jdk.proxy;
​
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
​
/**
 * title: MyInvocationHandler
 * <p>
 * description:
 *
 * @author tin @公众号【看点代码再上班】 on 2022/1/22 上午9:01
 */
public class MyInvocationHandler implements InvocationHandler {
    //目标对象
    private Object target;
​
    public Object getInstance(Object target) {
        this.target = target;
        Class clazz = this.target.getClass();
        // Proxy.newProxyInstance的三个参数分别是:
        // 1 被代理类的类加载器
        // 2 被代理类的接口
        // 3 java.lang.reflect.InvocationHandler
        return Proxy.newProxyInstance(clazz.getClassLoader(),
                clazz.getInterfaces(),
                this);
    }
​
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("------前置通知------------");
        // 执行目标方法
        Object result = method.invoke(target, args);
        System.out.println("------后置处理------------");
        return result;
    }
}

MyInvocationHandler类内的Proxy.newProxyInstance生成代理对象。通过以上类定义,我们来写一个main测试类:

package com.tin.example.jdk.proxy;
​
/**
 * title: JdkProxyTest
 * <p>
 * description:
 *
 * @author tin @公众号【看点代码再上班】 on 2022/1/22 上午9:11
 */
public class JdkProxyTest {
    public static void main(String[] args) throws Exception {
        //sun.misc.ProxyGenerator.saveGeneratedFiles 用于输出代理类class文件到本地
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
​
        //代理接口
        BookFacade proxy = (BookFacade) new MyInvocationHandler().getInstance(new BookFacadeImpl());
        proxy.addBook("Java性能权威指南@【看点代码再上班】");
    }
}

main方法运行结果如下:

因为我的测试类已经加了以下代码:

System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

这是用于把生成的proxy代理类的class文件输出到本地的,打开生成的class文件,内容如下:

同样的,生成的代理类实现了目标接口定义的方法addBook():

到这里就可以初步回答我们标题的问题了:

jdk动态代理生成的代理类实现了我们业务定义的接口,并重写了我们接口的方法,如此才实现代理的功能,所以我们的目标类需要实现接口。

 

二、复现问题“jdk动态代理不能代理普通类”

看了以上示例估计就有朋友反问了,所举例子只是一个特例,说明接口实现类可以被jdk代理,非接口实现类也可以吧,不一定是通过"implements"方式实现,这就是我们这小节的问题“jdk动态代理能不能代理普通类?”。

 

新建一个没有实现接口的类BookOperation:

public class BookOperation {
    public void addBook(String bookName) {
        System.out.println("添加书籍, bookName:" + bookName);
    }
}

Test测试类如下:

public class JdkProxyTest {
    public static void main(String[] args) throws Exception {
        //sun.misc.ProxyGenerator.saveGeneratedFiles 用于输出代理类class文件到本地
        System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
        //代理普通类
        BookOperation bookOperation = (BookOperation) new MyInvocationHandler().getInstance(new BookOperation());
        bookOperation.addBook("Java性能权威指南@【看点代码再上班】");
    }
}

依然通过类强转的方式获取生成的类:

BookOperation bookOperation = (BookOperation) new MyInvocationHandler().getInstance(new BookOperation());

有朋友可能会反问,它不一定是生成BookOperation类,这样取是不是不合适的?是的,这样的提问是没问题的,但是如果不强转,我不知道如何能够调用我们的目标方法。

 

为了能够验证需要类型强转且确确实实无法代理非接口实现类,我们看下面的运行结果以及生成的代理类的结构。

 

运行结果如下:

 

从抛的异常来看,代理类Proxy已经生成,但不是我想要的BookOperation的代理类!类型强转失败。

 

既然不是我指定的目标类的代理类,那么生成的Proxy类究竟是怎么样的呢?

 

见下图:

和我们前面的Proxy最大的不同在于没有实现接口(因为BookOperation没有实现接口,这是必然的),整个Proxy内也没有addBook()方法。

 

既然没有目标类的方法,代理类如何执行我们的目标方法?

 

既然没有接口,那为什么不能继承BookOperation类完成代理功能?!”会有人这么想。

 

这样想就对了,这个也就是cglib采用的方式,具体原理请阅读以下文章啦:

面试官:cglib为什么不能代理private方法?

 

到这里,我们可以再次确定标题所问之答案:jdk动态代理无法代理非接口实现类。

 

三、深入源码分析

以上只是通过表层分析我们的jdk动态代理无法代理非接口实现类。是否真如此呢?我们通过源码看一看。

 

jdk代理的关键在代理类的生成。我们从Proxy.newProxyInstance()方法切入,深入分析代理类是如何生成的。 

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
{
        Objects.requireNonNull(h);
​
        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
​
        /*
         * Look up or generate the designated proxy class.
         * ① 寻找或者生成(如果缓存没有)指定代理类
         */
        Class<?> cl = getProxyClass0(loader, intfs);
​
        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
        /*
         * ② 获取构造器
         */
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
         /*
         * ③ 根据我们定义的invocation handler生成代理对象
         */
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

Proxy.newProxyInstance()关键在两步:

  • ① Class<?> cl = getProxyClass0(loader, intfs) 生成代理类;

  • ② return cons.newInstance(new Object[]{h}) 生成代理对象;

第①点,生成代理类,就是生成我们以上com/sun/proxy/$Proxy0.class代理类的字节码,继续跟进去看一下。

 

getProxyClass0方法代码很少,其内部直接调用了proxyClassCache.get方法:

proxyClassCache是一个本地静态变量也是一个缓存cache,其构造器的两个入参KeyFactory和ProxyClassFactory至关重要,分别对应keyFactory和valueFactory

继续进入到proxyClassCache.get()方法内部,如下:

看上图的第③点,获取最终的代理类value值重点就在于Factory的get()方法:

 

前面讲proxyClassCache的构造器入参时已经提到valueFactory对应的就是ProxyClassFactory。valueFactory.apply其实对应的是ProxyClassFactory#apply。

 

我们继续跟进去看看ProxyClassFactory#apply方法逻辑(ProxyClassFactory也是Proxy的一个内部类):

 

第①点,

interfaceClass = Class.forName(intf.getName(), false, loader);

验证入参类加载器按全限定名称重新加载入参接口得到的class对象是否和接口class对象相同,主要也是为了验证类加载器是否相同,因为同一个类加载器加载的class才相同,否则不相同:


第①点,

if (!interfaceClass.isInterface())

验证入参class对象是否是接口。

 

其实,如果目标类没有实现接口,interfaces数组会为空,不会走到这里,我们启动非接口实现类debug如下:

interfaces为空,会导致最终生成的代理类缺少相关的方法。继续跟进到第③点生成代理类一看究竟。

 

sun.misc.ProxyGenerator#generateProxyClass(java.lang.String, java.lang.Class<?>[], int)方法如下:

最终生成class是在generateClassFile(),该方法生成类的方法和属性等信息,它会遍历interfaces中的每一个接口class,把class的每一个方法包装为ProxyMethod对象,最后通过ProxyMethod生成代理类的代理方法并输出到字节流中,如下图:

从以上图示可以很明显的看出来,非接口实现类传的参数interfaces是一个空数组,最后generateClassFile()无法生成对应的代理方法。

 

以上,从源码维度也佐证了jdk动态代理依赖接口,只有实现了接口的类的方法才能被加入到代理类中生成代理方法,最终完成代理功能

 

四、结语

我是tin,一个在努力让自己变得更优秀的普通工程师。自己阅历有限、学识浅薄,如有发现文章不妥之处,非常欢迎加我提出,我一定细心推敲并加以修改。

 

坚持创作不容易,你的正反馈是我坚持输出的最强大动力,谢谢!

最后别忘了关注我公众号哦【看点代码再上班】!附上原文链接⏬⏬⏬  
https://mp.weixin.qq.com/s/LWToCjGGP52_0cy9xkiHlQ

点赞收藏
分类:标签:
看点代码再上班
请先登录,感受更多精彩内容
快去登录吧,你将获得
  • 浏览更多精彩评论
  • 和开发者讨论交流,共同进步

为你推荐

JAVA使用CompletableFuture实现流水线并行处理,加速你的接口响应

JAVA使用CompletableFuture实现流水线并行处理,加速你的接口响应

讲透JAVA Stream的collect用法与原理,远比你想象的更强大

讲透JAVA Stream的collect用法与原理,远比你想象的更强大

没有二十年功力,写不出Thread.sleep(0)这一行“看似无用”的代码!

没有二十年功力,写不出Thread.sleep(0)这一行“看似无用”的代码!

【译】记一次数据库连接泄漏导致的响应迟缓

【译】记一次数据库连接泄漏导致的响应迟缓

【全网首发】微服务10:系统服务熔断、限流

【全网首发】微服务10:系统服务熔断、限流

【全网首发】MQ-消息堆积-JDK Bug导致线程阻塞案例分析

【全网首发】MQ-消息堆积-JDK Bug导致线程阻塞案例分析

25
0