java 反射机制

转自http://www.iteye.com/topic/1123081

Java语言允许通过程序化的方式间接对Class进行操作，Class文件由类装载器装载后，在JVM中将形成一份描述Class结构的元信息对象，通过该元信息对象可以获知Class的结构信息：如构造函数、属性和方法等。Java允许用户借由这个Class相关的元信息对象间接调用Class对象的功能，这就为使用程序化方式操作Class对象开辟了途径。

简单实例

我们将从一个简单例子开始探访Java反射机制的征程，下面的Car类拥有两个构造函数、两个方法以及三个属性，如代码清单3-9所示：

代码清单3-9  Car

Java代码

  1. package com.baobaotao.reflect;

  2. public class Car {
  3. private String brand;
  4. private String color;
  5. private int maxSpeed;
  6. //①默认构造函数
  7. public Car(){}
  8. //②带参构造函数
  9. public Car(String brand,String color,int maxSpeed){
  10. this.brand = brand;
  11. this.color = color;
  12. this.maxSpeed = maxSpeed;
  13. }
  14. //③未带参的方法
  15. public void introduce() {
  16. System.out.println("brand:"+brand+";color:"+color+";maxSpeed:" +maxSpeed);
  17. }
  18. //省略参数的getter/Setter方法
  19. …
  20. }

package com.baobaotao.reflect;
public class Car {
        private String brand;
        private String color;
        private int maxSpeed;

     //①默认构造函数
        public Car(){}

     //②带参构造函数
        public Car(String brand,String color,int maxSpeed){
                this.brand = brand;
                this.color = color;
                this.maxSpeed = maxSpeed;
        }

     //③未带参的方法
        public void introduce() {
       System.out.println("brand:"+brand+";color:"+color+";maxSpeed:" +maxSpeed);
        }
     //省略参数的getter/Setter方法
     …
}

一般情况下，我们会使用如下的代码创建Car的实例：

Java代码

  1. Car car = new Car();

  2. car.setBrand("红旗CA72");

Car car = new Car();
car.setBrand("红旗CA72");

或者：

Java代码

  1. Car car = new Car("红旗CA72","黑色");

Car car = new Car("红旗CA72","黑色");

以上两种方法都采用传统方式的直接调用目标类的方法，下面我们通过Java反射机制以一种更加通用的方式间接地操作目标类：

代码清单3-10  ReflectTest

Java代码

  1. package com.baobaotao. reflect;

  2. import java.lang.reflect.Constructor;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Method;
  5. public class ReflectTest {
  6. public static Car  initByDefaultConst() throws Throwable
  7. {
  8. //①通过类装载器获取Car类对象
  9. ClassLoader loader = Thread.currentThread().getContextClassLoader();
  10. Class clazz = loader.loadClass("com.baobaotao.reflect.Car");
  11. //②获取类的默认构造器对象并通过它实例化Car
  12. Constructor cons = clazz.getDeclaredConstructor((Class[])null);
  13. Car car = (Car)cons.newInstance();
  14. //③通过反射方法设置属性
  15. Method setBrand = clazz.getMethod("setBrand",String.class);
  16. setBrand.invoke(car,"红旗CA72");
  17. Method setColor = clazz.getMethod("setColor",String.class);
  18. setColor.invoke(car,"黑色");
  19. Method setMaxSpeed = clazz.getMethod("setMaxSpeed",int.class);
  20. setMaxSpeed.invoke(car,200);
  21. return car;
  22. }
  23. public static void main(String[] args) throws Throwable {
  24. Car car = initByDefaultConst();
  25. car.introduce();
  26. }
  27. }

package com.baobaotao. reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectTest {
        public static Car  initByDefaultConst() throws Throwable
        {
                //①通过类装载器获取Car类对象
                ClassLoader loader = Thread.currentThread().getContextClassLoader();
                Class clazz = loader.loadClass("com.baobaotao.reflect.Car"); 

          //②获取类的默认构造器对象并通过它实例化Car
                Constructor cons = clazz.getDeclaredConstructor((Class[])null);
                Car car = (Car)cons.newInstance();

          //③通过反射方法设置属性
                Method setBrand = clazz.getMethod("setBrand",String.class);
                setBrand.invoke(car,"红旗CA72");
                Method setColor = clazz.getMethod("setColor",String.class);
                setColor.invoke(car,"黑色");
                Method setMaxSpeed = clazz.getMethod("setMaxSpeed",int.class);
                setMaxSpeed.invoke(car,200);
                return car;
        }

        public static void main(String[] args) throws Throwable {
                Car car = initByDefaultConst();
                car.introduce();
        }
}

