Java反射机制浅析

package com.alfred.main;

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

public class Reflection {

    /**
     * 打印整个类的结构(包括父子类接口)
     * @param c Class对象
     */
    public static void printClassStructure(Class c) {
        try {
            // 获取所有的属性(不包括父类的)
            Field[] fs = c.getDeclaredFields();

            // 定义可变长的字符串，用来存储属性
            StringBuffer sb = new StringBuffer();
            // 通过追加的方法，将每个属性拼接到此字符串中
            // 最外边的public定义
            sb.append(Modifier.toString(c.getModifiers()) + " class "
                    + c.getSimpleName());
            Class superclass = c.getSuperclass();
            if (superclass != null && !superclass.getSimpleName().equals("Object")) {
                // 不是直接继承于Object，说明有其他继承类
                printClassStructure(superclass);
                sb.append(" extends " + superclass.getSimpleName());
            }
            Class[] interfaces = c.getInterfaces();
            if (interfaces.length > 0) {
                sb.append(" implements ");
                for (int i = 0; i < interfaces.length; i++) {
                    printClassStructure(interfaces[i]);
                    sb.append(((i != 0) ? "," : "")
                            + interfaces[i].getSimpleName());
                }
            }
            sb.append("{\n");

            // 类中的属性
            for (Field field : fs) {
                sb.append("\t");// 缩进
                sb.append(Modifier.toString(field.getModifiers()) + " ");// 获得属性的修饰符，例如public,static等等
                sb.append(field.getType().getSimpleName() + " ");
                sb.append(field.getName() + ";\n");
            }

            // 类中的构造方法
            Constructor[] declaredConstructors = c.getDeclaredConstructors();
            for (Constructor constructor : declaredConstructors) {
                sb.append("\t");
                sb.append(Modifier.toString(constructor.getModifiers()) + " ");
                sb.append(c.getSimpleName() + "(");
                Class[] parameterTypes = constructor.getParameterTypes();
                for (int i = 0; i < parameterTypes.length; i++) {
                    sb.append(((i != 0) ? "," : "")
                            + parameterTypes[i].getSimpleName() + " arg" + i);
                }
                sb.append("){}\n");
            }

            // 类中的方法
            Method[] ms = c.getDeclaredMethods();
            for (Method method : ms) {
                sb.append("\t");
                sb.append(Modifier.toString(method.getModifiers()) + " ");
                sb.append(method.getReturnType().getSimpleName() + " ");
                sb.append(method.getName() + "(");
                Class<?>[] parameterTypes = method.getParameterTypes();
                for (int i = 0; i < parameterTypes.length; i++) {
                    sb.append(((i != 0) ? "," : "")
                            + parameterTypes[i].getSimpleName() + " arg" + i);
                }
                sb.append("){}\n");
            }

            sb.append("}");

            System.out.println(sb);
            System.out.println("=================================");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 得到某个对象的公共属性
     * @param owner
     * @param fieldName
     * @return 该属性对象
     * @throws Exception
     */
    public static Object getProperty(Object owner, String fieldName)
            throws Exception {
        Class ownerClass = owner.getClass();
        Field field = ownerClass.getDeclaredField(fieldName);
        Object property = field.get(owner);
        return property;
    }

    /**
     * 得到某类的静态公共属性
     * @param className 类名
     * @param fieldName 属性名
     * @return 该属性对象
     * @throws Exception
     */
    public static 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 static 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[i] = args[i].getClass();
        }
        Method method = ownerClass.getMethod(methodName, argsClass);
        return method.invoke(owner, args);
    }

    /**
     * 执行某类的静态方法
     * @param className 类名
     * @param methodName 方法名
     * @param args 参数数组
     * @return 执行方法返回的结果
     * @throws Exception
     */
    public static 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[i] = args[i].getClass();
        }
        Method method = ownerClass.getMethod(methodName, argsClass);
        return method.invoke(null, args);
    }

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

    /**
     * 是不是某个类的实例
     * @param obj 实例
     * @param cls 类
     * @return 如果 obj 是此类的实例，则返回 true
     */
    public static boolean isInstance(Object obj, Class cls) {
        return cls.isInstance(obj);
    }

    /**
     * 得到数组中的某个元素
     * @param array 数组
     * @param index 索引
     * @return 返回指定数组对象中索引组件的值
     */
    public static Object getByArray(Object array, int index) {
        return Array.get(array, index);
    }

}