Java 内省(Introspector)与反射(Reflect)

       最近在给Android客户端做一个类似中间件的插件来连接app和另外一个独立模块的通信，用到了Java 反射和内省方面的知识，虽然之前写过一些简单的Demo，但是时间久了没碰就忘光了，于是在这里Mark一下！

一 Java反射机制

      Java反射机制是在运行状态中，对于任意一个类，都能够得到这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

      

      通俗的说，反射就是让你可以通过类名称来得到对象 ( 类，属性，方法 ) 的技术。不管什么类型对象，java虚拟机都会为之实例化一个 java.lang.Class的不可变实例，这个实例会提供方法来检测对象的成员(Field)和方法(Method)信息。

     

       Class 类支持反射的概念,Java附带的库java.lang.reflect包含了Field,Method以及Constructor类(每个类都实现了Member接口)。这些类型的对象是由JVM在运行期创建的,用以表示未知类里对应的成员。这样你就可以使用Constructor创建新的对象,用get()和set()方法读取和修改与Field对象关联的属性,用invoke()方法调用与Method对象关联的方法。另外,你还可以调用getFields(),getMethods(),getConstructors()等等很便利的方法,以返回表示属性、方法以及构造器的对象数组,这些对象(在JDK文档中,可找到与Class类相关的更多的资料)。这样,匿名对象的类信息就能在运行期被完全确定下来,而在编译期不需要知道任何事情。
      

       重要的是,反射机制并没有什么魔法。当你通过反射与一个未知类型的对象打交道时,JVM只是简单地检查这个对象,看它属于哪个特定的类(就象RTTI那样)。但在这之后,在做其它事情之前,必须加载那个类的Class对象。因此,那个类的.class文件对于JVM来说必须是可获取的,要么在本地机器上,要么可以通过网络取得。所以RTTI和反射之间真正的区别只在于,对RTTI来说,编译器在编译期打开和检查.class文件。(换句话说,我们可以用“普通”方式调用一个对象的所有方法。)而对于反射机制来说.class文件在编译期间是不可获取的,所以是在运行期打开和检查.class文件。 

      我们有两种方法来获取某个类的Class对象，如下：

//1.Class.forName
//			Class<?> clazz = Class.forName("com.ricky.java.junit.reflect.Calculator");
			
			//2.类名.class/对象..getClass()
//			Class<?> clazz = Calculator.class;
			Class<?> clazz = new Calculator().getClass();

拿到一个类的Class对象，我们就可以做很多事情了，有些甚至与教科书上的说法相违背(例如：private 属性/方法 其它对象访问不了)，下面通过一个实例来展示一下具体的用法。

首先，是待反射的类 Calculator.java

package com.ricky.java.junit.reflect;

@AutoWired(name="aaa")
public class Calculator {

	private String name;
	
	public Calculator(){
		
	}
	
	public Calculator(String name){
		this.name = name;
	}
	
	private String say(String word){
		
		return "say,"+word;
	}
	
	protected String hello(String word){
		
		return "hello,"+word;
	}
	
	public int add(int a,int b){
		
		return a+b;
	}
	
	public int sub(int a,int b){
		
		return a-b;
	}
	
	public void speak(String word){
		System.out.println("hi,"+word);
	}
	
	public void bb(String word){
		System.out.println(name);
		say(word);
	}
}

自定义注解 AutoWired.java

package com.ricky.java.junit.reflect;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface AutoWired {

	public String name();
}

ReflectTest.java

package com.ricky.java.junit.reflect;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		
		testMethod(Calculator.class);
		
//		testField(Calculator.class);
		
//		testAnnotation(Calculator.class);
	}
	
	public static void testAnnotation(Class<?> clazz) {
		
//		Annotation[] annotations = clazz.getAnnotations();
		Annotation[] annotations = clazz.getDeclaredAnnotations();
		if(annotations!=null){
			for (Annotation annotation : annotations) {
				
				System.out.println(annotation.annotationType());
			}
		}
	}
	
	public static void testField(Class<?> clazz) {
		
//		Field[] fields = clazz.getFields();
		Field[] fields = clazz.getDeclaredFields();
		if(fields!=null){
			for (Field field : fields) {
				System.out.println(field.getModifiers()+" "+field.getType()+" "+field.getName());
			}
		}
	}
	
	public static void testConstructor(Class<?> clazz) {
		
//		Constructor<?>[] constructors = clazz.getConstructors();
		Constructor<?>[] constructors = clazz.getDeclaredConstructors();
		
		if(constructors!=null){
			
			for (Constructor<?> constructor : constructors) {
				
				System.out.println(constructor.getName()+"**"+constructor.getParameterTypes());
			}
		}
	}

	public static void testMethod(Class<?> clazz) {
		
//		Method[] methods = clazz.getMethods();
		Method[] methods = clazz.getDeclaredMethods();
		if(methods!=null){
        	
        	for (Method method : methods) {
				
        		String methodName = method.getName();
        		Class<?>[] paramTypes = method.getParameterTypes();
        		
        		System.out.println("methodName="+methodName+"**params="+Arrays.toString(paramTypes));
        		
        		if("say".equals(methodName)){	//say 方法是 private类型的
        			try {
        				method.setAccessible(true);	//暴力破解
						Object result = method.invoke(clazz.newInstance(), new Object[]{"haha"});
						System.out.println(methodName + " invoke result="+result);
						
					} catch (IllegalArgumentException e) {
						e.printStackTrace();
					} catch (InvocationTargetException e) {
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						e.printStackTrace();
					} catch (InstantiationException e) {
						e.printStackTrace();
					}
        		}
			}
        }
	}

}

     此处，需要注意的是通过class.newInstance()来创建对象时，被创建的对象必须提供 默认的构造方法，否则会抛异常。