运行以上程序，在控制台上将打印出以下信息：

引用

brand:红旗CA72;color:黑色;maxSpeed:200

这说明我们完全可以通过编程方式调用Class的各项功能，这和直接通过构造函数和方法调用类功能的效果是一致的，只不过前者是间接调用，后者是直接调用罢了。

在ReflectTest中，使用了几个重要的反射类，分别是ClassLoader、Class、Constructor和Method，通过这些反射类就可以间接调用目标Class的各项功能了。在①处，我们获取当前线程的ClassLoader，然后通过指定的全限定类“com.baobaotao.beans.Car”装载Car类对应的反射实例。在②处，我们通过Car的反射类对象获取Car的构造函数对象cons，通过构造函数对象的newInstrance()方法实例化Car对象，其效果等同于new
Car()。在③处，我们又通过Car的反射类对象的getMethod（String methodName,Class
paramClass）获取属性的Setter方法对象，第一个参数是目标Class的方法名；第二个参数是方法入参的对象类型。获取方法反射对象后，即可通过invoke（Object
obj,Object
param）方法调用目标类的方法，该方法的第一个参数是操作的目标类对象实例；第二个参数是目标方法的入参。

在代码清单3
10中，粗体所示部分的信息即是通过反射方法操控目标类的元信息，如果我们将这些信息以一个配置文件的方式提供，就可以使用Java语言的反射功能编写一段通用的代码对类似于Car的类进行实例化及功能调用操作了。

类装载器ClassLoader

类装载器工作机制

类装载器就是寻找类的节码文件并构造出类在JVM内部表示对象的组件。在Java中，类装载器把一个类装入JVM中，要经过以下步骤：

[1.]装载：查找和导入Class文件；
[2.]链接：执行校验、准备和解析步骤，其中解析步骤是可以选择的：
   
[2.1]校验：检查载入Class文件数据的正确性；
   
[2.2]准备：给类的静态变量分配存储空间；
   
[2.3]解析：将符号引用转成直接引用；
[3.]初始化：对类的静态变量、静态代码块执行初始化工作。

类装载工作由ClassLoader及其子类负责，ClassLoader是一个重要的Java运行时系统组件，它负责在运行时查找和装入Class字节码文件。JVM在运行时会产生三个ClassLoader：根装载器、ExtClassLoader（扩展类装载器）和AppClassLoader（系统类装载器）。其中，根装载器不是ClassLoader的子类，它使用C++编写，因此我们在Java中看不到它，根装载器负责装载JRE的核心类库，如JRE目标下的rt.jar、charsets.jar等。ExtClassLoader和AppClassLoader都是ClassLoader的子类。其中ExtClassLoader负责装载JRE扩展目录ext中的JAR类包；AppClassLoader负责装载Classpath路径下的类包。

这三个类装载器之间存在父子层级关系，即根装载器是ExtClassLoader的父装载器，ExtClassLoader是AppClassLoader的父装载器。默认情况下，使用AppClassLoader装载应用程序的类，我们可以做一个实验：

代码清单3-11  ClassLoaderTest

Java代码

public class ClassLoaderTest {

  1. public static void main(String[] args) {

  2. ClassLoader loader = Thread.currentThread().getContextClassLoader();
  3. System.out.println("current loader:"+loader);
  4. System.out.println("parent loader:"+loader.getParent());
  5. System.out.println("grandparent loader:"+loader.getParent(). getParent());
  6. }
  7. }

public class ClassLoaderTest {
        public static void main(String[] args) {
                ClassLoader loader = Thread.currentThread().getContextClassLoader();
                System.out.println("current loader:"+loader);
                System.out.println("parent loader:"+loader.getParent());
                System.out.println("grandparent loader:"+loader.getParent(). getParent());
        }
}

运行以上代码，在控制台上将打出以下信息：

引用

current
loader:[email protected]
parent loader:[email protected]
    
//①根装载器在Java中访问不到，所以返回null
grandparent loader:null

通过以上的输出信息，我们知道当前的ClassLoader是AppClassLoader，父ClassLoader是ExtClassLoader，祖父ClassLoader是根类装载器，因为在Java中无法获得它的句柄，所以仅返回null。

