Java反射机制初探

最新推荐文章于 2017-09-04 09:56:00 发布

java_wliang

最新推荐文章于 2017-09-04 09:56:00 发布

阅读量659

点赞数

分类专栏： Java 文章标签： Java

Java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

反射，reflection，听其名就像照镜子一样，可以看见自己也可以看见别人的每一部分。在java语言中这是一个很重要的特性。

下面是来自sun公司官网关于反射的介绍：

Reflection is a feature in the Java programming language. It allows an executing Java program to examine or "introspect" upon itself, and manipulate internal properties of the program. For example, it's possible for a Java class to obtain the names of all its members and display them.

The ability to examine and manipulate a Java class from within itself may not sound like very much, but in other programming languages this feature simply doesn't exist. For example, there is no way in a Pascal, C, or C++ program to obtain information about the functions defined within that program.

One tangible use of reflection is in JavaBeans, where software components can be manipulated visually via a builder tool. The tool uses reflection to obtain the properties of Java components (classes) as they are dynamically loaded.

那么解释一下就是，反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行操作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。这个能特定我们不常看到，但是在其他的比如C或者C++语言中很不就存在这个特性。一个常见的例子是在JavaBean中，一些组件可以通过一个构造器来操作。这个构造器就是用的反射在动态加载的时候来获取的java中类的属性的。

反射的前传：类类型 Class Class

java中有一个类很特殊，就是Class类，很多朋友在写程序的时候有用过比如Apple.class来查看类型信息，大家就可以把它理解为封装了类的信息，很多解释说Class类没有构造器，其实是有的，只不过它的构造方法是private的（构造函数还有private的？？有，这样是为了禁止开发者去自己创建Class类的实例）。我们可以看一下JDK中源码：

注释很明确的告诉了我们，这个类是有JVM来创建的，所以我们就不用麻烦了。如果我们拿到一个类的类型信息，就可以利用反射获取其各种成员以及方法了。（注：Class 从JDK1.5版本后就开始更多为泛型服务了）那么我们怎么拿到一个类型的信息呢？假设我们有一个Role类：

package com.java.reflection;

public class Role {
	private String roleType;
	private String roleName;
	private String roleAge;
	
	public Role() {
		this.roleType = "defaultType";
		this.roleName = "defaultName";
		this.roleAge = "defaultAge";
		System.out.println("public Constructor Role() is invoking");
	}
	// 私有构造器
	private Role(String roleType,String roleName,String roleAge) {
		this.roleType = roleType;
		this.roleName = roleName;
		this.roleAge = roleAge;
		System.out.println("Private Constructor Role(String roleType,String roleName,String roleAge) is invoking");
	}
	public String getRoleType() {
		return roleType;
	}
	public void setRoleType(String roleType) {
		this.roleType = roleType;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
	public String getRoleAge() {
		return roleAge;
	}
	public void setRoleAge(String roleAge) {
		this.roleAge = roleAge;
	}
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "This is a role called " + roleName;
	}
	
}

在没有对象实例的时候，主要有两种办法。

		// 获取类类型的两种方式
		Class Class1 = Role.class;
		Class Class2 = Class.forName("com.java.reflection.Role");

注意第二种方式中，forName中的参数一定是完整的类名（包名+类名），并且这个方法需要捕获异常。现在得到cls1就可以创建一个Role类的实例了，利用Class的newInstance方法相当于调用类的默认的构造器

		// newInstance为类别创建一个实例，返回类型为Object类型，调用默认构造器
		Object object = Class1.newInstance();
		//Object o1 = new Role();   //与上面的方法等价

这样就创建了一个对象，缺点是我们只能利用默认构造函数，因为Class的newInstance是不接受参数的，后面会讲到可接受参数的newInstance，第二，如果类的构造函数是private的，比如Class，我们仍旧不能实例化其对象。

获取类的构造器

　　首先介绍一下Constructor类，这个类用来封装反射得到的构造器，Class有四个方法来获得Constructor对象

