Java反射

一:概述 
Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。 

Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 

1．检测类： 
1.1 reflection的工作机制 
考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。 

Java代码  收藏代码
  1. import java.lang.reflect.Method;  
  2.   
  3. public class Demo001 {  
  4.     public static void main(String args[]) {  
  5.         try {  
  6.             Class<?> c = Class.forName("javax.swing.JFrame");  
  7.             Method m[] = c.getDeclaredMethods();  
  8.             for (int i = 0; i < m.length; i++){  
  9.                 System.out.println(m[i].toString());  
  10.             }  
  11.         } catch (Throwable e) {  
  12.             System.err.println(e);  
  13.         }  
  14.     }  
  15. }  


按如下语句执行： 
它的结果输出为： 
public void javax.swing.JFrame.remove(java.awt.Component) 
public void javax.swing.JFrame.update(java.awt.Graphics) 
public javax.accessibility.AccessibleContext javax.swing.JFrame.getAccessibleContext() 
protected java.lang.String javax.swing.JFrame.paramString() 
protected void javax.swing.JFrame.addImpl(java.awt.Component,java.lang.Object,int) 
public void javax.swing.JFrame.setLayout(java.awt.LayoutManager) 
protected void javax.swing.JFrame.processWindowEvent(java.awt.event.WindowEvent) 
public void javax.swing.JFrame.setIconImage(java.awt.Image) 
public java.awt.Container javax.swing.JFrame.getContentPane() 
public java.awt.Component javax.swing.JFrame.getGlassPane() 
public javax.swing.JLayeredPane javax.swing.JFrame.getLayeredPane() 
public javax.swing.JRootPane javax.swing.JFrame.getRootPane() 
public void javax.swing.JFrame.setContentPane(java.awt.Container) 
public void javax.swing.JFrame.setGlassPane(java.awt.Component) 
public void javax.swing.JFrame.setLayeredPane(javax.swing.JLayeredPane) 
protected javax.swing.JRootPane javax.swing.JFrame.createRootPane() 
protected void javax.swing.JFrame.frameInit() 
public int javax.swing.JFrame.getDefaultCloseOperation() 
public javax.swing.JMenuBar javax.swing.JFrame.getJMenuBar() 
public static boolean javax.swing.JFrame.isDefaultLookAndFeelDecorated() 
protected boolean javax.swing.JFrame.isRootPaneCheckingEnabled() 
public void javax.swing.JFrame.setDefaultCloseOperation(int) 
public static void javax.swing.JFrame.setDefaultLookAndFeelDecorated(boolean) 
public void javax.swing.JFrame.setJMenuBar(javax.swing.JMenuBar) 
protected void javax.swing.JFrame.setRootPane(javax.swing.JRootPane) 
protected void javax.swing.JFrame.setRootPaneCheckingEnabled(boolean) 
这样就列出了javax.swing.JFrame类的各方法名以及它们的限制符和返回类型。 
这个程序使用 Class.forName 载入指定的类，然后调用 getDeclaredMethods 来获取这个类中定义了的方法列表。java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类。 
1.2 Java类反射中的主要方法 
对于以下三类组件中的任何一类来说 -- 构造函数、字段和方法 -- java.lang.Class 提供四种独立的反射调用，以不同的方式来获得信息。调用都遵循一种标准格式。以下是用于查找构造函数的一组反射调用： 
Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数， 
Constructor[] getConstructors() -- 获得类的所有公共构造函数 
Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关) 
Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 
获得字段信息的Class 反射调用不同于那些用于接入构造函数的调用，在参数类型数组中使用了字段名： 
Field getField(String name) -- 获得命名的公共字段 
Field[] getFields() -- 获得类的所有公共字段 
Field getDeclaredField(String name) -- 获得类声明的命名的字段 
Field[] getDeclaredFields() -- 获得类声明的所有字段 
用于获得方法信息函数： 
Method getMethod(String name, Class[] params) -- 使用特定的参数类型，获得命名的公共方法 
Method[] getMethods() -- 获得类的所有公共方法 
Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型，获得类声明的命名的方法 
Method[] getDeclaredMethods() -- 获得类声明的所有方法 

