java之反射

 

什么是反射？通过利用字节码文件通过Class对象获取类中所有数据的方式就是反射。这种技术可以获取到任何定义的信息（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分，这就是的用途。下面说下Class对象。

创建Class对象

// 方式一
Class<?> clazz1 = Class.forName("cn.tedu.reflection.Student"); //参数是类的全路径

// 方式二    
Class<?> clazz2 = Student.class;

// 方式三     
Student s = new Student();
Class<?> clazz3 = s.getClass();

常用方法

获得包名、类名

• clazz.getPackage().getName()//包名
• clazz.getSimpleName()//类名
• clazz.getName()//完整类名

成员变量定义信息

• getFields()//获得所有公开的成员变量，包括继承的变量
• getDeclaredFields()//获得本类定义的成员变量，包括私有,不包括继承的变量
• getField(变量名)
• getDeclaredField(变量名)

构造方法定义信息

• getConstructor(参数类型列表)//获得公开的构造方法
• getConstructors()//获得所有公开的构造方法
• getDeclaredConstructors()//获得所有构造方法，包括私有
• getDeclaredConstructor(int.class, String.class)

方法定义信息

• getMethods()//获得所有可见的方法，包括继承的方法
• getMethod(方法名,参数类型列表)
• getDeclaredMethods()//获得本类定义的方法，包括私有,不包括继承的方法
• getDeclaredMethod(方法名, int.class, String.class)

反射新建实例

• c.newInstance();//执行无参构造
• c.newInstance(6, "abc");//执行有参构造
• c.getConstructor(int.class, String.class); //执行含参构造，获取构造方法

反射调用成员变量

• c.getDeclaredField(变量名); //获取变量
• c.setAccessible(true); //使私有成员允许访问
• f.set(实例, 值); //为指定实例的变量赋值，静态变量，第一参数给 null
• f.get(实例); //访问指定实例的变量的值，静态变量，第一参数给 null

反射调用成员方法

• Method m = c.getDeclaredMethod(方法名, 参数类型列表);
• m.setAccessible(true) ;//使私有方法允许被调用
• m.invoke(实例, 参数数据) ;//让指定的实例来执行该方法

 

封装的反射常用工具类

public class Reflections {

    /**
     * 通过forName方法获取Class对象
     * 
     * @param path 类的全路径
     * @return 指定全路径的类的Class对象
     */
    public static Class<?> forName(String path) {
        Class<?> clazz = null;
        try {
            clazz = Class.forName(path);
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            System.err.println("您输入路径不存在");
        }
        return clazz;
    }

    /**
     * 
     * @param obj 如果是字符串，就是类的全路径，按照类全路径创建Class对象 如果是对象，按照对象的 getclass()方法创建Class对象
     * @return Class对象
     */
    public static Class<?> getClass(Object obj) {
        Class<?> clazz = null;
        if (obj instanceof String) {
            clazz = forName((String) obj);
        } else {
            clazz = obj.getClass();
        }
        return clazz;
    }

    /**
     * 
     * @param para 传入创建Class对象的对象或路径
     * @return 传入对象或路径的无参构造函数
     */
    public static Constructor<?> getConstructor(Object obj) {
        Constructor<?> cons = null;
        try {
            cons = getClass(obj).getConstructor();
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("您传入的参数不对");
        }
        return cons;
    }

    /**
     * 
     * @param obj 传入的参数 可以是字符串，也可以是对象
     * @return 根据传入的参数返回本类中定义的构造方法，包括私有构造方法
     */
    public static Constructor<?>[] getDeclaredConstructor(Object obj) {
        Constructor<?>[] cons = null;
        try {
            cons = getClass(obj).getDeclaredConstructors();
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("您传入的参数不对");
        }
        return cons;
    }


    public static Method[] getMethods(Object obj, boolean isDeclared) {
        Class<?> clazz = getClass(obj);
        if (isDeclared) { // 获取本类定义的方法
            return clazz.getDeclaredMethods();
        } else {
            return clazz.getMethods();
        }
    }

    // 通过重载使用达到函数参数默认值的效果
    public static Method[] getMethods(Object obj) {
        return getMethods(obj, false);
    }


    /**
     * 
     * @param obj 传入的类全路径或对象
     * @param funcName  被调用的方法名
     * @param isDeclared 是否是本类中定义的方法
     * @return 返回传入类全路径或对象的实例化Object对象
     */
    public static Object invokeMethod(Object obj,String funcName, boolean isDeclared) {
        Class<?> clazz = getClass(obj);
        Method m = null;
        Object o = newInstance(obj);
            try {
                if(isDeclared) {
                    m = clazz.getDeclaredMethod(funcName);
                }else {
                    m = clazz.getMethod(funcName);
                }
                m.setAccessible(true);
                m.invoke(o);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } 
            return o;
        }
    


    /**
     * 
     * @param obj 传入参数字符串或对象
     * @return 返回参数对应的无参构造创建的实例
     */
    public static Object newInstance(Object obj) {
        Object instance = null;
        try {
            Constructor<?> cons = getConstructor(obj);
            instance = cons.newInstance();
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("实例化失败");
        } 
        return instance;
    }
    

    /**
     * 
     * @param obj 传入字符串或对象参数
     * @param isDeclared  是否是本类定义的
     * @return 返回参数对用的Class对象中的字段/属性
     */
    public static Field[] getFields(Object obj, boolean isDeclared) {
        Class<?> clazz = getClass(obj);
        if(isDeclared) {
            return clazz.getDeclaredFields();
        }else {            
            return clazz.getFields();
        }
    }
    
    // 重载实现参数默认值，方便使用
    public static Field[] getFields(Object obj) {
        return getFields(obj,false);
    }
    
    

    
    /**
     * 
     * @param obj 传入的类全路径或对象
     * @param fieldName 字段名称
     * @param isDecalred 是否是本类内定义的
     * @return 返回字段
     */
    public static Field getField(Object obj, String fieldName, boolean isDecalred) {
        Class<?> clazz = getClass(obj);
        Field field = null;
        try {
            if(isDecalred) {
                field = clazz.getDeclaredField(fieldName);
            }else {
                field = clazz.getField(fieldName);                                
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.err.println("字段获取失败");
        }
        return field;
    }
    
    // 重载实现参数默认值，方便使用
    public static Field getField(Object obj, String fieldName) {
        return getField(obj,fieldName,false);
    }
    
    
    /**
     * 
     * @param obj 传入的字符串或对象
     * @param fieldName  字段名字
     * @param fieldValue  字段属性
     * @param isDeclared  是否是本类中定义的（包括私有属性）
     */
    public static Object setField(Object obj, String fieldName,Object fieldValue, boolean isDeclared) {
        Field f = null;
        Object value = null;
        if(isDeclared) {
            f = getField("cn.tedu.reflection.Person","age",true);
        }else {
            f = getField("cn.tedu.reflection.Person","age");
        }
        Object instance = newInstance("cn.tedu.reflection.Person");
        f.setAccessible(true);
        try {
            f.set(instance, fieldValue);
            value = f.get(instance);
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
            System.out.println("设置失败");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("设置失败");            
        }
        return value;
    }
    
    // 重载实现参数默认值，方便使用
    public static Object setField(Object obj, String fieldName,Object fieldValue) {
        return setField(obj,fieldName,fieldValue,false);
    }
    
    
    
}