public Constructor<?>[] getConstructors() 返回类中所有的public构造器集合，默认构造器的下标为0
public Constructor<T> getConstructor(Class<?>... parameterTypes) 返回指定public构造器，参数为构造器参数类型集合
public Constructor<?>[] getDeclaredConstructors() 返回类中所有的构造器，包括私有
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回任意指定的构造器

从名字来看，还是很好懂的，带上Declared的都是获得所有的构造方法，包括私有，哈，这下我们就可以调用原本不允许调用的私有构造器了，看代码

		/**
         * 获取构造方法Constructor
         * getConstructor()  only for public 
         * getDeclaredConstructor()  global access all 
         * 
         * */
        
        // 指定参数列表获取特定的方法,参数为Class数组，存放三个String
        Constructor con = Class1.getDeclaredConstructor(new Class[]{String.class,String.class,String.class});
        con.setAccessible(true); //设置可访问的权限
        Object obj = con.newInstance(new Object[]{"teacher","tom","10"});
        System.out.println(obj);  //打印一下这个对象的信息
        
        // 获取所有的构造方法集合
        Constructor con1[] = Class1.getDeclaredConstructors();
        con1[1].setAccessible(true);
        Object obj1 = con1[1].newInstance(new Object[]{"student","lili","16"});
        System.out.println(obj1);

　解释一下：第一个是获得一个指定的方法，我们指定了参数是一个String类型，第二段我们获得了所有的构造方法集合，并选取了其中一个创建了新的对象。注意这里Constructor的newInstance方法就可以设置参数了，与文章前面的同样的方法形成了对比。

　　注意，以上的四个方法全部需要抛出异常，当我们获得私有的方法的时候，要用setAccessible设置一下可访问的权限，例子中没有演示获取共有方法，那个比较简单，就不做介绍了，其实掌握了上面两个，其他就好理解了。

获取类的成员变量

　　了解了构造器，其实你可以猜到成员变量的获取方法了，成员变量用Field类进行封装。

主要的方法非常的类似：

public Field getDeclaredField(String name) 获取任意指定名字的成员
public Field[] getDeclaredFields() 获取所有的成员变量
public Field getField(String name) 获取任意public成员变量
public Field[] getFields() 获取所有的public成员变量

　可以看出这些方法都是异曲同工的，好了直接看一下例子吧

/**
* 获取成员变量使用Field类进行封装
* getDeclaredField()
* getDeclaredFields()
* */
Field rolefield = Class1.getDeclaredField("roleName");
rolefield.setAccessible(true);
// obj指向Role对象实例，获取obj指向对象的roleName域的值
System.out.println("We get field is:" + rolefield.getName() + " and value is " + rolefield.get(obj));

// 获取类所有的成员变量
Field field[] = Class1.getDeclaredFields();
field[0].setAccessible(true);
field[1].setAccessible(true);
field[2].setAccessible(true);
System.out.println("所有成员变量以及对应值如下：");
System.out.println("We get field is :" + field[0].getName() + " and value is :" + field[0].get(obj));
System.out.println("We get field is :" + field[1].getName() + " and value is :" + field[1].get(obj));
System.out.println("We get field is :" + field[2].getName() + " and value is :" + field[2].get(obj));

这是在访问私有变量，什么私有变量也可以访问？？是的。。。

获取类的方法

　　我觉得你已经可以帮我写这一段了，封装类的方法的类是Method.获取method也有四个方法，猜到了没？？

public Method[] getMethods() 获取所有的共有方法的集合
public Method getMethod(String name,Class<?>... parameterTypes) 获取指定公有方法参数1：方法名参数2：参数类型集合
public Method[] getDeclaredMethods() 获取所有的方法
public Method getDeclaredMethod(String name,Class<?>... parameterTypes) 获取任意指定方法

看下面的例子吧

        /**
         * 调用类的方法 Method
         * getMethod()
         * getDeclaredMethod()
         * */
        // getMethod(String name,Class<?>... parameterTypes)，由于getRoleName为无参所以null
        Method method = Class1.getMethod("getRoleName", null);
        // obj所值类的方法被执行
        Object name = method.invoke(obj, null);
        System.out.println("we invoke method : " + method.getName() + "and its value is :" + name);
        // 获取所有的方法并输出方法
        Method methods[] = Class1.getDeclaredMethods();
        System.out.println("该类的所有方法如下：");
        for(Method m : methods) {
        	System.out.println(m.getName());
        }