JVM装载类时使用“全盘负责委托机制”，“全盘负责”是指当一个ClassLoader装载一个类的时，除非显式地使用另一个ClassLoader，该类所依赖及引用的类也由这个ClassLoader载入；“委托机制”是指先委托父装载器寻找目标类，只有在找不到的情况下才从自己的类路径中查找并装载目标类。这一点是从安全角度考虑的，试想如果有人编写了一个恶意的基础类（如java.lang.String）并装载到JVM中将会引起多么可怕的后果。但是由于有了“全盘负责委托机制”，java.lang.String永远是由根装载器来装载的，这样就避免了上述事件的发生。

ClassLoader重要方法

在Java中，ClassLoader是一个抽象类，位于java.lang包中。下面对该类的一些重要接口方法进行介绍：

  • Class loadClass(String name)

  • name参数指定类装载器需要装载类的名字，必须使用全限定类名，如com.baobaotao.
    beans.Car。该方法有一个重载方法loadClass(String name ,boolean
    resolve)，resolve参数告诉类装载器是否需要解析该类。在初始化类之前，应考虑进行类解析的工作，但并不是所有的类都需要解析，如果JVM只需要知道该类是否存在或找出该类的超类，那么就不需要进行解析。

  • Class defineClass(String name, byte[] b, int off, int len)
  • 将类文件的字节数组转换成JVM内部的java.lang.Class对象。字节数组可以从本地文件系统、远程网络获取。name为字节数组对应的全限定类名。
  • Class findSystemClass(String name)
  • 从本地文件系统载入Class文件，如果本地文件系统不存在该Class文件，将抛出ClassNotFoundException异常。该方法是JVM默认使用的装载机制。
  • Class findLoadedClass(String name)
  • 调用该方法来查看ClassLoader是否已装入某个类。如果已装入，那么返回java.lang.Class对象，否则返回null。如果强行装载已存在的类，将会抛出链接错误。
  • ClassLoader getParent()
  • 获取类装载器的父装载器，除根装载器外，所有的类装载器都有且仅有一个父装载器，ExtClassLoader的父装载器是根装载器，因为根装载器非Java编写，所以无法获得，将返回null。

除JVM默认的三个ClassLoader以外，可以编写自己的第三方类装载器，以实现一些特殊的需求。类文件被装载并解析后，在JVM内将拥有一个对应的java.lang.Class类描述对象，该类的实例都拥有指向这个类描述对象的引用，而类描述对象又拥有指向关联ClassLoader的引用，如图3-4所示。

反射机制" TITLE="java 反射机制" />

每一个类在JVM中都拥有一个对应的java.lang.Class对象，它提供了类结构信息的描述。数组、枚举、注解以及基本Java类型（如int、double等），甚至void都拥有对应的Class对象。Class没有public的构造方法。Class对象是在装载类时由JVM通过调用类装载器中的defineClass()方法自动构造的。

Java反射机制

Class反射对象描述类语义结构，可以从Class对象中获取构造函数、成员变量、方法类等类元素的反射对象，并以编程的方式通过这些反射对象对目标类对象进行操作。这些反射对象类在java.reflect包中定义，下面是最主要的三个反射类：

  •  
    Constructor：类的构造函数反射类，通过Class#getConstructors()方法可以获得类的所有构造函数反射对象数组。在JDK5.0中，还可以通过getConstructor(Class...
    parameterTypes)获取拥有特定入参的构造函数反射对象。Constructor的一个主要方法是newInstance(Object[]
    initargs)，通过该方法可以创建一个对象类的实例，相当于new关键字。在JDK5.0中该方法演化为更为灵活的形式：newInstance
    (Object... initargs)。

  •  
    Method：类方法的反射类，通过Class#getDeclaredMethods()方法可以获取类的所有方法反射类对象数组Method[]。在JDK5.0中可以通过getDeclaredMethod(String
    name, Class...
    parameterTypes)获取特定签名的方法，name为方法名；Class...为方法入参类型列表。Method最主要的方法是invoke(Object
    obj, Object[] args)，obj表示操作的目标对象；args为方法入参，代码清单3
    10③处演示了这个反射类的使用方法。在JDK 5.0中，该方法的形式调整为invoke(Object obj, Object...
    args)。此外，Method还有很多用于获取类方法更多信息的方法：

  • 1）Class getReturnType()：获取方法的返回值类型；
         
    2）Class[] getParameterTypes()：获取方法的入参类型数组；
         
    3）Class[] getExceptionTypes()：获取方法的异常类型数组；
         
    4）Annotation[][] getParameterAnnotations()：获取方法的注解信息，JDK
    5.0中的新方法；

  •  
    Field：类的成员变量的反射类，通过Class#getDeclaredFields()方法可以获取类的成员变量反射对象数组，通过Class#getDeclaredField(String
    name)则可获取某个特定名称的成员变量反射对象。Field类最主要的方法是set(Object obj, Object
    value)，obj表示操作的目标对象，通过value为目标对象的成员变量设置值。如果成员变量为基础类型，用户可以使用Field类中提供的带类型名的值设置方法，如setBoolean(Object
    obj, boolean value)、setInt(Object obj, int value)等。

