Java中的反射使用

旧城等待， 2022-03-12 02:58 298阅读 0赞

# Java反射 #

> 说到Java中的反射使用，大家肯定不陌生，但是在真正使用的时候却犯了难。因为不经常使用的关系，当真正需要使用反射的时候却经常忘记该怎么写了，真的是非常尴尬…

为此，我特地分类整理了一些常用的反射使用方法，以方便大家使用。[点击查看项目源码][Link 1]

## 反射设置属性 ##

### 反射设置某个对象的成员属性 ###

/**
     * 反射设置某个对象的成员属性
     *
     * @param owner     对象
     * @param fieldName 属性名
     * @param value     属性值
     * @return
     * @throws Exception
     */
    public static void setField(Object owner, String fieldName, Object value)
            throws Exception {
        Class<?> ownerClass = owner.getClass();
        Field field = ownerClass.getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(owner, value);
    }

### 反射设置某个类的静态属性 ###

/**
     * 反射设置某个类的静态属性
     *
     * @param className 类名
     * @param fieldName 属性名
     * @param value     属性值
     * @return
     * @throws Exception
     */
    public static void setStaticField(String className, String fieldName, Object value)
            throws Exception {
        Class<?> ownerClass = Class.forName(className);
        Field field = ownerClass.getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(null, value);
    }
    
    /**
     * 反射设置某个类的静态属性
     *
     * @param clazz     类
     * @param fieldName 属性名
     * @param value     属性值
     * @return
     * @throws Exception
     */
    public static void setStaticField(Class<?> clazz, String fieldName, Object value)
            throws Exception {
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(null, value);
    }

--------------------

## 反射获取属性 ##

### 反射获取某个对象的成员属性 ###

/**
     * 反射获取某个对象的成员属性
     *
     * @param owner     对象
     * @param fieldName 属性名
     * @return
     * @throws Exception
     */
    public static Object getField(Object owner, String fieldName)
            throws Exception {
        Class<?> ownerClass = owner.getClass();
        Field field = ownerClass.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field.get(owner);
    }

### 反射获取某个类的静态属性 ###

/**
     * 反射获取某个类的静态属性
     *
     * @param className 类名
     * @param fieldName 属性名
     * @return
     * @throws Exception
     */
    public static Object getStaticField(String className, String fieldName)
            throws Exception {
        Class<?> ownerClass = Class.forName(className);
        Field field = ownerClass.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field.get(ownerClass);
    }
    
    /**
     * 反射获取某个类的静态属性
     *
     * @param clazz     类
     * @param fieldName 属性名
     * @return
     * @throws Exception
     */
    public static Object getStaticField(Class<?> clazz, String fieldName)
            throws Exception {
        Field field = clazz.getDeclaredField(fieldName);
        field.setAccessible(true);
        return field.get(clazz);
    }

--------------------

## 反射执行方法 ##

### 注意点 ###

*  对于我们封装的方法来说，当方法的参数类型是int、boolean、short等基础类型时，使用`getClass()`方法获取到的类型将是Integer、Boolean、Short等包装类，在调用getDeclaredMethod获取方法对象的时候就会抛异常NoSuchMethodException;
 *  如果调用的方法属于该对象的父类,那getDeclaredMethod就会抛异常NoSuchMethodException;

### 获取参数的类集合方法 ###

/**
     * 获取参数的类集合
     *
     * @param args
     * @return
     */
    private static Class<?>[] getClasses(Object... args) {
        Class<?>[] argsClass;
        if (args != null && args.length > 0) {
            argsClass = new Class[args.length];
            for (int i = 0, j = args.length; i < j; i++) {
                argsClass[i] = args[i].getClass();
            }
        } else {
            argsClass = new Class[0];
        }
        return argsClass;
    }

### 反射执行某对象的成员方法 ###

/**
     * 反射执行某对象的成员方法
     *
     * @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 = getClasses(args);
        Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
        method.setAccessible(true);
        return method.invoke(owner, args);
    }
    
    /**
     * 反射执行某对象的成员方法（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
     *
     * @param owner      对象
     * @param methodName 方法名
     * @param args       参数集合
     * @return
     * @throws Exception
     */
    public static Object invokeMethod(Object owner, String methodName,
                                      Class<?>[] argsClass, Object... args) throws Exception {
        Class<?> ownerClass = owner.getClass();
        Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
        method.setAccessible(true);
        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 = getClasses(args);
        Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
        method.setAccessible(true);
        return method.invoke(null, args);
    }
    
    /**
     * 反射执行某个类的静态方法
     *
     * @param clazz      类
     * @param methodName 方法名
     * @param args       参数集合
     * @return
     * @throws Exception
     */
    public static Object invokeStaticMethod(Class<?> clazz,
                                            String methodName, Object... args) throws Exception {
        Class<?>[] argsClass = getClasses(args);
        Method method = clazz.getDeclaredMethod(methodName, argsClass);
        method.setAccessible(true);
        return method.invoke(null, args);
    }
    
    /**
     * 反射执行某个类的静态方法（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
     *
     * @param className  类名
     * @param methodName 方法名
     * @param argsClass  参数类型的集合
     * @param args       参数集合
     * @return
     * @throws Exception
     */
    public static Object invokeStaticMethod(String className,
                                            String methodName, Class<?>[] argsClass, Object... args) throws Exception {
        Class<?> ownerClass = Class.forName(className);
        Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
        method.setAccessible(true);
        return method.invoke(null, args);
    }
    
    /**
     * 反射执行某个类的静态方法（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
     *
     * @param clazz      类
     * @param methodName 方法名
     * @param argsClass  参数类型的集合
     * @param args       参数集合
     * @return
     * @throws Exception
     */
    public static Object invokeStaticMethod(Class<?> clazz,
                                            String methodName, Class<?>[] argsClass, Object... args) throws Exception {
        Method method = clazz.getDeclaredMethod(methodName, argsClass);
        method.setAccessible(true);
        return method.invoke(null, args);
    }

