一、反射机制是什么

1、Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。
2、Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

二、反射的作用

我先讲两个案例来说明反射的重要性

案例1、通过配置文件的全类名，调用该类方法

（1）、配置一个properties文件，也可以用xml来配置

class=com.zhao.reflectdemo.pojo.Cat
name=小白

（2）、写两个实体类

Cat类

// @Data是LomBok的注解，如果不熟悉的小伙伴，可以认为他可以自动生成get、set方法等等
@Data
public class Cat {
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;

    public void call(String name){
        this.name = name;
        System.out.println("猫儿：" + this.name + "在叫");
    }
}

Dog类

@Data
public class Dog {
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;

    public void call(String name){
        this.name = name;
        System.out.println("狗儿：" + this.name + "在叫");
    }
}

（3）、测试：

    // 尝试用正常方法从配置文件中通过获取权类名，然后调用该类的call()方法
	// @Test为junit的注解，一般用于单元测试，因为一个类只有一个main方法，这个注解就是让该方法可以达到main方法的作用
    @Test
    public void test() throws Exception{
        // 从 properties 取出数据
        Properties properties = new Properties();
        properties.load(new InputStreamReader(
                Files.newInputStream(Paths.get("src\\main\\resources\\application.properties")),
                StandardCharsets.UTF_8)); // 不要在意我写的文件方法路径
        String className = properties.getProperty("class"); //目前值为：com.zhao.reflectdemo.pojo.Cat
        String name = properties.getProperty("name"); //目前值为：小白
        properties.clone(); // 关闭流
        // 正常方法中我们可以通过全类名，new一个对象，调用该类的方法
        Cat cat = new com.zhao.reflectdemo.pojo.Cat();
        cat.call(name); // 输出：猫儿：小白在叫

        // 那不通过反射我们可以，可以得到对象，并输出call()方法吗
//        Cat cat2 = new className(); // 当然是不可以的 className 指向的是一个字符串，并非一个类，使用这里肯定是会报错的
//        cat2.call(dogName);

        // 所以我们的主角 Class类 反射登场了
        common(className,name);

        // 更改 className 为 Dog类 全类名，当然可以在properties文件中更改，我这里就简化一下，免得本文冗长
        className = "com.zhao.reflectdemo.pojo.Dog";
        common(className,name);
    }
    // 通用方法，我们就可以知道，调用同样的方法，通过反射机制，就可以等到不同结果
    // 最大的不同就是，我们只通过两个字符串就实现了两个对象的方法
    private void common(String className,String name) throws Exception{
        Class<?> animalClass = Class.forName(className); // 通过全类名 得到Class 对象
        Object o = animalClass.newInstance(); // 生成该Cat类的对象
        Method call = animalClass.getMethod("call",String.class); // 得到 Method 对象，这个里面就是存储的该类的方法，因为我写的带参，所以这里也带String类的参数
        call.invoke(o,name);
    }

（4）、结果：

案例2、通过反射更改现有对象的属性

（1）、使用Cat类，去掉@Data注解和任何方法

public class Cat {
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;
}

（2）、测试类：

    public void Test2() throws Exception {
        Cat cat = new Cat();
        common2(cat);
        System.out.println(cat);
    }
    private <T> void common2(T t) throws Exception{
        // 我这里直接塞的是对象了，对象也可以通过getClass方法，获取该对象的Class类
        Class<?> tClass = t.getClass(); // 通过泛型得到该类的Class对象
        Field[] fields = tClass.getDeclaredFields(); // 得到该类所有的属性（包括private）
        for (Field field : fields) {
            field.setAccessible(true); // 关闭验证，我们就可以操作私有属性（private）
            if (field.getType() == String.class) { // 如果获取到属性的类型是String
                String name = field.getName(); // 获取该 Class 类的属性名
                Object o = field.get(t); // 获取该类的该方法的值
                if (Objects.isNull(o)){ // 如果值是空的话
                    if (name.equals("name")) { // 如果获取到属性的名字是name
                        field.set(t,"大白"); // 设置name值为大白
                    }else {
                        field.set(t,""); // 设置属性值为 ""
                    }
                }
            }
        }
    }

（3）、结果：debug看一下，的确可以实现改熟悉的值

三、反射原理

1、编译

图解

Java文件与Class文件对比

2、类加载

图解

DeBug看一下

查看Class对象是否是唯一的

3、运行

四、使用反射

反射机制相关的重要的类

一、获取class对象的三种方法

Cat cat = new Cat();
Class<? extends Cat> class1 = cat.getClass();
Class<Cat> class2 = Cat.class;
Class<?> class3 = Class.forName("com.zhao.reflectdemo.pojo.Cat");
System.out.println(class1 == class2); //true
System.out.println(class1 == class3); //true
System.out.println(class2 == class3); //true

