反射都不会，还敢说自己会Java？

比眉伴天荒 2021-09-24 06:08 301阅读 0赞

### 文章目录 ###

*   *  一、反射机制
     *   *  1.1 框架
         *  1.2 什么是反射机制？
         *  1.3 反射的优点
     *  二、获取Class对象
     *  三、 Class对象的功能
     *   *  3.1 获取功能
         *  3.2 Field：成员变量
         *   *  3.2.1 测试的实体类
             *  3.2.2 测试getFields和getField(String name)方法
             *  3.2.3 测试 getDeclaredFields 和 getDeclaredField(String name)方法
         *  3.3 Constructor:构造方法
         *   *  3.3.1 修改测试的实体类
             *  3.3.2 测试获取构造函数的方法
         *  3.4 Method：方法对象
         *   *  3.4.1 修改测试的实体类
             *  3.4.2 测试获取成员方法的方法
         *  3.5 获取全类名
     *  四、反射机制的应用案例
     *   *  4.1 案例分析
         *   *  4.1.1 需求
             *  4.1.2 实现
             *  4.1.3 步骤
         *  4.2 代码实现
         *   *  4.2.1 需要的实体类
             *  4.2.2 编写配置文件
             *  4.2.3 实现框架
             *  4.2.4 修改配置文件，再次运行

## 一、反射机制 ##

### 1.1 框架 ###

在学习Java的路上，相信你一定使用过各种各样的框架。所谓的框架就是一个半成品软件，已经对基础的代码进行了封装并提供相应的API。在框架的基础上进行软件开发，可以简化编码。学习使用框架并不需要了解反射，但是如果想要自己写一个框架，那么就需要对反射机制有很深入的了解。

### 1.2 什么是反射机制？ ###

在程序运行状态中，对于任意一个类或对象，都能够获取到这个类的所有属性和方法（包括私有属性和方法），`这种动态获取信息以及动态调用对象方法的功能就称为反射机制`。简单来讲，**通过反射，类对我们是完全透明的，想要获取任何东西都可以**。

### 1.3 反射的优点 ###

可以在程序运行过程中，操作这些对象；  
可以解耦，提高程序的可扩展性。  
在学习反射以前，我们先来了解一下Java代码在计算机中所经历的三个阶段：

`Source源代码阶段`：java被编译成`*.class`字节码文件。  
`Class类对象阶段`：`.class字节码`文件被类加载器加载进内存，并将其封装成Class对象（用于在内存中描述字节码文件），Class对象将原字节码文件中的成员变量抽取出来封装成数组Field\[\]，将原字节码文件中的构造函数抽取出来封装成数组Construction\[\]，将成员方法封装成数组Method\[\]。当然Class类内不止这三个，还封装了很多，我们常用的就这三个。  
`RunTime运行时阶段`：使用new创建对象的过程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NtaWxlaGFwcGluZXNz_size_16_color_FFFFFF_t_70]

## 二、获取Class对象 ##

*  获取Class对象的三种方式  
    【Source源代码阶段】 Class.forName(“全类名”)：将字节码文件加载进内存，返回Class对象；  
    多用于配置文件，将类名定义在配置文件中，通过读取配置文件加载类。  
    【Class类对象阶段】 类名.class：通过类名的属性class获取；  
    多用于参数的传递  
    【Runtime运行时阶段】对象.getClass()：此方法是定义在Objec类中的方法，因此所有的类都会继承此方法。  
    多用于对象获取字节码的方式
 *  代码演示
    
        public class getClass { 
            public static void main(String[] args) throws Exception { 
            
                //方式一：Class.forName("全类名");
                Class class1 = Class.forName("zzuli.edu.cn.Person");   //Person自定义实体类
                System.out.println("class1 = " + class1);
        
                //方式二：类名.class
                Class class2 = Person.class;
                System.out.println("class2 = " + class2);
        
                //方式三：对象.getClass();
                Person person = new Person();
                Class class3 = person.getClass();
                System.out.println("class3 = " + class3);
        
                //比较三个对象
                System.out.println(class1 == class2);    //true
                System.out.println(class1 == class3);    //true
            }
        }
    
    运行结果：  
    ![在这里插入图片描述][2020050515045532.png]  
    通过上述比较三个对象的结果可以得出一个结论：`同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，无论通过哪一种方式获取的Class对象都是同一个`。

## 三、 Class对象的功能 ##

### 3.1 获取功能 ###

这里只写出一些常用的，具体可以参看jdk的帮助文档。

*  获取成员变量

Field[] getFields()          //获取所有public修饰的成员变量
    Field getField(String name)  //获取指定名称的public修饰的成员变量
    
    Field[] getDeclaredFields()  //获取所有的成员变量，不考虑修饰符
    Field getDeclaredField(String name)  //获取指定的成员变量，不考虑修饰符

