java 类反射机制

1.什么是反射？

JAVA反射机制是在 运行状态 中，对于 任意一个类 ，都能够 知道 这个类的 所有属性和方法 ；对于 任意一个对象 ，都能够 调用它 的 任意一个方法和属性 ；这种 动态获取的信息以及动态调用对象的方法的功能 称为Java语言的反射机制。
反射(Reflection)是Java程序开发语言的特征之一，它允许运行中的Java程序 对自身进行检查 ，也称 自审 ，并能直接操作程序的内部属性。例如，使用它能获得Java类中各成员的名称并显示出来。
Java的这一能力在实际应用中应用得很多，在其它的程序语言中根本就不存在这一特性。例如，Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。

JavaBean是类反射的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过类反射动态的载入并取得Java组件(类)的属性。后面学习的各种框架，基本上都会有反射的使用。

2.使用类反射的三个步骤：

例如：用于反射的类，如Method，可以在java.lang.reflect包中找到。使用这些类的时候必须要遵循三个步骤：

第一步：获得你想操作的类的java.lang.Class对象。在运行中的Java程序中，用java.lang.Class类来描述类和接口等。

第二步：调用诸如getDeclaredMethods的方法，取得该类中定义的所有方法的列表。

第三步：使用反射的API来操作这些信息。

[java]  view plain  copy

 

1. <pre name="code" class="html"><pre name="code" class="html"><span style="color:#ff6600;">Classc = Class.forName("java.lang.String");  
2. Methodms[]= c.getDeclaredMethods();  
3. System.out.println(ms[0].toString());</span>  

3.获取Class对象的三种方式 

• 通过对象的getClass方法进行获取。这种方式需要具体的类和该类的对象，以及调用getClass方法。

• 任何数据类型(包括基本数据类型)都具备着一个静态的属性class，通过它可直接获取到该类型对应的Class对象。这种方式要使用具体的类，然后调用类中的静态属性class完成，无需调用方法，性能更好。

• 通过Class.forName()方法获取。这种方式仅需使用类名，就可以获取该类的Class对象，更有利于扩展。

[java]  view plain  copy

 

1. </pre></div><pre>  

[html]  view plain  copy

 

1. <div><span style="color: rgb(204, 0, 0);"></span><pre name="code" class="java">package cn.hncu.reflect;  
2.   
3. import org.junit.Test;  
4.   
5. public class reflectGetClass {  
6.     public static void main(String[] args) {  
7.     //    getClassObj();  
8.         //getClassObj2();  
9.         getClassObj3();  
10.     }  
11.     @Test  
12.     public void test(){  
13.         Person p=new Person();  
14.         Object obj=(Object)p;  
15.         Class c=obj.getClass();//运行时多态，new谁调谁  
16.         System.out.println(c);  
17.   
18.         System.out.println(int.class);//int  
19.         System.out.println(Integer.class);//java.lang.Integer  
20.         System.out.println(Integer.TYPE);//int  
21.     }  
22.     private static void getClassObj3() {  
23.         try {  
24.             Class c=Class.forName("cn.hncu.reflect.Person");//3333用字符串(类名)---依赖于String类  
25.             System.out.println(c);  
26.         } catch (ClassNotFoundException e) {  
27.             e.printStackTrace();  
28.         }  
29.   
30.     }  
31.     //所有数据类型(包括基本数据类型)都有一个静态变量class  
32.     private static void getClassObj2() {  
33.         Class c=Person.class;//2222通过类名----依赖于Person类  
34.         System.out.println(c);  
35.     }  
36.   
37.     private static void getClassObj() {  
38.         Person p=new Person();//1111通过对象  
39.         Class c=p.getClass();  
40.         System.out.println(c);  
41.   
42.         Person p2=new Person();//1111通过对象  
43.         Class c2=p.getClass();  
44.         System.out.println(c2==c);//同一个类模板，所有对象是共享同一个类模板的  
45.   
46.     }  
47. }  

练习（模拟Java内省的功能）：

思路：定义一个Model类，里面所有的属性都是private的，然后为每个属性提供getter和setter方法；

再准备一个Map，map的key值都是类里面的属性字段的字符串表示，值任意。 

设计一个方法ObjectgetModel(Mapmap,Classcls)，传入一个包含所有值的Map，然后再传入Model类的class，那么返回Model类的实例，这个实例里面已经包含好了所有相关的数据。也就是把Map中的数据通过反射，设置回到Model类实例中。 

[html]  view plain  copy

 

1. package cn.hncu.reflect.myBeanUtil;  
2.   
3. import java.lang.reflect.Field;  
4. import java.lang.reflect.Method;  
5. import java.util.Map;  
6.   
7. public class MyBeanUtils {  
8.     public static Object populate(Class cls,Map<String, Object> map) throws ReflectiveOperationException, IllegalAccessException{  
9.         Object obj=null;  
10.         //1 用类反射new出对象  
11.         obj=cls.newInstance();  
12.         //2 再用类反射对新new的对象设置属性值(必须遵守Java设置规范)--即通过setter方法设置  
13.            //2.1遍历出所有该类声明的属性  
14.         Field flds[]=cls.getDeclaredFields();  
15.         for(Field fld:flds){  
16.             //获取该fld对象所代表的属性名  
17.             String fldName=fld.getName();  
18.              //根据属性名，到map中去读取数据，只有数据非空才需要给该属性设置值   
19.             Object value=map.get(fld.getName());//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。  
20.             if(value==null){  
21.                 System.out.println(fld.getName()+"的数据为空");  
22.             }else{  
23.                 //如果map中存在对应的属性数据，则由属性名得出它的setter方法的名字  
24.                 String methodName="set"+fldName.substring(0,1).toUpperCase()+fldName.substring(1);  
25.                  //根据方法名和参数的数据类型(其实就是属性的类型)，获得Method对象  
26.                 Method method=cls.getDeclaredMethod(methodName, fld.getType());  
27.                  //调用该method对象所代表的方法  
28.                 Object params[]=new Object[1];  
29.                 params[0]=value;  
30.                 method.invoke(obj, params);  
31.             }  
32.         }  
33.         return obj;  
34.     }  
35.     public static<T>  T populate2(Class<T> cls,Map<String, Object> map) throws ReflectiveOperationException, IllegalAccessException{  
36.         T obj=null;  
37.         //1 用类反射new出对象  
38.         obj=cls.newInstance();  
39.         //2 再用类反射对新new的对象设置属性值(必须遵守Java设置规范)--即通过setter方法设置  
40.            //2.1遍历出所有该类声明的属性  
41.         Field flds[]=cls.getDeclaredFields();  
42.         for(Field fld:flds){  
43.             //获取该fld对象所代表的属性名  
44.             String fldName=fld.getName();  
45.              //根据属性名，到map中去读取数据，只有数据非空才需要给该属性设置值   
46.             Object value=map.get(fld.getName());//返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。  
47.             if(value==null){  
48.                 System.out.println(fld.getName()+"的数据为空");  
49.             }else{  
50.                 //如果map中存在对应的属性数据，则由属性名得出它的setter方法的名字  
51.                 String methodName="set"+fldName.substring(0,1).toUpperCase()+fldName.substring(1);  
52.                  //根据方法名和参数的数据类型(其实就是属性的类型)，获得Method对象  
53.                 Method method=cls.getDeclaredMethod(methodName, fld.getType());  
54.                  //调用该method对象所代表的方法  
55.                 Object params[]=new Object[1];  
56.                 params[0]=value;  
57.                 method.invoke(obj, params);  
58.             }  
59.         }  
60.         return obj;  
61.     }  
62. }