详解 反射机制

反射机制，可能有的同学在学习本篇博文的内容之前，就久仰过大名。
因为，只要学习框架的知识，就必然会看到反射机制的应用。
那么，为什么反射机制这么受欢迎呢？
因为它功能十分强大。
至于为什么本人在次对反射机制赞不绝口，请看博文内容：

---

目录

• 类的加载
• 反射机制
  • 获取 class文件对象：
  • 获取 构造方法：
  • 获取 类的对象：
  • 获取成员变量：
  • 获取成员方法：
  • 反射运行配置文件内容：
  • 反射忽视泛型检查：
  • 反射机制设置某个对象的某个属性为指定的值：
• 动态代理

---

首先，本人先要来讲解下有关反射机制的一个很重要的知识点 —— 类的加载：

类的加载

请观看本人博文 —— 《详解 类的加载》

反射机制

概述：

JAVA反射机制是在运行状态中
对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意一个方法和属性；
这种动态获取类的信息以及动态调用对象的方法的功能称为java语言的反射机制
要想解剖一个类,必须先要获取到该类的字节码文件对象
而解剖使用的就是Class类中的方法，
所以先要获取到每一个字节码文件对应的Class类型的对象

---

获取 class文件对象：

获取 class文件对象的三种方式：

• Object类的getClass()方法
• 任何一个对象的 静态属性class
• Class类中静态方法forName()：
  public static Class forName(String className):
  className: 这个表示的是一个类对应的全类名(就是需要加上包名)

那么，本人来展示下这三种方式：
首先，本人给出一个含有两个成员、三种构造方法、三个方法的信息存储类：

package edu.youzg.about_reflact.core;

public class FanInfo {
    public String name;
    int age;

    public FanInfo() {
        System.out.println("执行类空参构造方法");
    }

    public FanInfo(String name) {
        this.name = name;
        System.out.println("执行类单参构造方法 === " + name);
    }

    private FanInfo(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("执行类双参私有参构造方法 === " + name + " === " + age);
    }

    public void test(){
        System.out.println("这是一个空参的test方法");
    }

    public void test1 (String name){
        System.out.println("这是一个空参的test方法" + name);
    }

    public void test2(String name,int age){
        System.out.println("两个参数的方法"+name+"==="+age);
    }


    private int test(String name, int age, double num) {
        System.out.println("私有的方法" + name + "===" + age + "===" + num);
        return 666;
    }
}

那么，现在，本人来展示下如何获取 class文件对象：

package edu.youzg.about_reflact.core;

public class Test {

    public static void main(String[] args) throws ClassNotFoundException {
        //如何获取一个类的字节码文件对象。
        //方式1 getClasss()
        Object obj = new Object();
        Class aClass = obj.getClass();
        Class aClass1 = obj.getClass();

        Object obj2 = new Object();
        Class aClass2 = obj2.getClass();

        System.out.println(aClass==aClass1);

        System.out.println(aClass1==aClass2);
        System.out.println("=================================");

        //方式2，每一个类，都有一个静态的 class 属性可以获取该类的字节码文件对象
        Class objectClass = Object.class;
        System.out.println(aClass2==objectClass);
        Class stringClass = String.class;

        System.out.println("=================================");

        //方式3：使用Class中的方法 传入一个类的全限定名来获取
        //全限定名：包名+类名 能够确保一个类的唯一性。org.westos.demo.MyTest  org.westos.demo2.MyTest
        //Class 类 描述字节码文件类型的。
        //static Class<?> forName (String className)
        //返回与带有给定字符串名的类或接口相关联的 Class 对象。

        Class fanClass = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        Class fanClass2 = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        System.out.println(fanClass == fanClass2);
    }

}

现在，本人来展示下运行结果：

---

获取 构造方法：

获取所有构造方法：

• public Constructor<?>[] getConstructors()：
  获取所有的构造方法，不包含私有的
• public Constructor<?>[] getDeclaredConstructors()：
  获取所有的构造方法 ，包括私有的

获取单个构造方法：

• public Constructor< T > getConstructor(Class<?>... parameterTypes)：
  获取单个的构造方法， 不包含私有的
• public Constructor< T > getDeclaredConstructor(Class<?>... parameterTypes)：
  获取单个的构造方法，包含私有的

那么，本人来展示下如何 获取构造方法：

package edu.youzg.about_reflact.core;

import java.lang.reflect.Constructor;

public class Test {

