`

Java反射经典实例

JavaJ#SpringHibernate框架 
阅读更多

Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制.

1. 得到某个对象的属性
  1. public Object getProperty(Object owner, String fieldName) throws Exception {      
  2.     Class ownerClass = owner.getClass();                                          
  3.                                                                                   
  4.     Field field = ownerClass.getField(fieldName);                                 
  5.                                                                                   
  6.     Object property = field.get(owner);                                           
  7.                                                                                   
  8.     return property;                                                              
  9. }                                                                                 

Class ownerClass = owner.getClass()：得到该对象的Class。
Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。
Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。
 
2. 得到某个类的静态属性

  1. public Object getStaticProperty(String className, String fieldName)    
  2.             throws Exception {                                         
  3.     Class ownerClass = Class.forName(className);                       
  4.                                                                        
  5.     Field field = ownerClass.getField(fieldName);                      
  6.                                                                        
  7.     Object property = field.get(ownerClass);                           
  8.                                                                        
  9.     return property;                                                   
  10. }                                                                      

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。
Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。


3. 执行某对象的方法
  1. public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {   
  2.     Class ownerClass = owner.getClass();   
  3.     Class[] argsClass = new Class[args.length];   
  4.     for (int i = 0, j = args.length; i < j; i++) {   
  5.         argsClass[i] = args[i].getClass();   
  6.     }    
  7.     Method method = ownerClass.getMethod(methodName, argsClass);      
  8.     return method.invoke(owner, args);    
  9. }  
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。
3～6行：配置参数的Class数组，作为寻找Method的条件。
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。
method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法
  1. public Object invokeStaticMethod(String className, String methodName,            
  2.             Object[] args) throws Exception {                                    
  3.     Class ownerClass = Class.forName(className);                                 
  4.                                                                                  
  5.     Class[] argsClass = new Class[args.length];                                  
  6.                                                                                  
  7.     for (int i = 0, j = args.length; i < j; i++) {                               
  8.         argsClass[i] = args[i].getClass();                                       
  9.     }                                                                            
  10.                                                                                  
  11.     Method method = ownerClass.getMethod(methodName, argsClass);                 
  12.                                                                                  
  13.     return method.invoke(null, args);                                            
  14. }                                                                                
基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。
 
5. 新建实例
  1. public Object newInstance(String className, Object[] args) throws Exception {    
  2.     Class newoneClass = Class.forName(className);                                
  3.                                                                                  
  4.     Class[] argsClass = new Class[args.length];                                  
  5.                                                                                  
  6.     for (int i = 0, j = args.length; i < j; i++) {                               
  7.         argsClass[i] = args[i].getClass();                                       
  8.     }                                                                            
  9.                                                                                  
  10.     Constructor cons = newoneClass.getConstructor(argsClass);                    
  11.                                                                                  
  12.     return cons.newInstance(args);                                               
  13.                                                                                  
  14. }                                                                                
这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。
Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。
第6～第10行：得到参数的Class数组。
Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。
cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例
  1. public boolean isInstance(Object obj, Class cls) {        
  2.     return cls.isInstance(obj);                           
  3. }                                                         

7. 得到数组中的某个元素
  1. public Object getByArray(Object array, int index) {       
  2.     return Array.get(array,index);                        
  3. }                                                         

附完整源码：
  1. import java.lang.reflect.Array;   
  2. import java.lang.reflect.Constructor;   
  3. import java.lang.reflect.Field;   
  4. import java.lang.reflect.Method;   
  5.   
  6.   
  7. /**  
  8.  * Java Reflection Cookbook  
  9.  *  
  10.  * @author Michael Lee  
  11.  * @since 2006-8-23  
  12.  * @version 0.1a  
  13.  */  
  14.   
  15. public class Reflection {   
  16.     /**  
  17.      * 得到某个对象的公共属性  
  18.      *  
  19.      * @param owner, fieldName  
  20.      * @return 该属性对象  
  21.      * @throws Exception  
  22.      *  
  23.      */  
  24.     public Object getProperty(Object owner, String fieldName) throws Exception {   
  25.         Class ownerClass = owner.getClass();   
  26.   
  27.         Field field = ownerClass.getField(fieldName);   
  28.   
  29.         Object property = field.get(owner);   
  30.   
  31.         return property;   
  32.     }   
  33.   
  34.     /**  
  35.      * 得到某类的静态公共属性  
  36.      *  
  37.      * @param className   类名  
  38.      * @param fieldName   属性名  
  39.      * @return 该属性对象  
  40.      * @throws Exception  
  41.      */  
  42.     public Object getStaticProperty(String className, String fieldName)   
  43.             throws Exception {   
  44.         Class ownerClass = Class.forName(className);   
  45.   
  46.         Field field = ownerClass.getField(fieldName);   
  47.   
  48.         Object property = field.get(ownerClass);   
  49.   
  50.         return property;   
  51.     }   
  52.   
  53.   
  54.     /**  
  55.      * 执行某对象方法  
  56.      *  
  57.      * @param owner  
  58.      *            对象  
  59.      * @param methodName  
  60.      *            方法名  
  61.      * @param args  
  62.      *            参数  
  63.      * @return 方法返回值  
  64.      * @throws Exception  
  65.      */  
  66.     public Object invokeMethod(Object owner, String methodName, Object[] args)   
  67.             throws Exception {   
  68.   
  69.         Class ownerClass = owner.getClass();   
  70.   
  71.         Class[] argsClass = new Class[args.length];   
  72.   
  73.         for (int i = 0, j = args.length; i < j; i++) {   
  74.             argsClass[i] = args[i].getClass();   
  75.         }   
  76.   
  77.         Method method = ownerClass.getMethod(methodName, argsClass);   
  78.   
  79.         return method.invoke(owner, args);   
  80.     }   
  81.   
  82.   
  83.       /**  
  84.      * 执行某类的静态方法  
  85.      *  
  86.      * @param className  
  87.      *            类名  
  88.      * @param methodName  
  89.      *            方法名  
  90.      * @param args  
  91.      *            参数数组  
  92.      * @return 执行方法返回的结果  
  93.      * @throws Exception  
  94.      */  
  95.     public Object invokeStaticMethod(String className, String methodName,   
  96.             Object[] args) throws Exception {   
  97.         Class ownerClass = Class.forName(className);   
  98.   
  99.         Class[] argsClass = new Class[args.length];   
  100.   
  101.         for (int i = 0, j = args.length; i < j; i++) {   
  102.             argsClass[i] = args[i].getClass();   
  103.         }   
  104.   
  105.         Method method = ownerClass.getMethod(methodName, argsClass);   
  106.   
  107.         return method.invoke(null, args);   
  108.     }   
  109.   
  110.   
  111.   
  112.     /**  
  113.      * 新建实例  
  114.      *  
  115.      * @param className  
  116.      *            类名  
  117.      * @param args  
  118.      *            构造函数的参数  
  119.      * @return 新建的实例  
  120.      * @throws Exception  
  121.      */  
  122.     public Object newInstance(String className, Object[] args) throws Exception {   
  123.         Class newoneClass = Class.forName(className);   
  124.   
  125.         Class[] argsClass = new Class[args.length];   
  126.   
  127.         for (int i = 0, j = args.length; i < j; i++) {   
  128.             argsClass[i] = args[i].getClass();   
  129.         }   
  130.   
  131.         Constructor cons = newoneClass.getConstructor(argsClass);   
  132.   
  133.         return cons.newInstance(args);   
  134.   
  135.     }   
  136.   
  137.   
  138.        
  139.     /**  
  140.      * 是不是某个类的实例  
  141.      * @param obj 实例  
  142.      * @param cls 类  
  143.      * @return 如果 obj 是此类的实例，则返回 true  
  144.      */  
  145.     public boolean isInstance(Object obj, Class cls) {   
  146.         return cls.isInstance(obj);   
  147.     }   
  148.        
  149.     /**  
  150.      * 得到数组中的某个元素  
  151.      * @param array 数组  
  152.      * @param index 索引  
  153.      * @return 返回指定数组对象中索引组件的值  
  154.      */  
  155.     public Object getByArray(Object array, int index) {   
  156.         return Array.get(array,index);   
  157.     }   
  158. }  

分享到：
| JSTL-EL表达式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java反射经典实例

    在本“Java反射经典实例”中，我们将深入探讨这个主题，了解如何利用反射来访问和修改私有属性以及调用私有方法。 1. **反射的概念与用途** - 反射机制是在运行时分析类的能力，它允许我们获取类的信息（如类名、...

    Java反射经典实例 Java Reflection Cookbook[1].pdf

    ### Java反射经典实例详解 #### 一、引言 反射是Java编程语言中的一个重要特性，它允许程序在运行时检查自身结构（如类、字段、方法等），并且可以在运行时调用任意一个类的成员（包括私有成员）。这一特性为Java...

    Java反射简单例子

    下面我们将详细探讨Java反射的基本概念、使用场景以及如何通过`ReflectTest.java`这个简单的例子来理解反射。 ### 1. 反射的基本概念 反射机制允许我们在运行时检查类的信息，包括类名、方法名、参数类型等，并且...

    Java反射应用实例

    代码主要实现了Java反射应用实例, 包含利用反射方法创建对象(使用默认构造函数和自定义构造函数),访问对应对象的方法(包括带参数的和不带参数的),访问对应对象的域(Field). 从这里可以看到代码的详细解说:...

    java反射实例代码

    在提供的"java反射实例代码"中，应该包含了如何使用上述方法的实际示例，这些示例有助于加深对Java反射机制的理解。通过阅读和运行这些代码，开发者可以更直观地学习如何在程序运行时动态地操作类、方法和字段，从而...

    JAVA反射简单例子

    Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Spring框架中，反射扮演着核心角色，...希望这个简单的反射例子能帮助你更好地理解和运用Java反射。

    反射实例-JAVA反射机制

    ### 反射实例—JAVA反射机制 #### 一、反射概念及原理 反射在计算机科学领域，特别是程序设计中，是指程序有能力访问、检测和修改其自身的结构和行为。这一概念最早由Smith于1982年提出，并迅速应用于各种编程语言...

    Java反射简单小实例

    ### Java反射机制简介 Java反射机制是Java编程语言的一个强大特性，它允许程序在运行时检查自身，并且能够“看”到类的信息（字段、方法等），甚至可以在运行时调用这些方法或修改这些字段的值。这为开发带来了很大...

    java例子 java反射

    Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。...通过分析这些例子，你可以更深入地理解Java反射的使用方式及其在实际开发中的应用。

    java 反射机制例子

    ### Java反射机制详解 #### 一、反射的基本概念与历史背景 反射的概念最早由Smith在1982年提出，其核心思想是程序有能力访问、检测甚至修改自身的状态和行为。这种能力一经提出，迅速成为了计算机科学领域的研究...

    java反射调用实例代码

    这个资源“java反射调用实例代码”提供了关于如何使用Java反射API进行各种操作的实际示例。 在Java中，`java.lang.reflect`包提供了对反射的支持，包括`Class`类，`Constructor`类，`Method`类和`Field`类。这些类...

    java反射 java反射 java反射java反射

    Java反射是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中，反射机制提供了强大的能力，包括在运行时检查类的结构、创建对象实例、调用方法以及访问和修改字段值。...

    Java 8个反射实例

    以下将详细介绍Java反射的8个关键实例。 1. 获取Class对象 要使用反射，首先需要获取到目标类的Class对象。这可以通过以下几种方式实现： - 使用`Class.forName()`方法，如`Class&lt;?&gt; clazz = Class.forName("全...

    Java 反射机制 代码的实例

    Java反射机制是Java编程语言中的一个强大特性，它允许程序在运行时检查和操作类、接口、对象等的内部结构。通过反射，开发者可以动态地获取类的信息并调用其方法，创建对象，访问私有成员，甚至改变类的行为。在深入...

    JAVA反射机制的入门代码

    Java反射机制是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。这个特性使得Java具有了高度的灵活性和动态性，尤其是在处理元数据、创建对象、调用私有方法...

    java反射简单例子demo

    Java反射是Java编程语言中的一个强大特性，它允许运行时检查类、接口、字段和方法的信息，甚至可以动态地创建对象并调用其方法。在Java中，`java.lang.reflect`包提供了对反射的支持，包括`Class`、`Constructor`、`...

    java 反射实例，大量注释，简单易懂

    Java反射是Java编程语言中的一个重要特性，它允许程序在运行时检查类、接口、字段和方法的信息，并且能够在运行时创建和访问这些类的对象。在Java中，反射提供了对类对象的元数据（metadata）的访问，使得我们可以...

    JAVA反射机制及应用例子

    JAVA反射机制及应用例子.。。Reflection API

    java反射例子，封装了一个反射帮助类

    在标题和描述中提到的“java反射例子，封装了一个反射帮助类”，这表明我们有一个实用工具类，可以帮助简化使用反射的复杂过程。 首先，让我们理解Java反射的基本概念。当我们的程序运行时，我们可以通过Class类来...

Magicbox
Global site tag (gtag.js) - Google Analytics