1.3开始使用 Reflection： 
用于 reflection 的类，如 Method，可以在 java.lang.relfect 包中找到。使用这些类的时候必须要遵循三个步骤：第一步是获得你想操作的类的 java.lang.Class 对象。在运行中的 Java 程序中，用 java.lang.Class 类来描述类和接口等。 
下面就是获得一个 Class 对象的方法之一： 
Class c = Class.forName("java.lang.String"); 
这条语句得到一个 String 类的类对象。还有另一种方法，如下面的语句： 
Class c = int.class; 
或者 
Class c = Integer.TYPE; 
它们可获得基本类型的类信息。其中后一种方法中访问的是基本类型的封装类 (如 Integer) 中预先定义好的 TYPE 字段。 
第二步是调用诸如 getDeclaredMethods 的方法，以取得该类中定义的所有方法的列表。 
一旦取得这个信息，就可以进行第三步了——使用 reflection API 来操作这些信息，如下面这段代码： 
Class c = Class.forName("java.lang.String"); 
Method m[] = c.getDeclaredMethods(); 
System.out.println(m[0].toString()); 
它将以文本方式打印出 String 中定义的第一个方法的原型。 

2．处理对象： 
如果要作一个开发工具像debugger之类的，你必须能发现filed values,以下是三个步骤: 

a.创建一个Class对象 
b.通过getField 创建一个Field对象 
c.调用Field.getXXX(Object)方法(XXX是Int,Float等，如果是对象就省略；Object是指实例). 

例如： 

Java代码  收藏代码
  1. import java.awt.Rectangle;  
  2. import java.lang.reflect.Field;  
  3.   
  4. public class SampleGet {  
  5.   
  6.     public static void main(String[] args) {  
  7.         Rectangle r = new Rectangle(100, 325);  
  8.         printHeight(r);  
  9.   
  10.     }  
  11.   
  12.     static void printHeight(Rectangle r) {  
  13.         Field heightField;  
  14.         Integer heightValue;  
  15.         Class<?> c = r.getClass();  
  16.         try {  
  17.             heightField = c.getField("height");  
  18.             heightValue = (Integer) heightField.get(r);  
  19.             System.out.println("Height: " + heightValue.toString());  
  20.         } catch (NoSuchFieldException e) {  
  21.             System.out.println(e);  
  22.         } catch (SecurityException e) {  
  23.             System.out.println(e);  
  24.         } catch (IllegalAccessException e) {  
  25.             System.out.println(e);  
  26.         }  
  27.     }  
  28. }  



二、安全性和反射 
在处理反射时安全性是一个较复杂的问题。反射经常由框架型代码使用，由于这一点，我们可能希望框架能够全面接入代码，无需考虑常规的接入限制。但是，在其它情况下，不受控制的接入会带来严重的安全性风险，例如当代码在不值得信任的代码共享的环境中运行时。 
由于这些互相矛盾的需求，Java编程语言定义一种多级别方法来处理反射的安全性。基本模式是对反射实施与应用于源代码接入相同的限制： 
从任意位置到类公共组件的接入 
类自身外部无任何到私有组件的接入 
受保护和打包（缺省接入）组件的有限接入 
不过至少有些时候，围绕这些限制还有一种简单的方法。我们可以在我们所写的类中，扩展一个普通的基本类java.lang.reflect.AccessibleObject 类。这个类定义了一种setAccessible方法，使我们能够启动或关闭对这些类中其中一个类的实例的接入检测。唯一的问题在于如果使用了安全性管理器，它将检测正在关闭接入检测的代码是否许可了这样做。如果未许可，安全性管理器抛出一个例外。 

三、Java反射有两个缺点 
第一：性能问题。用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。 

第二：许多应用中更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射——仅在它可以真正增加灵活性的地方——记录其在目标类中的使用。 

完整实例代码： 

Java代码  收藏代码
    1. import java.lang.reflect.Field;  
    2. import java.lang.reflect.Method;  
    3.   
    4. public class ReflectSecurity {  
    5.     public static void main(String args[]) {  
    6.         try {  
    7.             Class<?> c = Class.forName("javax.swing.JFrame");  
    8.   
    9.             Method m[] = c.getDeclaredMethods();  
    10.             for (int i = 0; i < m.length; i++) {  
    11.                 System.out.println(m[i].toString());  
    12.             }  
    13.   
    14.             Field[] fileds = c.getFields();  
    15.             for (int i = 0; i < fileds.length; i++) {  
    16.                 System.out.println(fileds[i].toString());  
    17.             }  
    18.   
    19.         } catch (Throwable e) {  
    20.             System.err.println(e);  
    21.         }  
    22.     }  
    23. }  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/gavin110-lgy/p/5742769.html