`
c125543072
  • 浏览: 30126 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
社区版块
存档分类
最新评论

Java反射经典实例 Java Reflection Cookbook (初级)

JavaJ#SpringHibernate框架 
阅读更多
Java代码 复制代码
  1. Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制。   
  2.   
  3. 1. 得到某个对象的属性   
  4.   
  5. 1 public Object getProperty(Object owner, String fieldName) throws Exception {   
  6. 2     Class ownerClass = owner.getClass();   
  7. 3    
  8. 4     Field field = ownerClass.getField(fieldName);   
  9. 5    
  10. 6     Object property = field.get(owner);   
  11. 7    
  12. 8     return property;   
  13. 9 }   
  14. Class ownerClass = owner.getClass()：得到该对象的Class。   
  15.   
  16. Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。   
  17.   
  18. Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。   
  19.   
  20.   
  21.   
  22. 2. 得到某个类的静态属性   
  23.   
  24.  1 public Object getStaticProperty(String className, String fieldName)   
  25.  2             throws Exception {   
  26.  3     Class ownerClass = Class.forName(className);   
  27.  4    
  28.  5     Field field = ownerClass.getField(fieldName);   
  29.  6    
  30.  7     Object property = field.get(ownerClass);   
  31.  8    
  32.  9     return property;   
  33. 10 }   
  34.   
  35. Class ownerClass = Class.forName(className) ：首先得到这个类的Class。   
  36.   
  37. Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。   
  38.   
  39. Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。   
  40.   
  41.   
  42. 3. 执行某对象的方法   
  43.   
  44.  1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {   
  45.  2    
  46.  3     Class ownerClass = owner.getClass();   
  47.  4    
  48.  5     Class[] argsClass = new Class[args.length];   
  49.  6    
  50.  7     for (int i = 0, j = args.length; i < j; i++) {   
  51.  8         argsClass[i] = args[i].getClass();   
  52.  9     }   
  53. 10    
  54. 11     Method method = ownerClass.getMethod(methodName, argsClass);   
  55. 12    
  56. 13     return method.invoke(owner, args);   
  57. 14 }   
  58. Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。   
  59.   
  60. 5～9行：配置参数的Class数组，作为寻找Method的条件。   
  61.   
  62. Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。   
  63.   
  64. method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。   
  65.   
  66.   
  67. 4. 执行某个类的静态方法   
  68.   
  69.  1 public Object invokeStaticMethod(String className, String methodName,   
  70.  2             Object[] args) throws Exception {   
  71.  3     Class ownerClass = Class.forName(className);   
  72.  4    
  73.  5     Class[] argsClass = new Class[args.length];   
  74.  6    
  75.  7     for (int i = 0, j = args.length; i < j; i++) {   
  76.  8         argsClass[i] = args[i].getClass();   
  77.  9     }   
  78. 10    
  79. 11     Method method = ownerClass.getMethod(methodName, argsClass);   
  80. 12    
  81. 13     return method.invoke(null, args);   
  82. 14 }   
  83.   
  84. 基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。   
  85.   
  86.   
  87.   
  88. 5. 新建实例   
  89.  1    
  90.  2 public Object newInstance(String className, Object[] args) throws Exception {   
  91.  3     Class newoneClass = Class.forName(className);   
  92.  4    
  93.  5     Class[] argsClass = new Class[args.length];   
  94.  6    
  95.  7     for (int i = 0, j = args.length; i < j; i++) {   
  96.  8         argsClass[i] = args[i].getClass();   
  97.  9     }   
  98. 10    
  99. 11     Constructor cons = newoneClass.getConstructor(argsClass);   
  100. 12    
  101. 13     return cons.newInstance(args);   
  102. 14    
  103. 15 }   
  104.   
  105. 这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。   
  106.   
  107. Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。   
  108.   
  109. 第5～第9行：得到参数的Class数组。   
  110.   
  111. Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。   
  112.   
  113. cons.newInstance(args)：新建实例。   
  114.   
  115.   
  116. 6. 判断是否为某个类的实例   
  117.   
  118. 1 public boolean isInstance(Object obj, Class cls) {   
  119. 2     return cls.isInstance(obj);   
  120. 3 }   
  121.   
  122.   
  123. 7. 得到数组中的某个元素   
  124. 1 public Object getByArray(Object array, int index) {   
  125. 2     return Array.get(array,index);   
  126. 3 }   
  127.   
  128.   
  129. 附完整源码：   
  130.   
  131. import java.lang.reflect.Array;   
  132. import java.lang.reflect.Constructor;   
  133. import java.lang.reflect.Field;   
  134. import java.lang.reflect.Method;   
  135.   
  136.   
  137. /**  
  138.  * Java Reflection Cookbook  
  139.  *  
  140.  * @author Michael Lee  
  141.  * @since 2006-8-23  
  142.  * @version 0.1a  
  143.  */  
  144.   
  145. public class Reflection {   
  146.     /**  
  147.      * 得到某个对象的公共属性  
  148.      *  
  149.      * @param owner, fieldName  
  150.      * @return 该属性对象  
  151.      * @throws Exception  
  152.      *  
  153.      */  
  154.     public Object getProperty(Object owner, String fieldName) throws Exception {   
  155.         Class ownerClass = owner.getClass();   
  156.   
  157.         Field field = ownerClass.getField(fieldName);   
  158.   
  159.         Object property = field.get(owner);   
  160.   
  161.         return property;   
  162.     }   
  163.   
  164.     /**  
  165.      * 得到某类的静态公共属性  
  166.      *  
  167.      * @param className   类名  
  168.      * @param fieldName   属性名  
  169.      * @return 该属性对象  
  170.      * @throws Exception  
  171.      */  
  172.     public Object getStaticProperty(String className, String fieldName)   
  173.             throws Exception {   
  174.         Class ownerClass = Class.forName(className);   
  175.   
  176.         Field field = ownerClass.getField(fieldName);   
  177.   
  178.         Object property = field.get(ownerClass);   
  179.   
  180.         return property;   
  181.     }   
  182.   
  183.   
  184.     /**  
  185.      * 执行某对象方法  
  186.      *  
  187.      * @param owner  
  188.      *            对象  
  189.      * @param methodName  
  190.      *            方法名  
  191.      * @param args  
  192.      *            参数  
  193.      * @return 方法返回值  
  194.      * @throws Exception  
  195.      */  
  196.     public Object invokeMethod(Object owner, String methodName, Object[] args)   
  197.             throws Exception {   
  198.   
  199.         Class ownerClass = owner.getClass();   
  200.   
  201.         Class[] argsClass = new Class[args.length];   
  202.   
  203.         for (int i = 0, j = args.length; i < j; i++) {   
  204.             argsClass[i] = args[i].getClass();   
  205.         }   
  206.   
  207.         Method method = ownerClass.getMethod(methodName, argsClass);   
  208.   
  209.         return method.invoke(owner, args);   
  210.     }   
  211.   
  212.   
  213.       /**  
  214.      * 执行某类的静态方法  
  215.      *  
  216.      * @param className  
  217.      *            类名  
  218.      * @param methodName  
  219.      *            方法名  
  220.      * @param args  
  221.      *            参数数组  
  222.      * @return 执行方法返回的结果  
  223.      * @throws Exception  
  224.      */  
  225.     public Object invokeStaticMethod(String className, String methodName,   
  226.             Object[] args) throws Exception {   
  227.         Class ownerClass = Class.forName(className);   
  228.   
  229.         Class[] argsClass = new Class[args.length];   
  230.   
  231.         for (int i = 0, j = args.length; i < j; i++) {   
  232.             argsClass[i] = args[i].getClass();   
  233.         }   
  234.   
  235.         Method method = ownerClass.getMethod(methodName, argsClass);   
  236.   
  237.         return method.invoke(null, args);   
  238.     }   
  239.   
  240.   
  241.   
  242.     /**  
  243.      * 新建实例  
  244.      *  
  245.      * @param className  
  246.      *            类名  
  247.      * @param args  
  248.      *            构造函数的参数  
  249.      * @return 新建的实例  
  250.      * @throws Exception  
  251.      */  
  252.     public Object newInstance(String className, Object[] args) throws Exception {   
  253.         Class newoneClass = Class.forName(className);   
  254.   
  255.         Class[] argsClass = new Class[args.length];   
  256.   
  257.         for (int i = 0, j = args.length; i < j; i++) {   
  258.             argsClass[i] = args[i].getClass();   
  259.         }   
  260.   
  261.         Constructor cons = newoneClass.getConstructor(argsClass);   
  262.   
  263.         return cons.newInstance(args);   
  264.   
  265.     }   
  266.   
  267.   
  268.        
  269.     /**  
  270.      * 是不是某个类的实例  
  271.      * @param obj 实例  
  272.      * @param cls 类  
  273.      * @return 如果 obj 是此类的实例，则返回 true  
  274.      */  
  275.     public boolean isInstance(Object obj, Class cls) {   
  276.         return cls.isInstance(obj);   
  277.     }   
  278.        
  279.     /**  
  280.      * 得到数组中的某个元素  
  281.      * @param array 数组  
  282.      * @param index 索引  
  283.      * @return 返回指定数组对象中索引组件的值  
  284.      */  
  285.     public Object getByArray(Object array, int index) {   
  286.         return Array.get(array,index);   
  287.     }   
  288. }  
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 
 3     Class ownerClass = owner.getClass();
 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(owner, args);
14 }
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。

5～9行：配置参数的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 
 2 public Object newInstance(String className, Object[] args) throws Exception {
 3     Class newoneClass = 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     Constructor cons = newoneClass.getConstructor(argsClass);
12 
13     return cons.newInstance(args);
14 
15 }

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。

第5～第9行：得到参数的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 }


附完整源码：

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;


/**
 * Java Reflection Cookbook
 *
 * @author Michael Lee
 * @since 2006-8-23
 * @version 0.1a
 */

public class Reflection {
    /**
     * 得到某个对象的公共属性
     *
     * @param owner, fieldName
     * @return 该属性对象
     * @throws Exception
     *
     */
    public Object getProperty(Object owner, String fieldName) throws Exception {
        Class ownerClass = owner.getClass();

        Field field = ownerClass.getField(fieldName);

        Object property = field.get(owner);

        return property;
    }

    /**
     * 得到某类的静态公共属性
     *
     * @param className   类名
     * @param fieldName   属性名
     * @return 该属性对象
     * @throws Exception
     */
    public Object getStaticProperty(String className, String fieldName)
            throws Exception {
        Class ownerClass = Class.forName(className);

        Field field = ownerClass.getField(fieldName);

        Object property = field.get(ownerClass);

        return property;
    }


    /**
     * 执行某对象方法
     *
     * @param owner
     *            对象
     * @param methodName
     *            方法名
     * @param args
     *            参数
     * @return 方法返回值
     * @throws Exception
     */
    public Object invokeMethod(Object owner, String methodName, Object[] args)
            throws Exception {

        Class ownerClass = owner.getClass();

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Method method = ownerClass.getMethod(methodName, argsClass);

        return method.invoke(owner, args);
    }


      /**
     * 执行某类的静态方法
     *
     * @param className
     *            类名
     * @param methodName
     *            方法名
     * @param args
     *            参数数组
     * @return 执行方法返回的结果
     * @throws Exception
     */
    public Object invokeStaticMethod(String className, String methodName,
            Object[] args) throws Exception {
        Class ownerClass = Class.forName(className);

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Method method = ownerClass.getMethod(methodName, argsClass);

        return method.invoke(null, args);
    }



    /**
     * 新建实例
     *
     * @param className
     *            类名
     * @param args
     *            构造函数的参数
     * @return 新建的实例
     * @throws Exception
     */
    public Object newInstance(String className, Object[] args) throws Exception {
        Class newoneClass = Class.forName(className);

        Class[] argsClass = new Class[args.length];

        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }

        Constructor cons = newoneClass.getConstructor(argsClass);

        return cons.newInstance(args);

    }


    
    /**
     * 是不是某个类的实例
     * @param obj 实例
     * @param cls 类
     * @return 如果 obj 是此类的实例，则返回 true
     */
    public boolean isInstance(Object obj, Class cls) {
        return cls.isInstance(obj);
    }
    
    /**
     * 得到数组中的某个元素
     * @param array 数组
     * @param index 索引
     * @return 返回指定数组对象中索引组件的值
     */
    public Object getByArray(Object array, int index) {
        return Array.get(array,index);
    }
}

 

分享到：
| DateHelper
评论
发表评论

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

相关推荐

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

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

    Java经典实例.第三版（高清PDF+配套代码）

    《Java经典实例.第三版》是一本深受Java开发者欢迎的实战指南，旨在通过丰富的实例来深入浅出地讲解Java编程的各个方面。这本书的高清PDF版本提供了清晰易读的阅读体验，而配套的代码则为读者提供了实践操作的机会，...

    java 经典实例 cookbook 书中 代码 第二部分

    java cookbook O'Reilly

    java 经典实例 cookbook 书中代码第一部分

    java 经典实例 代码 第一部分10M cookbook 封面 斗鸡 O'Reilly qq:287196468 分2部分下载

    Java Cookbook(3rd) 无水印pdf

    Java Cookbook(3rd) 英文无水印pdf 第3版 pdf所有页面使用FoxitReader和PDF-XChangeViewer测试都可以打开 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或...

    Kubernetes经典实例：Kubernetes Cookbook.zip

    Kubernetes经典实例：Kubernetes Cookbook 中、英文版 高清打包合集

    R语言经典实例 英文版 R Cookbook

    If you're a beginner, R Cookbook will help get you started. If you're an experienced data programmer, it will jog your memory and expand your horizons. You'll get the job done faster and learn more ...

    Java.9.Concurrency.Cookbook.2nd.Edition

    《Java 9 Concurrency Cookbook 2nd Edition》是一本针对Java并发编程的权威指南，旨在帮助开发者深入理解和熟练掌握Java 9中的并发特性。这本书在2017年出版，结合了最新的Java版本特性，提供了丰富的实践案例和...

    Java.9.Cookbook

    《Java 9 Cookbook》是2017年出版的一本针对Java 9开发者的实用指南。这本书深入浅出地介绍了Java 9的新特性和改进，旨在帮助开发者更好地理解和利用这个版本的强大功能。以下是对该书内容的一些关键知识点的概述： ...

    Java 9 Cookbook epub

    Java 9 Cookbook 英文epub 本资源转载自网络，如有侵权，请联系上传者或csdn删除 本资源转载自网络，如有侵权，请联系上传者或csdn删除

    Java 11 Cookbook, Second Edition

    Java 11 Cookbook offers a range of software development solutions with simple and straightforward Java 11 code examples to help you build a modern software system. Starting with the installation of ...

    java 7 Concurrency cookbook

    《Java 7 Concurrency Cookbook》是一本专注于Java并发编程实践的书籍，旨在帮助开发者深入理解并熟练运用Java 7中的并发工具和API。这本书通过实际的示例代码，讲解了如何在多线程环境中有效地管理和控制并发，提高...

    Java SOA Cookbook源代码

    《Java SOA Cookbook》是一本专注于Java面向服务架构（Service-Oriented Architecture，简称SOA）实践的书籍，源代码的提供旨在帮助读者更深入地理解书中的概念和技术。SOA是一种设计原则，它强调通过独立、可重用的...

    Java_9_Concurrency_Cookbook_-_Second_Edition.pdf

    #### 标签：Java 9、并发、Cookbook、Java9 - **Java 9**：是Java平台的一个重要版本，引入了许多新的特性和改进，尤其是在模块化方面。本书主要针对Java 9环境下的并发编程进行讲解。 - **并发**：强调了本书的...

    Java-NIO-Programming-Cookbook(含源码)

    本书《Java NIO Programming Cookbook》旨在深入浅出地介绍如何利用Java NIO进行高效的I/O编程，并提供了源码供读者实践和学习。 在Java NIO中，`ByteBuffer`是核心类之一，它用于存储和读写数据。`...

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