    public static void main(String[] args) throws Exception {
        //1.获取该类的字节码文件对象
        Class fanClass = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        //2.获取该类的空参构造方法对象
        Constructor constructor = fanClass.getConstructor();

        //使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
        Object obj = constructor.newInstance();
        System.out.println(obj);

        System.out.println("========================================");
        //我们之前也可以借助有参构造来创建对象。
        //我们采用反射的方式，来借助有参构造，创建该类对象。
        //获取一个参数的构造方法对象。
        Constructor constructor1 = fanClass.getConstructor(String.class);
        //使用构造方法对象中的方法来创建该类对象。
        FanInfo obj2 = (FanInfo) constructor1.newInstance("米斯达");
        System.out.println(obj2);

        System.out.println("========================================");
        //我们以前不能使用私有构造直接创建对象
        //下来我们采用反射的方式的方式，借助私有构造方法来创建出该类对象
        //获取出私有构造方法对象
        Constructor declaredConstructor = fanClass.getDeclaredConstructor(String.class, int.class);
        //通过私有的构造方法对象，调用他的方法来创建该类对象。
        //取消权限的语法检测
        declaredConstructor.setAccessible(true);
        Object obj7 = declaredConstructor.newInstance("波鲁纳雷夫", 30);
        System.out.println(obj7);
    }

}

现在，本人来展示下运行结果：

---

获取 类的对象：

获取 类的对象：

• public Object newInstance():
  根据调用这个方法的Constructor类对象，获得一个相应的对象

那么，本人来展示下如何 获取类的对象：

package edu.youzg.about_reflact.core;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class Test {

    public static void main(String[] args) throws Exception {
        //我们采用反射的方式，来创建一个类的对象。
        //1.获取该类的字节码文件对象
        Class fanClass = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        //2.获取空参的构造方法对象
        Constructor declaredConstructor = fanClass.getDeclaredConstructor();
        //3.调用 Constructor 中的方法来创建FanInfo的对象
        FanInfo fan = (FanInfo) declaredConstructor.newInstance();
        System.out.println(fan);

        System.out.println("===================================");
        //我们现在来通过双参构造方法来创建FanInfo的对象
        Constructor constructor = fanClass.getDeclaredConstructor(String.class, int.class);
        constructor.setAccessible(true);
        //设置权限
        fan = (FanInfo) constructor.newInstance("米斯达", 30);
        System.out.println(fan);

        System.out.println("===================================");
        //如果我们借助 空参 来创建对象，还有一个简便方法。

        Class fanClass2 = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        //不用去获取空参构造对象，在 Class 里面有一个方法，就能创建对象。
        FanInfo fan2 = (FanInfo) fanClass2.newInstance();
        System.out.println(fan2);
    }

}

那么，本人现在来展示下运行结果：

---

获取成员变量：

获取所有成员变量：

• public Field[] getFields()：
  获取所有的成员变量包含从父类继承过来的
• public Field[] getDeclaredFields()：
  获取所有的成员变量 包含私有的 也包含从父类继承过来的成员变量

获取单个成员变量：

• public Field getField(String name)
• public Field getDeclaredField(String name)

那么，本人来展示下如何 获取成员变量：

package edu.youzg.about_reflact.core;

import java.lang.reflect.Field;

public class Test {

    public static void main(String[] args) throws Exception {
        //对于成员变量 用 Field 这个类型来描述
        //1.获取该类的字节码文件对象
        Class fanClass = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        //2.获取该类的成员变量对象
        //2.1 获取该类中所有的字段对象数组
        //getFields() 获取所有的公共字段
        Field[] fields = fanClass.getFields();
        for (Field field : fields) {
            System.out.println(field.toString());
        }

        System.out.println("==================================");
        //获取所有字段对象，包括私有
        Field[] declaredFields = fanClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("===========================================================");
        //获取公共的单个字段对象
        Field name = fanClass.getField("name");//传入字段名称
        System.out.println(name);
        //获取非公共的单个字段对象。
        Field age = fanClass.getDeclaredField("age");
        System.out.println(age);
    }

}

那么，本人现在来展示下运行结果：

---

获取成员方法：

获取所有成员方法：

• public Method[] getMethods()：
  获取所有的公共的成员方法不包含私有的
  包含从父类继承过来的过来的公共方法
• public Method[] getDeclaredMethods()：
  获取自己的所有成员方法 包含私有的

获取单个成员方法：

//参数1: 方法名称 参数2:方法行参的class 对象

• public Method getMethod(String name,Class<?>... parameterTypes)：
  获取单个的方法 不包含私有的
• public Method getDeclaredMethod(String name,Class<?>... parameterTypes)：
  获取单个方法包括私有的

那么，本人现在来展示下 获取成员方法：

package edu.youzg.about_reflact.core;

import java.lang.reflect.Method;

public class Test {