*  获取构造方法

Constructor<?>[] getConstructors() //获取所有public修饰的构造函数
    Constructor<T> getConstructor(类<?>... parameterTypes)  //获取指定的public修饰的构造函数
    
    Constructor<?>[] getDeclaredConstructors()  //获取所有的构造函数，不考虑修饰符
    Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  //获取指定的构造函数，不考虑修饰符

*  获取成员方法

Method[] getMethods()           //获取所有public修饰的成员方法
    Method getMethod(String name, 类<?>... parameterTypes) //获取指定名称的public修饰的成员方法
    
    Method[] getDeclaredMethods()  //获取所有的成员方法，不考虑修饰符
    Method getDeclaredMethod(String name, 类<?>... parameterTypes) //获取指定名称的成员方法，不考虑修饰符

*  获取全类名

String getName()

### 3.2 Field：成员变量 ###

*  设置值 void set(Object obj, Object value)
 *  获取值 get(Object obj)
 *  忽略访问权限修饰符的安全检查 setAccessible(true):暴力反射

#### 3.2.1 测试的实体类 ####

import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    @Setter
    @Getter
    @ToString
    public class Person { 
    
        public String a;        //最大范围public
        protected String b;     //受保护类型
        String c;               //默认的访问权限
        private String d;       //私有类型
    
    }

#### 3.2.2 测试getFields和getField(String name)方法 ####

/** * 获取成员变量 * * Field[] getFields() * * Field getField(String name) * @throws Exception */
    public class reflectDemo1{ 
        public static void main(String[] args) throws Exception { 
        
            //获取Person的Class对象
            Class personClass = Person.class;
    
            //1、Field[] getFields()获取所有public修饰的成员变量
            Field[] fields = personClass.getFields();
            for(Field field : fields){ 
                System.out.println(field);
            }
    
            System.out.println("=============================");
    
            //2.Field getField(String name) 获取指定名称的public修饰的成员变量
            Field a = personClass.getField("a");
            //获取成员变量a的值 [也只能获取公有的，获取私有的或者不存在的字符会抛出异常]
            Person p = new Person();
            Object value = a.get(p);
            System.out.println("value = " + value);//因为在Person类中a没有赋值，所以为null
    
            //设置成员变量a的属性值
            a.set(p,"张三");
            System.out.println(p);
        }
    }

运行结果：  
![在这里插入图片描述][20200505145031456.png]

#### 3.2.3 测试 getDeclaredFields 和 getDeclaredField(String name)方法 ####

/** * Field[] getDeclaredFields() * Field getDeclaredField(String name) * @throws Exception */
    public class reflectDemo2 { 
        public static void main(String[] args) throws Exception { 
        
            //获取Person的Class对象
            Class personClass = Person.class;
    
            //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
            Field[] declaredFields = personClass.getDeclaredFields();
            for(Field filed : declaredFields){ 
                System.out.println(filed);
            }
    
            System.out.println("===================================");
    
            //Field getDeclaredField(String name) //获取指定的成员变量，不考虑修饰符
            Field d = personClass.getDeclaredField("d"); //private String d;
            Person p = new Person();
    
            //Object value1 = d.get(p); //如果直接获取会抛出异常，因为对于私有变量虽然能会获取到，但不能直接set和get，必须忽略访问权限修饰符的安全检查后才可以
            //System.out.println("value1 = " + value1); 
    
            //忽略访问权限修饰符的安全检查，又称为暴力反射
            d.setAccessible(true);
            Object value2 = d.get(p);
            System.out.println("value2 = " + value2);
        }
    }

运行结果：  
![在这里插入图片描述][20200505145112885.png]  
注意：如果没有忽略访问修饰符直接访问会抛出如下所示的异常  
![在这里插入图片描述][20200505145140794.png]

### 3.3 Constructor:构造方法 ###

创建对象：**T newInstance(Object… initargs)**  
注意：如果使用空参数构造方法创建对象，操作可以简化，直接使用Class对象的newInstance方法。

#### 3.3.1 修改测试的实体类 ####

import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    @Setter
    @Getter
    @ToString
    public class Person { 
    
        private String name;
        private Integer age;
    
        //无参构造函数
        public Person() { 
    
        }
        
        //单个参数的构造函数，且为私有构造方法
        private Person(String name){ 
        
        }
    
        //有参构造函数
        public Person(String name, Integer age) { 
            this.name = name;
            this.age = age;
        }
    }

#### 3.3.2 测试获取构造函数的方法 ####

