首页 > 代码库 > java-反射深度剖析

java-反射深度剖析

2024-10-25 15:55:02   204人阅读

Java反射是Java语言一个很重要的特征，简单剖析下反射的定义、原理、使用、性能及应用场景。

（一）定义

程序运行时，允许改动程序结构或变量类型，这种语言称为动态语言。java不属于动态语言，但提供了RTTI（Run-time Type Identification）运行时类别识别。RTTI分为两种方式，一种是编译运行时已知悉类型，一种是反射机制。

 

（二）原理

在《深入java虚拟机》中提到，java文件被编译成class文件，JVM类加载器加载class字节码到方法区，然后在堆中生成Class类，Class类可以访问到类的基本信息，如类简单名、类包含路径全名、访问修饰符、字段、方法等信息。

反射中需要使用到的类：

Field类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和Field类不同，Field类封装了反射类的属性，而Constructor类则封装了反射类的构造方法。
Method类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 
Class类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。

 

（三）使用

（1）获取Class

方法一:Class c=Class.forName("java.lang.String") 
方法二:对于基本数据类型可以用形如Class c=int.class或Class c=Integer.TYPE的语句 

（tips：int.class = Integer.TYPE !=Integer.class）

方法三:Class c=MyClass.class

（2）调用Class中的方法得到你想得到的信息集合，如调用getDeclaredFields()方法得到类所有的属性

 

[java] view plain copy
 
  1. Field field = classInstance.getDeclaredField("TEST_TIMES");  
  2.             int times = (Integer) field.get(classInstance);  
  3.             System.out.println(times);  

 

 

（四）性能

反射的性能是低于直接调用的，下次通过测试验证这个结果，测试中尽量避免对象创建等干扰因素。

我们将测试直接访问的耗时、直接反射的耗时、缓存需要查找的函数反射的耗时、使用ReflectAsm的反射耗时。

 

[java] view plain copy
 
  1. /** 
  2.  * 测试反射性能 
  3.  * 
  4.  * @author peter_wang 
  5.  * @create-time 2014-6-13 下午12:54:52 
  6.  */  
  7. public class ReflectPerformanceDemo {  
  8.     private static final int TEST_TIMES = 1000000;  
  9.   
  10.     private long mNum;  
  11.     private long mSum;  
  12.   
  13.     /** 
  14.      * @param args 
  15.      */  
  16.     public static void main(String[] args) {  
  17.         normalInvoke();  
  18.         normalReflectInvoke();  
  19.         cacheReflectInvoke();  
  20.         asmReflectInvoke();  
  21.     }  
  22.   
  23.     /** 
  24.      * 正常调用方法 
  25.      */  
  26.     private static void normalInvoke() {  
  27.         ReflectPerformanceDemo demo = new ReflectPerformanceDemo();  
  28.         long time1 = System.currentTimeMillis();  
  29.         for (long i = 0; i < TEST_TIMES; i++) {  
  30.             demo.setmNum(i);  
  31.             demo.mSum += demo.getmNum();  
  32.         }  
  33.         long time2 = System.currentTimeMillis();  
  34.         System.out.println("normal invoke time:" + (time2 - time1));  
  35.     }  
  36.   
  37.     /** 
  38.      * 常规反射调用方法 
  39.      */  
  40.     private static void normalReflectInvoke() {  
  41.         ReflectPerformanceDemo demo = new ReflectPerformanceDemo();  
  42.         long time1 = System.currentTimeMillis();  
  43.         try {  
  44.             for (long i = 0; i < TEST_TIMES; i++) {  
  45.                 Class<?> c = Class.forName("com.peter.demo.process.reflect.ReflectPerformanceDemo");  
  46.                 Method method = c.getMethod("setmNum", Long.TYPE);  
  47.                 method.invoke(demo, i);  
  48.                 demo.mSum += demo.getmNum();  
  49.             }  
  50.         }  
  51.         catch (Exception e) {  
  52.             e.printStackTrace();  
  53.         }  
  54.         long time2 = System.currentTimeMillis();  
  55.         System.out.println("normal reflect invoke time:" + (time2 - time1));  
  56.     }  
  57.   
  58.     /** 
  59.      * 缓存反射调用方法 
  60.      */  
  61.     private static void cacheReflectInvoke() {  
  62.         ReflectPerformanceDemo demo = new ReflectPerformanceDemo();  
  63.         try {  
  64.             Class<?> c = Class.forName("com.peter.demo.process.reflect.ReflectPerformanceDemo");  
  65.             Method method = c.getMethod("setmNum", Long.TYPE);  
  66.             long time1 = System.currentTimeMillis();  
  67.             for (long i = 0; i < TEST_TIMES; i++) {  
  68.                 method.invoke(demo, i);  
  69.                 demo.mSum += demo.getmNum();  
  70.             }  
  71.             long time2 = System.currentTimeMillis();  
  72.             System.out.println("cache invoke time:" + (time2 - time1));  
  73.         }  
  74.         catch (Exception e) {  
  75.             e.printStackTrace();  
  76.         }  
  77.     }  
  78.   
  79.     /** 
  80.      * asm反射调用方法 
  81.      */  
  82.     private static void asmReflectInvoke() {  
  83.         ReflectPerformanceDemo demo = new ReflectPerformanceDemo();  
  84.         try {  
  85.             MethodAccess ma = MethodAccess.get(ReflectPerformanceDemo.class);  
  86.             int index = ma.getIndex("setmNum");  
  87.             long time1 = System.currentTimeMillis();  
  88.             for (long i = 0; i < TEST_TIMES; i++) {  
  89.                 ma.invoke(demo, index, i);  
  90.                 demo.mSum += demo.getmNum();  
  91.             }  
  92.             long time2 = System.currentTimeMillis();  
  93.             System.out.println("asm invoke time:" + (time2 - time1));  
  94.         }  
  95.         catch (Exception e) {  
  96.             e.printStackTrace();  
  97.         }  
  98.     }  
  99.   
  100.     public long getmNum() {  
  101.         return mNum;  
  102.     }  
  103.   
  104.     public void setmNum(long mNum) {  
  105.         this.mNum = mNum;  
  106.     }  
  107.   
  108. }  


