Java笔试面试-反射和动态代理

比眉伴天荒 2021-09-23 08:00 304阅读 0赞

## 反射 ##

反射机制是 Java 语言提供的一种基础功能，赋予程序在运行时自省（introspect）的能力。简单来说就是通过反射，可以在运行期间获取、检测和调用对象的属性和方法。

**反射的使用场景**

1.编程工具 IDEA 或 Eclipse 等，在写代码时会有代码（属性或方法名）提示，就是因为使用了反射；  
2.很多知名的框架，为了让程序更优雅更简洁，也会使用到反射。

例如，Spring 可以通过配置来加载不同的类，调用不同的方法，代码如下所示：

例如，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;
        }
    }

3.数据库连接池，也会使用反射调用不同类型的数据库驱动，代码如下所示：

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
     * ......
     */ 
    @CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
    // 省略其他代码

可以看到，前两个参数的声明：

*  loader：为类加载器，也就是 target.getClass().getClassLoader()
 *  interfaces：接口代理类的接口实现列表

因此，要使用 JDK 原生的动态只能通过实现接口来完成。