此外，Java还为包提供了Package反射类，在JDK
5.0中还为注解提供了AnnotatedElement反射类。总之，Java的反射体系保证了可以通过程序化的方式访问目标类中所有的元素，对于private或protected的成员变量和方法，只要JVM的安全机制允许，也可以通过反射进行调用，请看下面的例子：

代码清单3-12  PrivateCarReflect

Java代码

package com.baobaotao.reflect;

  1. public class PrivateCar {

  2. //①private成员变量：使用传统的类实例调用方式，只能在本类中访问
  3. private String color;
  4. //②protected方法：使用传统的类实例调用方式，只能在子类和本包中访问
  5. protected void drive(){
  6. System.out.println("drive private car! the color is:"+color);
  7. }
  8. }

package com.baobaotao.reflect;
public class PrivateCar {
       //①private成员变量：使用传统的类实例调用方式，只能在本类中访问
   private String color;
        //②protected方法：使用传统的类实例调用方式，只能在子类和本包中访问
   protected void drive(){

System.out.println("drive private car! the color is:"+color);
   }
}

color变量和drive()方法都是私有的，通过类实例变量无法在外部访问私有变量、调用私有方法的，但通过反射机制却可以绕过这个限制：

代码清单3-13  PrivateCarReflect

Java代码

  1. public class PrivateCarReflect {

  2. public static void main(String[] args) throws Throwable{
  3. ClassLoader loader = Thread.currentThread().getContextClassLoader();
  4. Class clazz = loader.loadClass("com.baobaotao.reflect.PrivateCar");
  5. PrivateCar pcar = (PrivateCar)clazz.newInstance();
  6. Field colorFld = clazz.getDeclaredField("color");
  7. //①取消Java语言访问检查以访问private变量
  8. colorFld.setAccessible(true);
  9. colorFld.set(pcar,"红色");
  10. Method driveMtd = clazz.getDeclaredMethod("drive",(Class[])null);
  11. //Method driveMtd = clazz.getDeclaredMethod("drive"); JDK5.0下使用
  12. //②取消Java语言访问检查以访问protected方法
  13. driveMtd.setAccessible(true);
  14. driveMtd.invoke(pcar,(Object[])null);
  15. }
  16. }

…
public class PrivateCarReflect {
   public static void main(String[] args) throws Throwable{
           ClassLoader loader = Thread.currentThread().getContextClassLoader();
           Class clazz = loader.loadClass("com.baobaotao.reflect.PrivateCar");
           PrivateCar pcar = (PrivateCar)clazz.newInstance();

           Field colorFld = clazz.getDeclaredField("color");
        //①取消Java语言访问检查以访问private变量
           colorFld.setAccessible(true);
           colorFld.set(pcar,"红色");

           Method driveMtd = clazz.getDeclaredMethod("drive",(Class[])null);
        //Method driveMtd = clazz.getDeclaredMethod("drive"); JDK5.0下使用

        //②取消Java语言访问检查以访问protected方法
           driveMtd.setAccessible(true);
        driveMtd.invoke(pcar,(Object[])null);
  }
}

运行该类，打印出以下信息：

引用

drive private car! the color is:红色

在访问private、protected成员变量和方法时必须通过setAccessible(boolean
access)方法取消Java语言检查，否则将抛出IllegalAccessException。如果JVM的安全管理器设置了相应的安全机制，调用该方法将抛出SecurityException。

时间： 2024-11-07 01:45:20