测试结果：

 

 

[java] view plain copy
 
  1. normal invoke time:7  
  2. normal reflect invoke time:1499  
  3. cache invoke time:32  
  4. asm invoke time:20  

 

带缓存的反射调用方法速度明显慢于直接调用，采用asm第三方反射库，速度有少量提升。

反射慢的原因:Because reflection involves types that are dynamically resolved, certain Java virtual machine optimizations can not be performed. Consequently, reflective operations have slower performance than their non-reflective counterparts, and should be avoided in sections of code which are called frequently in performance-sensitive applications. 


（五）应用场景

（1）“基于构件的编程”，在这种编程方式中，将使用某种基于快速应用开发(RAD)的应用构建工具来构建项目。这是现在最常见的可视化编程方法，通过代表不同组件的图标拖动到图板上来创建程序，然后设置构件的属性值来配置它们。这种配置要求构件都是可实例化的，并且要暴露其部分信息，使得程序员可以读取和设置构件的值。

（2）能够提供在跨网络的远程平台上创建和运行对象的能力，实现java语言的网络可移动性。这被成为远程调用(RMI)，它允许一个Java程序将对象分步在多台机器上，这种分步能力将帮助开发人员执行一些需要进行大量计算的任务，充分利用计算机资源，提高运行速度。

 

（六）范例

破解最可靠的单例模式，在这个例子中，最可靠的又可以lazy loading的是第五种单例模式创建，但是可以通过反射机制破除安全性。

 

[java] view plain copy
 
  1. /** 
  2.  * 安全的单例模式 
  3.  *  
  4.  * @author peter_wang 
  5.  * @create-time 2014-6-10 下午4:45:20 
  6.  */  
  7. public class SingletonSafe {  
  8.     private SingletonSafe() {  
  9.         System.out.println("create singleton");  
  10.     }  
  11.   
  12.     private static class StaticSingleton {  
  13.         private static SingletonSafe instance = new SingletonSafe();  
  14.     }  
  15.   
  16.     public static SingletonSafe getInstance() {  
  17.         return StaticSingleton.instance;  
  18.     }  
  19. }  
[java] view plain copy
 
  1. /** 
  2.  * 测试反射 
  3.  *  
  4.  * @author peter_wang 
  5.  * @create-time 2014-6-10 下午5:08:58 
  6.  */  
  7. public class ReflectDemo {  
  8.   
  9.     /** 
  10.      * @param args 
  11.      */  
  12.     public static void main(String[] args) {  
  13.         try {  
  14.             Class classInstance = Class.forName("com.peter.demo.process.reflect.SingletonSafe");  
  15.             System.out.println(classInstance.getName());  
  16.   
  17.             Constructor cons = classInstance.getDeclaredConstructor(null);  
  18.             cons.setAccessible(true);  
  19.             SingletonSafe singletonSafe1 = (SingletonSafe) cons.newInstance(null);  
  20.             System.out.println("singleton1:" + singletonSafe1.toString());  
  21.             SingletonSafe singletonSafe2 = (SingletonSafe) cons.newInstance(null);  
  22.             System.out.println("singleton2:" + singletonSafe2.toString());  
  23.   
  24.             Method method1 = classInstance.getDeclaredMethod("getInstance", null);  
  25.             SingletonSafe singletonSafe3 = (SingletonSafe) method1.invoke(classInstance, null);  
  26.             System.out.println("singleton3:" + singletonSafe3.toString());  
  27.             Method method2 = classInstance.getDeclaredMethod("getInstance", null);  
  28.             SingletonSafe singletonSafe4 = (SingletonSafe) method2.invoke(classInstance, null);  
  29.             System.out.println("singleton4:" + singletonSafe4.toString());  
  30.         }  
  31.         catch (Exception e) {  
  32.             e.printStackTrace();  
  33.         }  
  34.     }  
  35.   
  36. }  


测试结果：

 

 

[java] view plain copy
 
  1. com.peter.demo.process.reflect.SingletonSafe  
  2. create singleton  
  3. singleton1:com.peter.demo.process.reflect.SingletonSafe@2a9931f5  
  4. create singleton  
  5. singleton2:com.peter.demo.process.reflect.SingletonSafe@2f9ee1ac  
  6. create singleton  
  7. singleton3:com.peter.demo.process.reflect.SingletonSafe@5f186fab  
  8. singleton4:com.peter.demo.process.reflect.SingletonSafe@5f186fab  

 

由测试结果可知，
单例模式可以用反射创建多个对象。

 

（七）总结

目前的计算机系统的速度，应用开发已不在过于在意性能，而更为注重系统的可维护性和扩展性以及快速开发效率上。上述的测试结果是在大量操作基础上产生的。而在通常的一次业务请求中，反射使用的次数应该是非常少的，只在框架级基础上被使用，在一个高负载的系统中，业务处理的性能将是关键点，而不在于使用的这些反射所带来的性能影响上。而使用反射所带来的开发便利与可维护性可扩展性的提升所带来的价值，是远远高于其所损耗的性能的。

java-反射深度剖析


联系
我们