Java 反射以及动态代理,来看就懂了

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

反射

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

[[323939]]

反射的使用场景

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

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

使用场景二:很多知名的框架,为了让程序更优雅更简洁,也会使用到反射。

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

  1. <bean id="person" class="com.spring.beans.Person" init-method="initPerson"
  2. </bean> 
[[323940]]

例如,MyBatis 在 Mapper 使用外部类的 Sql 构建查询时,代码如下所示:

  1. @SelectProvider(type = PersonSql.class, method = "getListSql"
  2. List<Person> getList(); 
  3. class PersonSql { 
  4.     public String getListSql() { 
  5.         String sql = new SQL() {{ 
  6.             SELECT("*"); 
  7.             FROM("person"); 
  8.         }}.toString(); 
  9.         return sql; 
  10.     } 
[[323940]]

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

  1. String url = "jdbc:mysql://127.0.0.1:3306/mydb"
  2. String username = "root"
  3. String password = "root"
  4. Class.forName("com.mysql.jdbc.Driver"); 
  5. Connection connection = DriverManager.getConnection(url, username, password); 
[[323940]]

当然反射还有其他很多类似的使用场景,这里就不一一列举,读者可以举一反三,想想在平常的开发中,还有哪些使用了反射功能的场景。

反射的基本使用

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

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

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

假设有一个实体类 MyReflect 包含了以上三种方法,代码如下:

  1. package com.interview.chapter4; 
  2. class MyReflect { 
  3.     // 静态方法 
  4.     public static void staticMd() { 
  5.         System.out.println("Static Method"); 
  6.     } 
  7.     // 公共方法 
  8.     public void publicMd() { 
  9.         System.out.println("Public Method"); 
  10.     } 
  11.     // 私有方法 
  12.     private void privateMd() { 
  13.         System.out.println("Private Method"); 
  14.     } 
[[323940]]

下面分别来看,使用反射如何调用以上三种类型的方法。

① 反射调用静态方法

  1. Class myClass = Class.forName("com.interview.chapter4.MyReflect"); 
  2. Method method = myClass.getMethod("staticMd"); 
  3. method.invoke(myClass); 
[[323940]]

② 反射调用公共方法

  1. Class myClass = Class.forName("com.interview.chapter4.MyReflect"); 
  2. // 创建实例对象(相当于 new ) 
  3. Object instance = myClass.newInstance(); 
  4. Method method2 = myClass.getMethod("publicMd"); 
  5. method2.invoke(instance); 
[[323940]]

③ 反射调用私有方法

  1. Class myClass = Class.forName("com.interview.chapter4.MyReflect"); 
  2. // 创建实例对象(相当于 new ) 
  3. Object object = myClass.newInstance(); 
  4. Method method3 = myClass.getDeclaredMethod("privateMd"); 
  5. method3.setAccessible(true); 
  6. method3.invoke(object); 
[[323940]]

反射使用总结

反射获取调用类可以通过 Class.forName(),反射获取类实例要通过 newInstance(),相当于 new 一个新对象,反射获取方法要通过 getMethod(),获取到类方法之后使用 invoke() 对类方法进行调用。如果是类方法为私有方法的话,则需要通过 setAccessible(true) 来修改方法的访问限制,以上的这些操作就是反射的基本使用。

动态代理

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

动态代理的使用场景

动态代理被广为人知的使用场景是 Spring 中的面向切面编程(AOP)。例如,依赖注入 @Autowired 和事务注解 @Transactional 等,都是利用动态代理实现的。

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

动态代理和反射的关系

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

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

1)JDK 原生动态代理

  1. interface Animal { 
  2.     void eat(); 
  3. class Dog implements Animal { 
  4.     @Override 
  5.     public void eat() { 
  6.         System.out.println("The dog is eating"); 
  7.     } 
  8. class Cat implements Animal { 
  9.     @Override 
  10.     public void eat() { 
  11.         System.out.println("The cat is eating"); 
  12.     } 
  13.   
  14. Java 反射以及动态代理,来看就懂了 
  15. // JDK 代理类 
  16. class AnimalProxy implements InvocationHandler { 
  17.     private Object target; // 代理对象 
  18.     public Object getInstance(Object target) { 
  19.         this.target = target; 
  20.         // 取得代理对象 
  21.         return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); 
  22.     } 
  23.     @Override 
  24.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  25.         System.out.println("调用前"); 
  26.         Object result = method.invoke(target, args); // 方法调用 
  27.         System.out.println("调用后"); 
  28.         return result; 
  29.     } 
  30. Java 反射以及动态代理,来看就懂了 
  31.   
  32. public static void main(String[] args) { 
  33.     // JDK 动态代理调用 
  34.     AnimalProxy proxy = new AnimalProxy(); 
  35.     Animal dogProxy = (Animal) proxy.getInstance(new Dog()); 
  36.     dogProxy.eat(); 
[[323940]]

以上代码,我们实现了通过动态代理,在所有请求前、后都打印了一个简单的信息。

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

2)cglib 动态代理

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

  1. <dependency> 
  2.     <groupId>cglib</groupId> 
  3.     <artifactId>cglib</artifactId> 
  4.     <version>3.2.12</version> 
  5. </dependency> 
[[323940]]

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

  1. class Panda { 
  2.     public void eat() { 
  3.         System.out.println("The panda is eating"); 
  4.     } 
  5. class CglibProxy implements MethodInterceptor { 
  6.     private Object target; // 代理对象 
  7.     public Object getInstance(Object target) { 
  8.         this.target = target; 
  9.         Enhancer enhancer = new Enhancer(); 
  10.         // 设置父类为实例类 
  11.         enhancer.setSuperclass(this.target.getClass()); 
  12.         // 回调方法 
  13.         enhancer.setCallback(this); 
  14.         // 创建代理对象 
  15.         return enhancer.create(); 
  16.     } 
  17.     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { 
  18.         System.out.println("调用前"); 
  19.         Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用 
  20.         System.out.println("调用后"); 
  21.         return result; 
  22.     } 
  23. public static void main(String[] args) { 
  24.     // cglib 动态代理调用 
  25.     CglibProxy proxy = new CglibProxy(); 
  26.     Panda panda = (Panda)proxy.getInstance(new Panda()); 
  27.     panda.eat(); 
[[323940]]

以上程序执行的结果:

  1. 调用前 
  2.  
  3. The panda is eating 
  4.  
  5. 调用后 

由以上代码可以知道,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.请补全以下代码?

  1. class MyReflect { 
  2.     // 私有方法 
  3.     private void privateMd() { 
  4.         System.out.println("Private Method"); 
  5.     } 
  6. class ReflectTest { 
  7.     public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException { 
  8.         Class myClass = Class.forName("MyReflect"); 
  9.         Object object = myClass.newInstance(); 
  10.         // 补充此行代码 
  11.         method.setAccessible(true); 
  12.         method.invoke(object); 
  13.     } 
[[323940]]

答: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() 的源码:

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

来看前两个参数的声明:

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

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

总结

通过本文可以知道 JDK 原生动态代理是使用反射实现的,但动态代理的实现方式不止有反射,还可以是 ASM(一个短小精悍的字节码操作框架)、cglib(基于 ASM)等。其中 JDK 原生的动态代理是通过接口实现的,而 cglib 是通过子类实现的,因此 cglib 不能代理最终类(final)。而反射不但可以反射调用静态方法,还可以反射调用普通方法和私有方法,其中调用私有方法时要设置 setAccessible 为 true。

 

责任编辑:武晓燕 来源: 今日头条
相关推荐

2012-02-08 10:12:19

Java反射

2017-05-11 21:30:01

Android动态代理ServiceHook

2012-02-08 10:37:42

Java反射

2011-04-06 11:41:25

Java动态代理

2012-08-28 10:59:26

JavaJava动态代理Proxy

2017-10-12 14:56:11

2011-03-23 10:40:51

java代理模式

2015-09-22 11:09:47

Java 8动态代理

2023-12-06 08:23:44

代理模式设计模式

2021-07-06 06:39:22

Java静态代理动态代理

2023-02-24 07:42:30

Java动态代理

2015-09-28 15:59:00

Java动态代理机制

2011-11-17 14:32:45

Java静态代理动态代理

2012-02-08 09:53:25

Java反射

2015-09-24 08:54:36

java动态代理

2015-09-24 08:55:14

Java动态代理扩展

2018-03-05 11:29:17

云计算云服务服务器

2010-04-01 09:22:38

代理模式Java反射机制

2023-07-31 07:43:07

Java语言表达式变量

2022-04-07 10:39:21

反射Java安全
点赞
收藏

51CTO技术栈公众号