java 反射机制的相关文章

java反射机制（一）—— 利用反射机制实例化对象

一.Java有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用编译期间完全未知的classes.换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体.或对其fields设值.或唤起其methods.(度娘文库是这么说的) 二.这篇文章主要介绍一下通过反射机制去实例化一个类的对象,然后调用其方法.本文主要介绍两种方式,第一种就是通过构造函数来实例化,第二种就是通过Cl

【java】java反射机制，动态获取对象的属性和对应的参数值，并属性按照字典序排序，Field.setAccessible()方法的说明【可用于微信支付 签名生成】

方法1:通过get()方法获取属性值 package com.sxd.test.controller; public class FirstCa{ private Integer num; private String name; private Boolean flag; public Integer getNum() { return num; } public void setNum(Integer num) { this.num = num; } public String getNam

Java 反射机制

使用 Java 反射机制可以在运行时期检查 Java 类的信息,检查 Java 类的信息往往是你在使用 Java 反射机制的时候所做的第一件事情,通过获取类的信息你可以获取以下相关的内容: Class 对象 类名 修饰符 包信息 父类 实现的接口 构造器 方法 变量 注解 除了上述这些内容,还有很多的信息你可以通过反射机制获得,如果你想要知道全部的信息你可以查看相应的文档 JavaDoc for java.lang.Class 里面有详尽的描述. 在本节中我们会简短的涉及上述所提及的信息,上述的

Java反射机制浅析

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. "程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言".从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言.但是JAVA有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载.探知.使用

java反射机制分析

本文转自:http://www.cnblogs.com/gulvzhe/archive/2012/01/27/2330001.html 浅显易懂,值得收藏 Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象, 都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制.反射的概念是由Smith在1982年 首次提出的,主要是指程序可以访问.检测和修改它本身状态或行为的一种能力.这一概念的提出很快引发了

java 反射机制：运行时的类信息(为框架服务的Bug存在)

反射机制:JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 换一种引出反射的说法是:当通过反射与一个未知的类型的对象打交道是,JVM只是简单地检查这个类,看它是属于哪个特定的类(就想RTTI那样).在用它做其他事情之前必须先加载那个类的Class对象.因此,那个类的.class文件对于JVM来说必须是可获取的:那么在本地机器上,要么通过网络获得

工厂类分离与java反射机制

网易 博客 发现 小组 风格 手机博客 玩LOFTER,免费冲印20张照片!> 创建博客登录 加关注 黙言-在路上 奋斗 首页 日志 相册 音乐 收藏 博友 关于我 黙言 加博友   关注他 他的网易微博 最新日志 Javascript 操作select控件 Oracle 存储过程基本语法 将域名和tomcat6进行绑定的 svn 423 Locked JS的trim()方法 jbpm4.4 结束流程时报错 随机阅读 让员工每年有一次机会当主角 外国女性如何舍身"套"色狼 亚洲电

java反射机制简介

1.字节码.所谓的字节码就是当java虚拟机加载某个类的对象时,首先需要将硬盘中该类的源代码编译成class文件的二进制代码(字节码),然后将class文件的字节码加载到内存中,之后再创建该类的对象 2.java反射的基础是Class类(注意不是小写的class),Class类实例代表着内存中的一份字节码.常见的获取Class类对象的方法如下(第一种为对象的方法,第二种为类的方法): Dog dog = new Dog(); Class dogClass = dog.getClass(); Cl

【转载】Java反射机制详解

转自:http://baike.xsoftlab.net/view/209.html#3_8 1反射机制是什么 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制. 2反射机制能做什么 反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类: 在运行时构造任意一个类的对象: 在运行时判断任意一个类所具有的成员变量和方法: 在运行时调用任意一个

Java反射机制（Reflection）

Java反射机制(Reflection) 一.反射机制是什么 Java反射机制是程序在运行过程中,对于任意一个类都能够知道这个类的所有属性和方法;对于任意一个对象都能够调用它的任意一个方法和属性,这种动态获取类信息以及动态调用对象方法的功能就是JAVA语言的反射机制. 二.反射机制能干什么 (1)在运行时判断任意一个对象所属的类 (2)在运行时构造任意一个类的对象 (3)在运行时判断任意一个类所具有的成员变量和方法 (4)在运行时调用任意一个对象的方法 (PS:注意反射机制都是在程序运行时,而不