JDK 原生动态代理是怎么实现的(附面试题)

发布时间:2023-06-17 13:48:08

反射

反射机制是 Java 语言提供的基本功能使程序在运行过程中自省(introspect)能力。简单来说,在运行过程中,可以通过反射获得、检测和调用对象的属性和方法。

使用场景进行反射

现实中反射的使用场景有很多,比如以下几个。

使用场景1:编程工具 IDEA 或 Eclipse 等等,写代码时会有代码(属性或方法名)提示,因为使用了反射。

使用场景二:许多著名的框架,为了使程序更加优雅和简洁,也会使用反射。

例如,Spring 不同的类别可以通过配置加载,调用不同的方法,代码如下:

<bean id="person" class="com.spring.beans.Person" init-method="initPerson"></bean>

例如,MyBatis 在 Mapper 使用外部类别 SQL 构建查询时,代码如下:

@SelectProvider(type = PersonSql.class, method = "getListSql")List<Person> getList();class PersonSql {    public String getListSql() {        String sql = new SQL() {{            SELECT("*");            FROM("person");        }}.toString();        return sql;    }}

使用场景三:数据库连接池,也会使用反射调用不同类型的数据库驱动,代码如下:

String url = "jdbc:mysql://127.0.0.1:3306/mydb";String username = "root";String password = "root";Class.forName("com.mysql.jdbc.Driver");Connection connection = DriverManager.getConnection(url, username, password);

当然,还有许多其他类似的反射场景。这里不一一列举。读者可以从一个例子中得出推论,思考在正常开发中使用反射功能的场景。

基本使用反射

接下来,我们通过反射调用类中的某种方法来学习反射的基本使用。

使用反射调用类的方法可分为三种情况:

  • 调用静态方法
  • 调用公共方法
  • 调用私有方法

假设有一个实体类 MyReflect 上述三种方法包括代码如下:

package com.interview.chapter4;class MyReflect {    // 静态方法    public static void staticMd() {        System.out.println("Static Method");    }    // 公共方法    public void publicMd() {        System.out.println("Public Method");    }    // 私有方法    private void privateMd() {        System.out.println("Private Method");    }}

以下是如何使用反射来调用上述三种方法。

① 反射调用静态方法
Class myClass = Class.forName("com.interview.chapter4.MyReflect");Method method = myClass.getMethod("staticMd");method.invoke(myClass);
② 反射调用公共方法
Class myClass = Class.forName("com.interview.chapter4.MyReflect");// 创建实例对象(相当于创建实例对象(相当于) new )Object instance = myClass.newInstance();Method method2 = myClass.getMethod("publicMd");method2.invoke(instance);
③ 反射调用私有方法
Class myClass = Class.forName("com.interview.chapter4.MyReflect");// 创建实例对象(相当于创建实例对象(相当于) new )Object object = myClass.newInstance();Method method3 = myClass.getDeclaredMethod("privateMd");method3.setAccessible(true);method3.invoke(object);
反射使用总结

可以通过反射获得调用类 Class.forName()反射获取实例应通过 newInstance(),等于 new 通过反射获取新对象的方法 getMethod()获得类似方法后使用 invoke() 调用对类方法。如果类法是私有方法,则需要通过 setAccessible(true) 修改方法的访问限制,以上操作是反射的基本使用。

动态代理

动态代理可以理解为应该自己做的事情,但交给别人代为处理。这个过程叫做动态代理。

使用动态代理的场景

众所周知,动态代理的使用场景是 Spring 面向切面编程(AOP)。例如,依赖注入 @Autowired 和事务注解 @Transactional 等等,都是通过动态代理来实现的。

动态代理也可以包装一些 RPC 调用,也可以通过代理实现全局拦截器等。

动态代理与反射的关系

JDK 原生提供的动态代理是通过反射实现的,但动态代理的实现也可以是 ASM(短小精悍的字节码操作框架)、cglib(基于 ASM)等等,不局限于反射。

让我们分别来看看:JDK 原生动态代理和 cglib 的实现。

1)JDK 原生动态代理
interface Animal {    void eat();}class Dog implements Animal {    @Override    public void eat() {        System.out.println("The dog is eating");    }}class Cat implements Animal {    @Override    public void eat() {        System.out.println("The cat is eating");    }}// JDK 代理class AnimalProxy implements InvocationHandler {    private Object target; // 代理对象    public Object getInstance(Object target) {        this.target = target;        // 获取代理对象        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().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;    }}public static void main(String[] args) {    // JDK 动态代理调用    AnimalProxy proxy = new AnimalProxy();    Animal dogProxy = (Animal) proxy.getInstance(new Dog());    dogProxy.eat();}

通过动态代理,我们在所有请求之前和之后打印了一个简单的信息。

注意: JDK Proxy 只能代理实现接口的类别(即使是 extends 继承也是不能代表的)。

2)cglib 动态代理

要是用 cglib 要实现添加对 cglib 如果是,引用 maven 对于项目,直接添加以下代码:

