Java反射经典

这里有一个较为完整的反射例子，以java.util.Date为示例，当然还需要try catch环绕
Class cls=Class.forName("java.util.Date"); //通过类路径加载类到虚拟机，生成类对象，类加载器为默认加载器。
Constructor constructor= cls.getConstructor(long.class);//获得该类的一个含参数构造函数，要提供参数类模板对象
Method method=cls.getMethod("getTime", null);//获得该类的一个方法对象，此方法有一个long类型的返回值。此方法无参数，所以参数模板传入null
Field field= cls.getDeclaredField("fastTime");//获得该类的一个私有属性对象，该属性为long类型
Object obj=constructor.newInstance(10000000L);//通过构造函数对象构造一个该类的对象，参数为10000000L
Object times=field.get(obj);//获得该类的一个对象此私有属性的值。
Object times2=method.invoke(obj, null);//执行该对象的方法并得到一个返回值。

一直都在连JDBC中用到Class.forName()，当用到XML动态解析分派的时候遇到了Class名字符串无法作为Class名实例化的问题，寻寻觅觅终于找到一个解决的办法：
public class DynamicLoader{
    public static void main(String args[]) throws Exception{
        Class toRun = Class.forName(args[0]);
        String[] newArgs=scrubArgs(args);
        Method mainMethod = findMain(toRun);
        mainMethod.invoke(null,new Object[]{newArgs});
    }
    private static String[] scruArgs(String[],args){
        String[] toReturn = new String[args.length-1];
        for(int i=0;i               toReturn[i-1]=args[i].toLowerCase();
         }
        return toReturn;
    }
    private static Method findMain(Class clazz) throw Exception{
        Method[] method = class.getMethods();
        for(int i=0;i            if(method[i].getName().equals("main"))
               return method[i];
        }
        return null;
}
}
再来个简单的测试程序：
public class Echoit{
      public static void main(String args[]){
              for(int i=0;i                  System.out.println("Echo arg"+i+" = "+args[i]);
                }
           }
}
都编译之后
java DynamicLoader Echo ONE TWO THERE
就可以看到效果了，既动态载入Echo又给它传了三个参数：）


Java提供了一套机制来动态执行方法和构造方法，以及数组操作等，这套机制就叫——反射。反射机制是如今很多流行框架的实现基础，其中包括Spring、Hibernate等。原理性的问题不是本文的重点，接下来让我们在实例中学习这套精彩的机制。
1. 得到某个对象的属性
public Object getProperty(Object owner, String fieldName) throws Exception {    
Class ownerClass = owner.getClass();                                        
                                                                                
Field field = ownerClass.getField(fieldName);                              
                                                                                
Object property = field.get(owner);                                          
                                                                                
return property;                                                            
}                                                                              

Class ownerClass = owner.getClass()：得到该对象的Class。
Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。
Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。

2. 得到某个类的静态属性
public Object getStaticProperty(String className, String fieldName)    
         throws Exception {                                        
Class ownerClass = Class.forName(className);                      
                                                                    
Field field = ownerClass.getField(fieldName);                      
                                                                    
Object property = field.get(ownerClass);                        
                                                                    
return property;                                                
}                                                                      
Class ownerClass = Class.forName(className) ：首先得到这个类的Class。
Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。

3. 执行某对象的方法
public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
Class ownerClass = owner.getClass();
Class[] argsClass = new Class[args.length];
for (int i = 0, j = args.length; i < j; i++) {
       argsClass = args.getClass();
}    
Method method = ownerClass.getMethod(methodName, argsClass);    
return method.invoke(owner, args);    
}
Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。
3～6行：配置参数的Class数组，作为寻找Method的条件。
Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。
method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。

4. 执行某个类的静态方法
public Object invokeStaticMethod(String className, String methodName,          
         Object[] args) throws Exception {                                  
Class ownerClass = Class.forName(className);                              
                                                                              
Class[] argsClass = new Class[args.length];                                  
                                                                              
for (int i = 0, j = args.length; i < j; i++) {                              
       argsClass = args.getClass();                                    
}                                                                            
                                                                              
Method method = ownerClass.getMethod(methodName, argsClass);                
                                                                              
return method.invoke(null, args);                                          
}                                                                              
基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。