二、Class类

Class类常用的方法

三、反射获取方法（Method）

Method类

案例：

1、有个Cat类：

public class Cat {
    public void call(String name){
        System.out.println("cat的有参方法，参数：" + name);
    }
    public String call(){
        System.out.println("cat的无参方法");
        return "无参方法";
    }
    private String privatization(){
        System.out.println("cat的私有方法");
        return "私有方法";
    }
}

2、测试案例：

    @Test
    public void Test2() throws Exception {
        Class<Cat> catClass = Cat.class; // 获取Cat的class对象
        Cat cat = catClass.newInstance(); // 得到一个Cat对象，与 new Cat() 类似

        System.out.println("============获取单个非私有方法==================");
        Method method = catClass.getMethod("call"); // 获取单个非私有方法
        Object o = method.invoke(cat);
        System.out.println("method的返回值是" + o);
        Method method2 = catClass.getMethod("call",String.class); // 获取单个非私有方法，带参
        method2.invoke(cat, "随便");
//        Method method3 = catClass.getMethod("privatization"); // 获取单个私有方法 //会报错
//        method3.invoke(cat);

        // 由于数据里面的方法，包括Object类太多了，就不打印出来了，可以自己解开试一试
//        System.out.println("============获取多个非私有方法==================");
//        Method[] methods = catClass.getMethods(); // 获取多个非私有方法
//        for (Method method1 : methods) {
//            System.out.println("================for循环=============================");
//            // 获取修饰符列表
//            System.out.print("获取修饰符列表：");
//            System.out.println(method1.getModifiers());
//            // 获取方法的返回值类型
//            System.out.print("获取方法的返回值类型：");
//            System.out.println(method1.getReturnType().getSimpleName());
//            // 获取方法名
//            System.out.print("获取方法名：");
//            System.out.println(method1.getName());
//        }

        Method[] declaredMethods = catClass.getDeclaredMethods(); // 获取全部方法，包括私有
        System.out.println("============获取单个方法==================");
        Method declaredMethod = catClass.getDeclaredMethod("privatization"); //获取单个私有方法
        declaredMethod.setAccessible(true); // 关闭检查，这样才可以调用私有方法
        declaredMethod.invoke(cat);

    }

3、结果

四、反射获取字段（Field）

Field类

案例：

1、有个Cat类：

@Data
public class Cat {
        //相信以大家的聪明才智肯定能举一反三，使用我就直接全部私有化属性了
    private String name;
    private Integer age;
    private Date brith;
    private String character;
    // 以下随便取的字段
    private String a;
    private String b;
    private String c;
    private String d;
}

2、测试案例：

    @Test
    public void Test3() throws Exception{
        //相信以大家的聪明才智肯定能举一反三，使用我就直接全部私有化属性了
        Cat cat = new Cat();
        cat.setA("随便，随便拉");
        Class<?> tClass = cat.getClass(); // 通过泛型得到该类的Class对象
        Field[] fields = tClass.getDeclaredFields(); // 得到该类所有的属性（包括private）
        for (Field field : fields) {
            field.setAccessible(true); // 关闭验证，我们就可以操作私有属性（private）
            if (field.getType() == String.class) { // 如果获取到属性的类型是String
                String name = field.getName(); // 获取该 Class 类的属性名
                Object o = field.get(cat); // 获取该类的该方法的值
                if (Objects.isNull(o)){ // 如果值是空的话
                    if (name.equals("name")) { // 如果获取到属性的名字是name
                        field.set(cat,"大白"); // 设置name值为大白
                    }else {
                        field.set(cat,""); // 设置属性值为 ""
                    }
                }
            }
        }
        System.out.println(cat);
    }

3、Debug

五、反射获取构造函数（Constructor）

Constructor类

案例：

1、有个Cat类：

public class Cat {
    public String name;

    private Cat(){

    }
    public Cat(String name){ this.name = name;}
}

2、测试案例：

    @Test
    public void Test4() throws Exception{
        Class<Cat> catClass = Cat.class;
        Constructor<Cat> constructor = catClass.getConstructor(String.class); // 获取非私有的构造函数
        Cat cat1 = constructor.newInstance("名字是个啥");
        System.out.println(cat1.name);
        Constructor<Cat> declaredConstructor = catClass.getDeclaredConstructor(); // 获取构造函数
        declaredConstructor.setAccessible(true); // 私有的要关闭检验
        Cat cat2 = declaredConstructor.newInstance(); // 通过私有的构造函数，得到Cat对象
        System.out.println(cat2.name);
    }

3、结果