二 Java 内省

       内省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 name 属性，这就是默认的规则。 Java 中提供了一套 API 用来访问某个属性的 getter/setter 方法，这些 API 存放于包 java.beans 中。通过 Introspector 来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器（ PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，然后我们就可以通过反射机制来调用这些方法。

BeanInfo beanInfo = Introspector.getBeanInfo(beanClazz, Object. class);
			PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();

Introspector.getBeanInfo(Class<?> beanClass, Class<?> stopClass) 第二个参数表示一个停止点，这里我们给的是Object.class，表示向上找到Object就停止查找。

下面通过一个简单的示例来展示，首先是两个JavaBean类

Student.java

package com.ricky.java.junit.introspector;

import java.util.List;

public class Student {
	private int id;
	private String name;
	private int age;
	private List<String> tags;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public List<String> getTags() {
		return tags;
	}
	public void setTags(List<String> tags) {
		this.tags = tags;
	}
	
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age
				+ ", tags=" + tags + "]";
	}
	
}

Programer.java

package com.ricky.java.junit.introspector;

import java.util.List;

public class Programer {
	private int id;
	private String name;
	private int age;
	private List<Tag> tags;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public List<Tag> getTags() {
		return tags;
	}
	public void setTags(List<Tag> tags) {
		this.tags = tags;
	}
	
	@Override
	public String toString() {
		return "Programer [id=" + id + ", name=" + name + ", age=" + age
				+ ", tags=" + tags + "]";
	}
	
}

Tag.java

package com.ricky.java.junit.introspector;

public class Tag {
	private int id;
	private String name;
	private String desc;
	
	public Tag(){
		
	}
	
	public Tag(int id, String name, String desc) {
		this.id = id;
		this.name = name;
		this.desc = desc;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getDesc() {
		return desc;
	}
	public void setDesc(String desc) {
		this.desc = desc;
	}
	
	@Override
	public String toString() {
		return "Tag [id=" + id + ", name=" + name + ", desc=" + desc + "]";
	}
	
}

然后这里模拟一下在 Java Web框架中比较常见的 FormBean实现，代码如下：

package com.ricky.java.junit.introspector;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class IntrospectorTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

//		test(Student.class);
		
//		testStudentBean();
		
		testProgramerBean();
	}
	
	public static void testProgramerBean() {
		
		Map<String,Object> params = new HashMap<>();
		params.put("id", 1);
		params.put("name", "ricky");
		params.put("age", 25);
		params.put("tags", Arrays.asList(new Tag(1, "programer", "programer man"),new Tag(2, "IT", "IT"),new Tag(3, "Geek", "Geek man")));
		
		Programer programer = getBean(Programer.class, params);
		System.out.println("programer="+programer);
	}
	
	public static void testStudentBean() {
		
		Map<String,Object> params = new HashMap<>();
		params.put("id", 1);
		params.put("name", "ricky");
		params.put("age", 25);
		params.put("tags", Arrays.asList("student","80","IT","geek"));
		
		Student stu = getBean(Student.class, params);
		System.out.println("stu="+stu);
	}

	/**
	 * 模拟 Web框架中的 FormBean 实现
	 * @param beanClazz
	 * @param params
	 * @return
	 */
	public static <T> T getBean(Class<T> beanClazz,Map<String,Object> params){
		
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(beanClazz, Object.class);
			PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
	        
			if(props!=null){
				
				T bean = beanClazz.newInstance();
				for (PropertyDescriptor prop : props) {
					
					System.out.println("prop name="+prop.getName()+" value="+params.get(prop.getName()));
					
					Method method = prop.getWriteMethod();
					method.invoke(bean, new Object[]{params.get(prop.getName())});
				}
				
				return bean;
			}
			
		} catch (IntrospectionException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		} 
		
		return null;
	}
	
	public static void test(Class<?> clazz){
		
		try {
			BeanInfo beanInfo = Introspector.getBeanInfo(clazz, Object.class);
			PropertyDescriptor[] props = beanInfo.getPropertyDescriptors();
	        
			if(props!=null){
				for (PropertyDescriptor prop : props) {
					
					System.out.println("name="+prop.getName()+"**type="+prop.getPropertyType()+"**r="+prop.getReadMethod()+"**w="+prop.getWriteMethod());
					
				}
			}
			
		} catch (IntrospectionException e) {
			e.printStackTrace();
		} 
	}

}

运行结果如下：

prop name=age value=25
prop name=id value=1
prop name=name value=ricky
prop name=tags value=[Tag [id=1, name=programer, desc=programer man], Tag [id=2, name=IT, desc=IT], Tag [id=3, name=Geek, desc=Geek man]]
programer=Programer [id=1, name=ricky, age=25, tags=[Tag [id=1, name=programer, desc=programer man], Tag [id=2, name=IT, desc=IT], Tag [id=3, name=Geek, desc=Geek man]]]