浅析JAVA反射（一）

Java Reflection (JAVA反射)  
Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。例如，使用它能获得 Java 类中各成员的名称并显示出来。
Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
JavaBean 是 reflection 的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过 reflection 动态的载入并取得 Java 组件(类) 的属性。

像Struts2.0 Hibernate Spring 都是利用了这一特性。

下面先看一个简单例子 打印一个类里面的属性和方法，代码比较简单，在这里久不解释了，运行一下看看结果就明白了。

1. import java.lang.reflect.Field;
2. import java.lang.reflect.Method;
3. import java.lang.reflect.Modifier;
5. public class Test {
6.     public static void main(String[] args) {
7.         show("java.util.Date");
8.     }
9.     /**
10.      * 打印一个类里面定义的属性和方法
11.      * @param className
12.      */
13.     @SuppressWarnings("unchecked")
14.     private static void show(String className) {
15.         try {
16.             Class c = Class.forName(className);
17.             //获取定义的属性
18.             Field[] fields = c.getDeclaredFields();
19.             System.out.println(className + " 类包含的属性有:");
20.             for (Field f : fields) {
21.                 int mod = f.getModifiers();
22.                 System.out.println(((mod == 0) ? ""
23.                         : (Modifier.toString(mod) + " "))
24.                         + getTypeName(f.getType()) + " " + f.getName());
25.             }
26.             System.out.println("------------------------------------------------");
27.             //获取定义的方法
28.             Method[] methods = c.getDeclaredMethods();
29.             System.out.println(className + " 类包含的方法有:");
30.             StringBuffer sb = new StringBuffer();
31.             for (Method m : methods) {
32.                 int mod = m.getModifiers();
33.                 if (mod != 0) {
34.                     //得到访问控制修饰符
35.                     sb.append(Modifier.toString(mod) + " ");
36.                 }
37.                 sb.append(getTypeName(m.getReturnType()) + " ");
38.                 sb.append(m.getName() + "(");
39.                 Class[] params = m.getParameterTypes();
40.                 for (int j = 0; j < params.length; j++) {
41.                     sb.append(getTypeName(params[j]));
42.                     if (j < (params.length - 1))
43.                         sb.append(",");
44.                 }
45.                 sb.append(")");
46.                 System.out.println(sb.toString());
47.                 sb.delete(0, sb.length());
48.             }
49.         } catch (Exception e) {
50.             e.printStackTrace();
51.         }
52.     }
54.     /**
55.      * 此方法来自java.lang.reflect.Field
56.      * @param type
57.      * @return
58.      */
59.     @SuppressWarnings("unchecked")
60.     private static String getTypeName(Class type) {
61.         if (type.isArray()) {//如果是数组类型
62.             try {
63.                 Class cl = type;
64.                 int dimensions = 0; //数组的维度
65.                 while (cl.isArray()) {
66.                     dimensions++;
67.                     cl = cl.getComponentType();
68.                 }
69.                 StringBuffer sb = new StringBuffer();
70.                 sb.append(cl.getName());
71.                 for (int i = 0; i < dimensions; i++) {
72.                     sb.append("[]");
73.                 }
74.                 return sb.toString();
75.             } catch (Throwable e) { /*FALLTHRU*/
76.             }
77.         }
78.         return type.getName();
79.     }
80. }
81. 
    

在制作这个例子的时候参考了java.lang.reflect.Method.toString() 方法 和java.lang.reflect.Field.toString()方法。

今天先来个简单的例子，下一篇将介绍如何利用反射机制。最常用的就是 从request 到pojo的属性拷贝，以及两个JavaBean之间的属性复制