/** * 获取构造方法 * Constructor<?>[] getConstructors() * Constructor<T> getConstructor(类<?>... parameterTypes) */
    public class reflectDemo3 { 
        public static void main(String[] args) throws Exception { 
    
            //获取Person的Class对象
            Class personClass = Person.class;
    
            //Constructor<?>[] getConstructors() //获取所有public修饰的构造函数
            Constructor[] constructors = personClass.getConstructors();
            for(Constructor constructor : constructors){    
                System.out.println(constructor);
            }
    
            System.out.println("==========================================");
    
            //获取无参构造函数 注意：Person类中必须要有无参的构造函数，不然抛出异常
            Constructor constructor1 = personClass.getConstructor(); 
            System.out.println("constructor1 = " + constructor1);
            //使用获取到的无参构造函数创建对象
            Object person1 = constructor1.newInstance();
            System.out.println("person1 = " + person1);
    
    
            System.out.println("==========================================");
    
            //获取有参的构造函数 //public Person(String name, Integer age) 参数类型顺序要与构造函数内一致，且参数类型为字节码文件类型
            Constructor constructor2 = personClass.getConstructor(String.class,Integer.class);
            System.out.println("constructor2 = " + constructor2);
            //使用获取到的有参构造函数创建对象
            Object person2 = constructor2.newInstance("zhangsan", 22);   //获取的是有参的构造方法，就必须要指定参数
            System.out.println(person2);
    
            System.out.println("=========================================");
    
            //对于一般的无参构造函数，我们都不会先获取无参构造器之后在进行初始化,而是直接调用Class类内的newInstance()方法
            Object person3 = personClass.newInstance();
            System.out.println("person3 = " + person3);
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NtaWxlaGFwcGluZXNz_size_16_color_FFFFFF_t_70 1]  
\*\*总结：\*\*如果使用无参构造方法创建对象，操作可以进行简化，直接使用Class对象的newInstance方法创建即可。

对于多出个Declared关键词的两个方法，与不带这个词的两个方法的对比，与之前3.2叙述的一样，getDeclaredConstructor方法可以获取到任何访问权限的构造器，而getConstructor方法只能获取public修饰的构造器，具体不再测试。此外在构造器的对象内也有setAccessible(true)方法，把它设置成true就可以操作了。

### 3.4 Method：方法对象 ###

执行方法：Object invoke(Object obj, Object… args)

#### 3.4.1 修改测试的实体类 ####

import lombok.Getter;
    import lombok.Setter;
    import lombok.ToString;
    
    @Setter
    @Getter
    @ToString
    public class Person { 
    
        private String name;
        private Integer age;
    
        //无参构造函数
        public Person() { 
    
        }
    
        //有参构造函数
        public Person(String name, Integer age) { 
            this.name = name;
            this.age = age;
        }
    
        //无参方法
        public void eat(){ 
            System.out.println("eat...");
        }
    
        //重载有参方法
        public void eat(String food){ 
            System.out.println("eat..."+food);
        }
    }

#### 3.4.2 测试获取成员方法的方法 ####

/** * 获取成员方法 * * Method[] getMethods() * * Method getMethod(String name, 类<?>... parameterTypes) */
    public class reflectDemo4 { 
        public static void main(String[] args) throws Exception { 
    
            //获取Person的Class对象
            Class personClass = Person.class;
    
            //获取指定名称的方法
            Method eat_method1 = personClass.getMethod("eat");
            //执行方法
            Person person = new Person();
            Object rtValue = eat_method1.invoke(person);//如果方法有返回值类型可以获取到，没有就为null
            //因为eat方法没有返回值，故输出null
            System.out.println("rtValue = " + rtValue);
    
            System.out.println("--------------------------------------------");
    
            //获取有参的函数，有两个参数：第一个参数为方法名，第二个参数是获取方法的参数类型的字节码文件
            Method eat_method2 = personClass.getMethod("eat", String.class);
            //执行方法
            eat_method2.invoke(person,"苹果");
    
            System.out.println("============================================");
    
            //获取方法列表
            Method[] methods = personClass.getMethods();
            for(Method method : methods){      //注意：获取到的方法不仅仅是Person类内自己的方法
                System.out.println(method);   //继承Object中的方法也会被获取到（当然前提是public修饰的）
            }
        }
    }

执行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NtaWxlaGFwcGluZXNz_size_16_color_FFFFFF_t_70 2]  
我们可以看出Person内的public方法都被打印出来了，此外Object中的public方法也都被打印出来了。

同之前的叙述一样，带有Declared关键字的方法这两个方法，可以获取到任意修饰符的方法。同样也提供了setAccessible(true)方法进行暴力反射。

`综上所述：在反射面前没有公有私有，都可以通过暴力反射解决`。

### 3.5 获取全类名 ###

getName()方法获取的类名是全类名（带有路径）

public class getNameDemo { 
        public static void main(String[] args) throws Exception { 
    
            //获取Person的Class对象
            Class personClass = Person.class;
            //获取全类名
            String className = personClass.getName();
            System.out.println(className);
        }
    }

