Java反射机制

反射机制概念

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够动态调用它的任意一个方法和属性；这个动态获取信息以及动态调用对象的方法的功能称为Java语言的反射机制。

在Java的设计模式和流行框架中，反射机制被大量的使用，如果不深刻理解Java反射机制，是无法理解Java的设计模式或阅读流行框架底层代码的。

反射机制提供的功能

• 在运行时判断任意一个对象所属的类
• 在运行时构造任意一个类的对象
• 在运行时访问一个类所具有的成员变量
• 在运行时调用任意一个对象的方法
• 生成动态代理

反射实现的类

在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中。

1. Class类：封装了描述方法的Method，描述字段的Field，描述构造器的Constructor等属性。对于每个类，JRE都会为其保留一个不变的Class类型的对象
2. Field类：代表类的成员变量（成员变量也称为类的属性）
3. Method类：代表类的方法
4. Constructor类：代表类的构造方法

获取类的字节码对象

要想解剖一个类，必须要获取到该类的字节码文件对象。常用的获取Class对象的3中方式：使用Class类的静态方法、使用类的.class方法、使用对象的getClass()。

/**
 * 获取Class对象演示
 *
 * @author god-jiang
 * @date 2021/1/2 17:09
 */
public class Reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获取类的三种方法
        // 第一种 Class.forName("类名")（强烈推荐）
        Class c1 = Class.forName("java.lang.String");
        System.out.println("第一种方法获取的类：" + c1);

        // 第二种 类名.class
        Class c2 = String.class;
        System.out.println("第二种方法获取的类：" + c2);

        // 第三种 对象.getClass()
        String str = new String();
        Class c3 = str.getClass();
        System.out.println("第三种方法获取的类：" + c3);
    }
}

反射机制的运用

1、在运行时判断任意一个对象所属的类

/**
 * 反射的运用
 *
 * @author god-jiang
 * @date 2021/1/2 17:33
 */
public class Reflect {
    public static void main(String[] args) throws ClassNotFoundException {
        // 1、在运行时判断任意一个对象所属的类
        Class c1 = Class.forName("java.lang.String");
        String str = new String("god-jiang");
        Integer itr = 666;
        // 同一个类则返回true,否则返回false
        boolean instance1 = c1.isInstance(str);
        boolean instance2 = c1.isInstance(itr);
        System.out.println("运行时获取的对象c1是否属于String类：" + instance1);
        System.out.println("运行时获取的对象c1是否属于Integer类：" + instance2);
    }
}

2、在运行时构造任意一个类的对象

/**
 * 反射的运用
 *
 * @author god-jiang
 * @date 2021/1/2 17:33
 */
public class Reflect {
    public static void main(String[] args) throws Exception {
        // 2、在运行时构造任意一个类的对象
        Class c1 = Class.forName("java.lang.String");
        // 调用无参的构造器
        Object str1 = c1.newInstance();
        System.out.println(str1.hashCode());

        // 调用有参的构造器
        // 获取String类带一个String参数的构造器
        Constructor constructor = c1.getConstructor(String.class);
        Object str2 = constructor.newInstance("god-jiang");
        System.out.println(str2);
    }
}

3、在运行时访问类所具有的成员变量

package god.jiang;

/**
 * 演示的POJO
 *
 * @author god-jiang
 * @date 2020/1/2 18:31
 */
@Data
public class User {
    private String name;
    private Integer age;
    private String tag;
}

演示反射机制获取成员变量并且修改变量

/**
 * 反射的运用
 *
 * @author god-jiang
 * @date 2021/1/2 17:33
 */
public class Reflect {
    public static void main(String[] args) throws Exception {
        // 3、在运行时访问类所具有的成员变量
        Class c1 = Class.forName("god.jiang.User");

        // 实例化对象
        User user = (User) c1.newInstance();
        user.setName("god-jiang");
        user.setAge(18);
        user.setTag("god-jiang演示反射的运用");

        Field[] fields = c1.getDeclaredFields();
        for (Field field : fields) {
            // 获取private变量的访问权
            field.setAccessible(true);
            System.out.println("成员变量" + field.getName() + "的值为：" + field.get(user));
        }

        System.out.println("=====================================================");
        // 动态修改对象的值
        Field field = c1.getDeclaredField("name");
        field.setAccessible(true);
        field.set(user, "wuxijiang666");
        System.out.println("name的值修改后为：" + user.getName());
    }
}

4、在运行时调用对象所具有的方法

/**
 * 反射的运用
 *
 * @author god-jiang
 * @date 2021/1/2 17:33
 */
public class Reflect {
    public static void main(String[] args) throws Exception {
        // 4、在运行时调用对象所具有的方法
        Class c1 = Class.forName("java.lang.String");
        Object str = c1.getConstructor(String.class).newInstance("god-jiang");

        // 通过反射获取String类的indexOf方法
        Method indexOf = c1.getDeclaredMethod("indexOf", String.class);
        // 获取private的访问权
        indexOf.setAccessible(true);
        // 调用方法,获取'-'在“god-jiang”的位置
        Object invoke = indexOf.invoke(str, "-");
        System.out.println("获取'-'在“god-jiang”的位置为：" + invoke);
    }
}

反射的缺点

• 反射会额外消耗一些系统资源，因此如果不需要动态创建一个对象那就不要使用反射
• 反射调用方法可以忽略权限检查，因此可能会破坏封装性而导致安全问题

总结

反射是每个Java程序员都必定要掌握的一个知识点，只会CRUD的只能是初级程序员，而初级往中高级的途径中，必有反射机制这个门槛，希望每位Java程序员都能够迈过去，一步步成长和升级。

希望以上这篇Java反射机制对正在学习Java或者已经工作的程序猿有所帮助。