<dependency>    <groupId>cglib</groupId>    <artifactId>cglib</artifactId>    <version>3.2.12</version></dependency>

cglib 具体实现请参考以下代码:

class Panda {    public void eat() {        System.out.println("The panda is eating");    }}class CglibProxy implements MethodInterceptor {    private Object target; // 代理对象    public Object getInstance(Object target) {        this.target = target;        Enhancer enhancer = new Enhancer();        // 以父类为例类        enhancer.setSuperclass(this.target.getClass());        // 回调方法        enhancer.setCallback(this);        // 创建代理对象        return enhancer.create();    }    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {        System.out.println(调用前”);        Object result = methodProxy.invokeSuper(o, objects); // 调用执行方法        System.out.println(调用后”);        return result;    }}public static void main(String[] args) {    // cglib 动态代理调用    CglibProxy proxy = new CglibProxy();    Panda panda = (Panda)proxy.getInstance(new Panda());    panda.eat();}

上述程序执行结果:

调用前

The panda is eating

调用后

以上代码可以知道,cglib 通过实现调用 MethodInterceptor 接口的 intercept 方法,调用 invokeSuper 动态代理。它可以直接动态代理普通类,不需要像 JDK 代理需要通过接口完成,值得一提的是 Spring 也通过了动态代理 cglib 实现的。

注意:cglib 底层是通过子类继承被代理对象来实现动态代理的,所以代理类不能是最终类(final),否则会报错 java.lang.IllegalArgumentException: Cannot subclass final class xxx。

1.动态代理解决了哪些问题?

答:首先,它是一种代理机制。如果我们熟悉设计模式中的代理模式,我们就会知道代理可以被视为调用目标的包装。这样,我们就不会直接调用目标代码,而是通过代理完成。通过代理,调用者和实现者可以解耦。例如 RPC 调用,通过代理,可以提供更友好的界面;也可以通过代理制作全局拦截器。

2.动态代理与反射的关系是什么?

答:反射可以用来实现动态代理,但动态代理还有其他实现方法,比如 ASM(短小精悍的字节码操作框架)、cglib 等。

3.以下描述的错误是什么?

A:cglib B的性能更高:Spring 中有使用 cglib 实现动态代理C:Spring 中有使用 JDK 原生动态代理D:JDK 原生动态代理性能更高

答:D

题目解析:Spring 实现动态代理有两种方式:cglib 和 JDK 原生动态代理。

4.请补充以下代码?
class MyReflect {    // 私有方法    private void privateMd() {        System.out.println("Private Method");    }}class ReflectTest {    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {        Class myClass = Class.forName("MyReflect");        Object object = myClass.newInstance();        // 补充此行代码        method.setAccessible(true);        method.invoke(object);    }}

答:Method method = myClass.getDeclaredMethod("privateMd");

题目分析:这个题目主要考私有方法的获取,私有方法的获取不是通过的 getMethod() 方式,而是通过 getDeclaredMethod() 获取的。

5.cglib 这句话可以代表任何类型,对吗?为什么?

答:这句话不完全正确,因为 cglib 只有代理才能有子类的普通类,比如最终类(final),cglib 由于动态代理无法实现,因此无法实现 cglib 底层是通过继承代理子类实现动态代理,因此不能使用继承子类 cglib。

6.JDK 原生动态代理和 cglib 有什么区别?

答:JDK 原生动态代理和 cglib 区别如下:

  • JDK 原生动态代理是基于接口实现的,不需要任何依赖,可以平滑支持 JDK 版本升级;
  • cglib 不需要实现接口,可以直接代理普通类,需要添加依赖包,性能更高。
7.为什么 JDK 必须通过接口完成原始动态代理?

答:这是因为 JDK 原生设计的原因取决于动态代理的实现方法 newProxyInstance() 的源码:

/** * ... * @param   loader the class loader to define the proxy class * @param   interfaces the list of interfaces for the proxy class to implement * ... */ @CallerSensitivepublic static Object newProxyInstance(ClassLoader loader,                                      Class<?>[] interfaces,                                      InvocationHandler h)    throws IllegalArgumentException{// 省略其他代码

看前两个参数的声明:

  • loader:为类加载器,即 target.getClass().getClassLoader()
  • interfaces:接口代理接口实现列表

看了上面的参数说明,我们就明白了,要用了 JDK 原始动态只能通过实现接口来完成。

总结

这篇文章可以知道 JDK 原始动态代理是通过反射实现的,但动态代理的实现不仅是反射,还有 ASM(短小精悍的字节码操作框架)、cglib(基于 ASM)等。其中 JDK 原始动态代理是通过接口实现的,而原始动态代理是通过接口实现的 cglib 它是通过子类实现的,所以 cglib 不能代表最终类(final)。反射不仅可以反射调用静态方法,还可以反射调用普通方法和私有方法。调用私有方法时应设置 setAccessible 为 true。

上一篇 Activity之间的参数传递
下一篇 jvm-第二节jvm的内存区域

文章素材均来源于网络,如有侵权,请联系管理员删除。

标签: Java教程Java基础Java编程技巧面试题Java面试题