--------------------

## 反射构建实例 ##

/**
     * 反射构建实例
     *
     * @param className 类名
     * @param args      构造函数的参数集合
     * @return
     * @throws Exception
     */
    public static Object newInstance(String className, Object... args)
            throws Exception {
        Class<?> newOneClass = Class.forName(className);
        Class<?>[] argsClass = getClasses(args);
        Constructor<?> cons = newOneClass.getDeclaredConstructor(argsClass);
        cons.setAccessible(true);
        return cons.newInstance(args);
    }
    
    /**
     * 反射构建实例
     *
     * @param clazz 类
     * @param args  构造函数的参数集合
     * @return
     * @throws Exception
     */
    public static <T> T newInstance(Class<T> clazz, Object... args)
            throws Exception {
        Class<?>[] argsClass = getClasses(args);
        Constructor<?> cons = clazz.getDeclaredConstructor(argsClass);
        cons.setAccessible(true);
        return (T) cons.newInstance(args);
    }
    
    /**
     * 反射构建实例（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
     *
     * @param className 类名
     * @param argsClass 参数类型的集合
     * @param args      构造函数的参数集合
     * @return
     * @throws Exception
     */
    public static Object newInstance(String className, Class<?>[] argsClass, Object... args)
            throws Exception {
        Class<?> newOneClass = Class.forName(className);
        Constructor<?> cons = newOneClass.getDeclaredConstructor(argsClass);
        cons.setAccessible(true);
        return cons.newInstance(args);
    }
    
    /**
     * 反射构建实例（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
     *
     * @param clazz     类
     * @param argsClass 参数类型的集合
     * @param args      构造函数的参数集合
     * @return
     * @throws Exception
     */
    public static <T> T newInstance(Class<T> clazz, Class<?>[] argsClass, Object... args)
            throws Exception {
        Constructor<?> cons = clazz.getDeclaredConstructor(argsClass);
        cons.setAccessible(true);
        return (T) cons.newInstance(args);
    }

--------------------

## 测试 ##

### 测试所需的类 ###

/**
     * 学生类
     *
     * @author xuexiang
     * @since 2019/3/4 下午8:36
     */
    public class Student {
    
        /**
         * 用于测试反射获取静态属性
         */
        private static long TotalNumber = 28;
    
        public int ID;
    
        /**
         * 用于测试反射获取成员属性
         */
        private String Name;
    
        private int Age = 20;
    
        private int Sex;
    
        private int Score;
    
        private Student() {
    
        }
    
        /**
         * 用于测试反射构建实例
         */
        private Student(int ID, String name) {
            this.ID = ID;
            Name = name;
        }
    
        public Student(int ID, String name, int age) {
            this.ID = ID;
            Name = name;
            Age = age;
        }
    
        public Student(int ID, String name, int age, int sex, int score) {
            this.ID = ID;
            Name = name;
            Age = age;
            Sex = sex;
            Score = score;
        }
    
        /**
         * 用于测试反射调用成员方法
         * @return
         */
        private String getName(Integer param) {
            return Name;
        }
    
        /**
         * 用于测试反射调用成员方法
         * @return
         */
        private Student setName(String name) {
            Name = name;
            return this;
        }
    
        /**
         * 用于测试反射调用静态方法
         * @return
         */
        private static long incrementTotalNumber(int number) {
            return TotalNumber + number;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "ID=" + ID +
                    ", Name='" + Name + '\'' +
                    ", Age=" + Age +
                    ", Sex=" + Sex +
                    ", Score=" + Score +
                    "}, TotalNumber=" + TotalNumber;
        }
    }
    
    /**
     * 继承了Student，用于测试"如果调用的方法属于该对象的父类,那getDeclaredMethod就会抛异常NoSuchMethodException"的问题
     *
     * @author xuexiang
     * @since 2019/3/4 下午10:12
     */
    public class GoodStudent extends Student {
    
        private int AchievementCount = 3;
    
    
        public GoodStudent(int ID, String name, int age, int sex, int score) {
            super(ID, name, age, sex, score);
        }
    
        public GoodStudent(Student student) {
            super(student.ID + 1, "xxxx", 22);
        }
    
        public int getAchievementCount() {
            return AchievementCount;
        }
    
        public GoodStudent setAchievementCount(int achievementCount) {
            AchievementCount = achievementCount;
            return this;
        }
    }