5. 新建实例
public Object newInstance(String className, Object[] args) throws Exception {    
Class newoneClass = Class.forName(className);                              
                                                                              
Class[] argsClass = new Class[args.length];                                  
                                                                              
for (int i = 0, j = args.length; i < j; i++) {                              
       argsClass = args.getClass();                                    
}                                                                            
                                                                              
Constructor cons = newoneClass.getConstructor(argsClass);                  
                                                                              
return cons.newInstance(args);                                              
                                                                              
}                                                                              
这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。
Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。
第6～第10行：得到参数的Class数组。
Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。
cons.newInstance(args)：新建实例。

6. 判断是否为某个类的实例
public boolean isInstance(Object obj, Class cls) {      
return cls.isInstance(obj);                        
}                                                      

7. 得到数组中的某个元素
public Object getByArray(Object array, int index) {      
return Array.get(array,index);                      
}
----------------------------------------------完整源码----------------------------------------------
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
* Java Reflection Cookbook
*
* @author Michael Lee
* @since 2006-8-23
* @version 0.1a
*/
public class Reflection {
/**
    * 得到某个对象的公共属性
    *
    * @param owner, fieldName
    * @return 该属性对象
    * @throws Exception
    *
    */
public Object getProperty(Object owner, String fieldName) throws Exception {
       Class ownerClass = owner.getClass();
       Field field = ownerClass.getField(fieldName);
       Object property = field.get(owner);
       return property;
}
/**
    * 得到某类的静态公共属性
    *
    * @param className 类名
    * @param fieldName 属性名
    * @return 该属性对象
    * @throws Exception
    */
public Object getStaticProperty(String className, String fieldName)
         throws Exception {
       Class ownerClass = Class.forName(className);
       Field field = ownerClass.getField(fieldName);
       Object property = field.get(ownerClass);
       return property;
}

/**
    * 执行某对象方法
    *
    * @param owner
    *          对象
    * @param methodName
    *          方法名
    * @param args
    *          参数
    * @return 方法返回值
    * @throws Exception
    */
public Object invokeMethod(Object owner, String methodName, Object[] args)
         throws Exception {
       Class ownerClass = owner.getClass();
       Class[] argsClass = new Class[args.length];
       for (int i = 0, j = args.length; i < j; i++) {
         argsClass = args.getClass();
       }
       Method method = ownerClass.getMethod(methodName, argsClass);
       return method.invoke(owner, args);
}

   /**
    * 执行某类的静态方法
    *
    * @param className
    *          类名
    * @param methodName
    *          方法名
    * @param args
    *          参数数组
    * @return 执行方法返回的结果
    * @throws Exception
    */
public Object invokeStaticMethod(String className, String methodName,
         Object[] args) throws Exception {
       Class ownerClass = Class.forName(className);
       Class[] argsClass = new Class[args.length];
       for (int i = 0, j = args.length; i < j; i++) {
         argsClass = args.getClass();
       }
       Method method = ownerClass.getMethod(methodName, argsClass);
       return method.invoke(null, args);
}

/**
    * 新建实例
    *
    * @param className
    *          类名
    * @param args
    *          构造函数的参数
    * @return 新建的实例
    * @throws Exception
    */
public Object newInstance(String className, Object[] args) throws Exception {
       Class newoneClass = Class.forName(className);
       Class[] argsClass = new Class[args.length];
       for (int i = 0, j = args.length; i < j; i++) {
         argsClass = args.getClass();
       }
       Constructor cons = newoneClass.getConstructor(argsClass);
       return cons.newInstance(args);
}

      
/**
    * 是不是某个类的实例
    * @param obj 实例
    * @param cls 类
    * @return 如果 obj 是此类的实例，则返回 true
    */
public boolean isInstance(Object obj, Class cls) {
       return cls.isInstance(obj);
}
      
/**
    * 得到数组中的某个元素
    * @param array 数组
    * @param index 索引
    * @return 返回指定数组对象中索引组件的值
    */
public Object getByArray(Object array, int index) {
       return Array.get(array,index);
}
}