运行结果：  
![在这里插入图片描述][20200505145517917.png]

## 四、反射机制的应用案例 ##

### 4.1 案例分析 ###

#### 4.1.1 需求 ####

写一个"框架"，在不改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中的任意方法。

#### 4.1.2 实现 ####

（1）配置文件  
（2）反射机制

#### 4.1.3 步骤 ####

（1）将需要创建的对象的全类名和需要执行的方法定义在配置文件中  
（2）在程序中加载读取配置文件  
（3）使用反射技术把类文件加载进内存  
（4）创建对象  
（5）执行方法

### 4.2 代码实现 ###

#### 4.2.1 需要的实体类 ####

(1)Person类

public class Person { 
        //无参方法
        public void eat(){ 
            System.out.println("eat...");
        }
    }

(2)Student类

public class Student { 
        //无参方法
        public void study(){ 
            System.out.println("I am a Student");
        }
    }

#### 4.2.2 编写配置文件 ####

className = zzuli.edu.cn.Person
    methodName = eat

#### 4.2.3 实现框架 ####

/** * 前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法 * 即：拒绝硬编码 */
    public class ReflectTest { 
        public static void main(String[] args) throws Exception { 
        
            //1.加载配置文件
            //1.1创建Properties对象
            Properties pro = new Properties();
            //1.2加载配置文件
            //1.2.1获取class目录下的配置文件(使用类加载器)
            ClassLoader classLoader = ReflectTest.class.getClassLoader();
            InputStream inputStream = classLoader.getResourceAsStream("pro.properties");
            pro.load(inputStream);
    
            //2.获取配置文件中定义的数据
            String className = pro.getProperty("className");
            String methodName = pro.getProperty("methodName");
    
            //3.加载该类进内存
            Class cls = Class.forName(className);
            //4.创建对象
            Object obj = cls.newInstance();
            //5.获取方法对象
            Method method = cls.getMethod(methodName);
            //6.执行方法
            method.invoke(obj);
        }
    }

运行结果：  
![在这里插入图片描述][20200505145743923.png]

#### 4.2.4 修改配置文件，再次运行 ####

//将配置文件内的信息修改为Student类及类内的study方法
    className = zzuli.edu.cn.Student
    methodName = study

运行结果：  
![在这里插入图片描述][20200505145811806.png]  
优点：对于框架来说，已经对基础的代码进行了封装并提供相应的API。在框架的基础上进行软件开发，可以简化编码。但如果我们使用传统的new形式来实例化，那么当类更改时我们就要修改Java代码，这是很繁琐的。修改Java代码以后我们还要进行重新编译、测试、发布等一系列的操作。而如果我们仅仅只是修改配置文件，而不需要修改Java代码就简单的多。此外使用反射还能达到解耦的效果，如果我们使用的是new这种形式进行对象的实例化。此时如果在项目的某一个小模块中我们的一个实例类丢失了，那么在编译期间就会报错，会导致整个项目无法启动。而对于反射创建对象Class.forName(“全类名”)这种形式，我们在编译期需要的仅仅只是一个字符串（全类名），在编译期不会报错，这样其他的模块就可以正常的运行，而不会因为一个模块的问题导致整个项目崩溃。

> 写博客是为了记住自己容易忘记的东西，另外也是对自己工作的总结，希望尽自己的努力，做到更好，大家一起努力进步！  
>   
> 如果有什么问题，欢迎大家一起探讨，代码如有问题，欢迎各位大神指正！  
>   
> 给自己的梦想添加一双翅膀，让它可以在天空中自由自在的飞翔！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NtaWxlaGFwcGluZXNz_size_16_color_FFFFFF_t_70]: /images/20210923/66d2fdef82d84ac38ce9a1801f4a6629.png
[2020050515045532.png]: /images/20210923/b7c6717cbc334fdca498478d6e055bed.png
[20200505145031456.png]: /images/20210923/3e3c43862e7546d5a7737ad2f78602c8.png
[20200505145112885.png]: /images/20210923/8b543906f44c4208bac8634a2f35062d.png
[20200505145140794.png]: /images/20210923/e9778b2ca0f8462cad1f9a85e4a80727.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NtaWxlaGFwcGluZXNz_size_16_color_FFFFFF_t_70 1]: /images/20210923/c52dedf497aa43a1b185747fd89815a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NtaWxlaGFwcGluZXNz_size_16_color_FFFFFF_t_70 2]: /images/20210923/d55441a978ed48579a815037b5e6336f.png
[20200505145517917.png]: /images/20210923/e3a5cf2086dc409d9a64612ff9a05588.png
[20200505145743923.png]: /images/20210923/cd538d9c153c43998d83ecc5a0a393f0.png
[20200505145811806.png]: /images/20210923/49f197b545b44782a971fead67a08ccb.png