### 测试方法 ###

/**
     * 测试
     *
     * @param args
     */
    public static void main(String[] args) {
        Student student = new Student(123, "xxxxxx", 25, 0, 100);
        System.out.println(student);
    
        System.out.println("--------测试反射属性设置------------");
        //反射设置某个对象的成员属性
        try {
            ReflectionUtils.setField(student, "Name", "xuexiang");
        } catch (Exception e) {
            e.printStackTrace();
        }
        //反射设置某个对象的静态属性
        try {
            ReflectionUtils.setStaticField(Student.class, "TotalNumber", 1111);
        } catch (Exception e) {
            e.printStackTrace();
        }
    
        System.out.println("--------测试反射属性获取------------");
        //反射获取某个对象的成员属性
        try {
            System.out.println("Name:" + ReflectionUtils.getField(student, "Name"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        //反射获取某个对象的静态属性
        try {
            System.out.println("TotalNumber:" + ReflectionUtils.getStaticField(Student.class, "TotalNumber"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    
        System.out.println("--------测试反射方法执行------------");
        //反射执行某对象的成员方法
        try {
            System.out.println("getName():" + ReflectionUtils.invokeMethod(student, "getName", 23));
        } catch (Exception e) {
            e.printStackTrace();
        }
    
    //        //反射执行某对象父类的成员方法（将会出错）
    //        try {
    //            GoodStudent goodStudent = new GoodStudent(student);
    //            System.out.println("getName():" + ReflectionUtils.invokeMethod(goodStudent, "getName", 23));
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
    
        //反射执行某个类的静态方法
        try {
            //对于参数是基础类型的方法，反射时用getClass获取的是包装类型，所以需要传入参数的类数组
            System.out.println("incrementTotalNumber():" + ReflectionUtils.invokeStaticMethod(Student.class, "incrementTotalNumber", new Class[]{int.class}, 2));
        } catch (Exception e) {
            e.printStackTrace();
        }
    
        System.out.println("--------测试反射构建实例------------");
        //反射构建实例
        try {
            Student student1 = ReflectionUtils.newInstance(Student.class, new Class[]{int.class, String.class}, 22334455, "xuexiangjys");
            System.out.println(student1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    
    //        //反射父类的构造方法构建实例（将会出错）
    //        try {
    //            GoodStudent student2 = ReflectionUtils.newInstance(GoodStudent.class, new Class[]{int.class, String.class}, 22334455, "xuexiangjys");
    //            System.out.println(student2);
    //        } catch (Exception e) {
    //            e.printStackTrace();
    //        }
    
    }

--------------------

## 联系方式 ##

[![E7_82_B9_E5_87_BB_E4_B8_80_E9_94_AE_E5_8A_A0_E5_85_A5QQ_E4_BA_A4_E6_B5_81_E7_BE_A4-602082750-blue.svg][]][E7_82_B9_E5_87_BB_E4_B8_80_E9_94_AE_E5_8A_A0_E5_85_A5QQ_E4_BA_A4_E6_B5_81_E7_BE_A4-602082750-blue.svg 1]  
![在这里插入图片描述][20190116143126277.png]

## 微信公共号 ##

![在这里插入图片描述][20190116143230727.jpg]

[Link 1]: https://github.com/xuexiangjys/architect-java/tree/master/src/basic/reflection
[E7_82_B9_E5_87_BB_E4_B8_80_E9_94_AE_E5_8A_A0_E5_85_A5QQ_E4_BA_A4_E6_B5_81_E7_BE_A4-602082750-blue.svg]: https://img.shields.io/badge/%E7%82%B9%E5%87%BB%E4%B8%80%E9%94%AE%E5%8A%A0%E5%85%A5QQ%E4%BA%A4%E6%B5%81%E7%BE%A4-602082750-blue.svg
[E7_82_B9_E5_87_BB_E4_B8_80_E9_94_AE_E5_8A_A0_E5_85_A5QQ_E4_BA_A4_E6_B5_81_E7_BE_A4-602082750-blue.svg 1]: http://shang.qq.com/wpa/qunwpa?idkey=9922861ef85c19f1575aecea0e8680f60d9386080a97ed310c971ae074998887
[20190116143126277.png]: /images/20220312/b9763d06fa8649aa9019d0b3f9e616bb.png
[20190116143230727.jpg]: /images/20220312/3a3e5f8283ff4127b003a1ccdf992ef9.png