    public static void main(String[] args) throws Exception {
        //我们采用反射的方式来调用方法执行。

        //1.获取该类的字节码文件对象
        Class<?> fanClass = Class.forName("edu.youzg.about_reflact.core.FanInfo");
        //2.获取空参的方法对象
        Method testMethod = fanClass.getMethod("test");
        //3.调用Method类中的 invoke() 方法，让test 调用执行
        Object obj = fanClass.newInstance();
        testMethod.invoke(obj); //参数1，类的对象，参数2，给方法的形参传递的实际的值

        System.out.println("================================");
        //调用两个参数的方法执行
        Method test1 = fanClass.getMethod("test1", String.class);
        //参数1，类的对象，参数2，给方法的形参传递的实际的值
        test1.invoke(obj, "米斯达");

        System.out.println("==================================");
        Method test2 = fanClass.getMethod("test2", String.class, int.class);
        test2.invoke(obj, "米斯达", 30);

        System.out.println("==================================");
        //以前的方式，你在外界new对象调用 私有方法是调用不到的。
        //我们通过反射来调用私有方法执行。
        Method test3 = fanClass.getDeclaredMethod("test3", String.class, int.class, double.class);
        //调用私有方法，取消私有的权限校验
        test3.setAccessible(true);
        Integer result = (Integer) test3.invoke(obj, "波鲁纳雷夫", 30, 66.6);
        System.out.println(result);
    }

}

那么，本人现在来展示下运行结果：

---

现在，本人要讲解一个非常常用的反射机制的应用场景 —— 通过反射运行配置文件内容：

反射运行配置文件内容：

在本人《详解 Properties类》博文中，曾讲过：Properties类可以将配置文件中的键值对读取出来。

那么，在这里，本人将通过反射机制，将从配置文件中读取出来的值，赋给类中相应成员：

本人直接来上代码：
首先，本人来给出一个多功能手机类：

package edu.youzg.about_reflact.core;

public class Phone {

    public Phone() {
    }
    
    public void game() {
        System.out.println("正在运行游戏");
    }
    
    public void music() {
        System.out.println("正在播放音乐");
    }

    public void call() {
        System.out.println("正在进行通话");
    }
    
}

现在，本人来展示下配置文件的信息：

className=edu.youzg.about_reflact.core.Phone
methodName=music

那么，现在，本人来展示下通过反射机制扫描配置文件，来调用目标方法：

package edu.youzg.about_reflact.core;

import java.io.FileReader;
import java.lang.reflect.Method;
import java.util.Properties;

public class Test {

    public static void main(String[] args) throws Exception {
        //加载配置文件
        //基于目标类开发
        Properties properties = new Properties();
        properties.load(new FileReader("./config.properties"));
        //1.获取该类的字节码文件对象
        Class clazz = Class.forName(properties.getProperty("className"));
        //2.通过反射来创建目标类对象
        Object obj = clazz.getDeclaredConstructor().newInstance();
        //3.调用目标类中的方法执行
        Method methodName = clazz.getMethod(properties.getProperty("methodName"));
        methodName.invoke(obj);
    }

}

那么，本人来展示下运行结果：

---

反射忽视泛型检查：

在本人博文《详解 泛型 与 自动拆装箱》中讲到过：

泛型仅在编译期有效，而反射机制是针对运行期的。
所以，我们若是通过反射机制去调用泛型的话，就会读取不到相应的类型，只会读取到Object类型，这就是我们所谓的 泛型擦除机制

那么，现在，本人就来展示下通过反射机制去调用一个集合时，可以存入不恰当的数据：

package edu.youzg.about_reflact.core;

import java.lang.reflect.Method;
import java.util.ArrayList;

public class Test {

    public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(666);
        list.add(374);
        list.add(251);
        // list.add("abc");
        //泛型，只在编译期有效，运行期就擦除了。
        //ArrayList.class
        Class aClass = list.getClass();
        //获取add()方法对象
        Method add = aClass.getMethod("add", Object.class);
        add.invoke(list,"abc");

        System.out.println(list);
    }

}

那么，本人来展示下运行结果：

可以看到，Integer类型的ArrayList，存入了字符串数据！

---

接下来，本人来通过反射机制给出一个工具类，以便我们能够直接对一个对象的某成员赋值：

反射机制设置某个对象的某个属性为指定的值：

首先，是这个工具类：

package edu.youzg.about_reflact.core;

import java.lang.reflect.Field;

public class AssignUtil {

    /* 此方法可将obj对象中名为propertyName的属性的值设置为value*/
    public static void setProperty(Object obj, String propertyName, Object value) throws NoSuchFieldException, IllegalAccessException {
        Class aClass = obj.getClass();
        Field declaredField = aClass.getDeclaredField(propertyName);
        declaredField.setAccessible(true); //取消private权限的检测
        declaredField.set(obj,value);
    }
}

现在，本人来给出一个测试类：

package edu.youzg.about_reflact.core;

public class Test {

    public static void main(String[] args) throws Exception {
        //通过反射写一个通用的设置某个对象的某个属性为指定的值
        FanInfo FanInfo = new FanInfo();
        AssignUtil.setProperty(FanInfo,"name","波鲁纳雷夫");
        AssignUtil.setProperty(FanInfo,"age",30);
        System.out.println(FanInfo.name);
        System.out.println(FanInfo.age);
    }

}

那么，现在，本人来展示下运行结果：

---

那么，现在，本人再来讲解一个有关反射机制的很重要的知识点 —— 动态代理：

动态代理

请观看本人博文—— 《详解 动态代理》

---