这个很简单吧，无参的时候我们只要传null就行了。

总结

以上就是反射机制的简单的使用，显然学过spring的朋友一定明白了，为什么可以通过配置文件就可以让我们获得指定的方法和变量，在我们创建对象的时候都是通过传进string实现的，就好像你需要什么，我们去为你生产，还有我们一直在用Object,这就说明java语言的动态特性，依赖性大大的降低了。

全部代码如下：

package com.java.reflection;

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

public class ReflectionTest {
	public static void main(String[] args) throws Exception {
		// 获取类类型的两种方式
		Class Class1 = Role.class;
		Class Class2 = Class.forName("com.java.reflection.Role");
		
		// newInstance为类别创建一个实例，返回类型为Object类型，调用默认构造器
		Object object = Class1.newInstance();
		//Object o1 = new Role();   //与上面的方法等价
		/**
         * 获取构造方法Constructor
         * getConstructor()  only for public 
         * getDeclaredConstructor()  global access all 
         * 
         * */
        
        // 指定参数列表获取特定的方法,参数为Class数组，存放三个String
        Constructor con = Class1.getDeclaredConstructor(new Class[]{String.class,String.class,String.class});
        con.setAccessible(true); //设置可访问的权限
        Object obj = con.newInstance(new Object[]{"teacher","tom","10"});
        System.out.println(obj);  //打印一下这个对象的信息
        
        // 获取所有的构造方法集合
        Constructor con1[] = Class1.getDeclaredConstructors();
        con1[1].setAccessible(true);
        Object obj1 = con1[1].newInstance(new Object[]{"student","lili","16"});
        System.out.println(obj1);
        
        /**
         * 获取成员变量使用Field类进行封装
         * getDeclaredField()
         * getDeclaredFields()
         * */
        Field rolefield = Class1.getDeclaredField("roleName");
        rolefield.setAccessible(true); 
        // obj指向Role对象实例，获取obj指向对象的roleName域的值
        System.out.println("We get field is:" + rolefield.getName() + " and value is " +  rolefield.get(obj));
        
        // 获取类所有的成员变量
        Field field[] = Class1.getDeclaredFields();
        field[0].setAccessible(true);
        field[1].setAccessible(true);
        field[2].setAccessible(true);
        System.out.println("所有成员变量以及对应值如下：");
        System.out.println("We get field is :" + field[0].getName() + " and value is :" + field[0].get(obj));
        System.out.println("We get field is :" + field[1].getName() + " and value is :" + field[1].get(obj));
        System.out.println("We get field is :" + field[2].getName() + " and value is :" + field[2].get(obj));
        
        /**
         * 调用类的方法 Method
         * getMethod()
         * getDeclaredMethod()
         * */
        // getMethod(String name,Class<?>... parameterTypes)，由于getRoleName为无参所以null
        Method method = Class1.getMethod("getRoleName", null);
        // obj所值类的方法被执行
        Object name = method.invoke(obj, null);
        System.out.println("we invoke method : " + method.getName() + "and its value is :" + name);
        // 获取所有的方法并输出方法
        Method methods[] = Class1.getDeclaredMethods();
        System.out.println("该类的所有方法如下：");
        for(Method m : methods) {
        	System.out.println(m.getName());
        }
	}
}

转载： http://www.cnblogs.com/octobershiner/archive/2012/03/18/2404751.html

获取类的方法 huoq 获取类的方法

获取类的成员变量

获取类获取类的成员变量的成员变量

获取类的成员变量

java_wliang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java反射机制初探

反射，reflection，听其名就像照镜子一样，可以看见自己也可以看见别人的每一部分。在java语言中这是一个很重要的特性。下面是来自sun公司官网关于反射的介绍： Reflection is a feature in the Java programming language. It allows an executing Java program to examine or
复制链接

扫一扫