Java反射机制那些事

向右看齐 2022-04-17 00:52 274阅读 0赞

## 前言 ##

前不久学习了反射机制，来总结下。

在此之前，回顾下java程序的编译运行过程，分为三个阶段：源码（.java文件）进过编译生成字节码文件（.class文件），然后jvm加载字节码文件执行程序（runtime）。

前两个步骤（编译阶段）是在硬盘上完成的，后一个步骤（运行阶段）是在内存中完成的，而中间这个衔接就是：jvm通过类加载器----ClassLoader把硬盘中的class文件加载到内存中生成一个Class类的对象，这样就可以使用这个类中的成员变量和方法。一个类默认只会被加载一次，所以这个类对应的Class对象有且仅有一个。

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

1983年Smith首次提出反射这个概念，主要指程序可以访问、检测和修改他本身状态或行为的一种能力。

java反射机制是在运行状态中中对类进行解剖并操作类中的构造方法，成员方法，成员属性(主要用于框架中)，这种动态获取信息以及动态调用对象的方法的功能称为java语言的反射机制。

## Class对象和反射机制的联系。 ##

了解了反射机制的概念，那么可见要想利用java反射机制做一些事，那么就要利用Class对象，所以说Class对象是反射的前提。

那么，怎么获取Class对象？

## java中有三种方式获取Class对象： ##

1. 类名.class

2. 对象名.gerClass

3. Class.forName("全限定名（包名 + 类名）");

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODgxNjA4NA_size_16_color_FFFFFF_t_70][] 获取Class对象

>  补充：Class对象分两种
> 
> 1.普通Class对象：基于 引用类型
> 
> 2.预定义(在jvm中的)Class对象：基于 基本类型 和 void

## 反射机制的几种作用： ##

1.  在运行时判断任意一个对象所属的类
2.  在运行时构造任意一个类的对象
3.  在运行时判断任意一个类所具有的成员变量和方法
4.  在运行时调用任意一个对象的方法

先准备一个类：

package com.test.demo;
    
    public class Student {
        public String name;
        private int age;
    
        public Student() {
        }
    
        private Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public void show(String msg){
            System.out.println("show方法 = " + msg);
        }
        private void speak(String msg,int number){
            System.out.println("speak方法 = " + msg +":"+ number );
        }
    
    @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

## 反射的使用1：构造器（Constructor）的反射 ##

再次之前，我们可以通过公共的空参构造new一个Student，但是无法new私有的满参构造。

Student student = new Student();

现在来反射构造构造器（反射的形式创建实例）

public static void main(String[] args)
                throws NoSuchMethodException, IllegalAccessException,
                InvocationTargetException, InstantiationException {
            //获取Class对象
            Class<?> clazz = Student.class;
            /*
                根据参数类型获取相应的构造器
                参数类型是形参类型
             */
            Constructor<?> constructor = clazz.getConstructor();
            /*
                创建实例
                参数类型是实参类型（形参一一对应）
             */
            Object obj = constructor.newInstance();
            System.out.println("obj = " + obj);
    }

这样获取到的Student对象和new出来的空参构造器new出来的对象效果一样的（实际业务开发并没有意义）。

前者通过new创建出来对象的方式相比用反射创建的对象更被动，前者 是被new出来的，而用反射，是自己创建自己（对象），构造方法反客为主。

还有一种方式，就是直接通过Class对象创建构造器：

public static void main(String[] args)
                throws  IllegalAccessException, InstantiationException {
            //获取Class对象
            Class<?> clazz = Student.class;
            /*
                默认调用空参构造创建一个实例
                jdk9中已过时
            */
            Object obj = clazz.newInstance();
            System.out.println("obj = " + obj);
        }

在Student类中 ，还有一个私有的构造器，正常方式下是不能通过私有构造器创建对象的。，但是反射可以做到：

public static void main(String[] args)
                throws NoSuchMethodException, IllegalAccessException,
                InvocationTargetException, InstantiationException {
            //获取Class对象
            Class<?> clazz = Student.class;
            /*
                获取构造
                因为权限是私有，但getConstructor()只能获取public修饰的方法
                getDeclaredConstructor():获取声明的方法。只要声明的就可以
             */
           Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);
           System.out.println("满参私有构造 ：" + constructor);
            /*
                私有构造，newInstance会产生非法访问异常：java.lang.IllegalAccessException
                所以要改变权限setAccessible() -->暴力反射
             */
            constructor.setAccessible(true);
           Object obj = constructor.newInstance("小明",20);
    
            System.out.println("obj = " + obj);
        }

以上就是利用反射来创建一个对象（反射构造器）。

## 反射的使用2：方法（Method）的反射 ##

接下来看看Student对象内两个方法的反射

我们之前（外部）使用方法，都是都是通过对象调用（非私有）方法，如果是静态方法就是类直接调用。

那么，使用反射调用（非私有）方法，该怎么做？

public static void main(String[] args)
                throws NoSuchMethodException, IllegalAccessException,
                InvocationTargetException {
            //获取Class对象
            Student student = new Student();
            Class<? extends Student> clazz = student.getClass();
            /*
                getMethod():获取Class对象里的方法
                参数一：方法名
                参数二：参数列表类型
             */
            Method show = clazz.getMethod("show", String.class);
            /*
                调用show方法需要对象和参数
                invoke()方法：调用的意思
                参数一：调用此方法的对象
                参数二：调用此方法需要传入的实参
             */
            show.invoke(student, "hello public show");
        }

>  反射可以理解为语言语法上的倒装句：
> 
> 我们平时写代码都是我（对象）去调用方法，这里就是：
> 
> **new Student().show("对象调用方法"); **    
> 
> 而在 **show.invoke(student, "hello public show");** 中，
> 
> show方法考虑的是谁来调用我，然后Student对象说，我来调用你（student作为参数）。

> 扩展：如果公共的show方法加上static关键字，会影响方法调用吗？
> 
> 提示：静态与对象无关.
> 
> 答：加上static关键字，普通代码即使不new对象也可以调用，这个大家都知道，那么，在**show.invoke(student, "hello public show");  **中参数1 写 null 也是不影响的，因为，show方法来自于 Student的Class对象。

接下来看看私有方法的反射如何实现？

ps: 反射通道的API都很有规律，可读性很强

public static void main(String[] args)
                throws NoSuchMethodException, IllegalAccessException,
                InvocationTargetException {
             //获取Class对象
            Student student = new Student();
            Class<? extends Student> clazz = student.getClass();
            /*
                getDeclaredMethod():获取Class对象里的声明过的方法(包括)
                参数一：方法名
                参数二：参数列表类型
             */
            Method speak = clazz.getDeclaredMethod("speak", String.class, int.class);
            //私有方法，暴力反射
            speak.setAccessible(true);
            /*
                调用show方法需要对象和参数
                invoke()方法：调用的意思
                参数一：调用此方法的对象
                参数二：调用此方法需要传入的实参
             */
            speak.invoke(student, "hello private speak",2018);
        }

## 反射的使用3：属性（Field）的反射 ##

在Student实体中有一个共有属性一个私有属性，我们可以通过对象来设置共有属性的值，那么通过反射如何实现所有属性的赋值？

先来看看共有属性name的赋值

public static void main(String[] args)
                throws ClassNotFoundException, NoSuchFieldException,
                IllegalAccessException, InstantiationException {
             //获取Class对象,参数全限定名
            Class<?> clazz = Class.forName("com.test.demo.Student");
            /*
                getField():通过属性名获取属性
             */
            Field name = clazz.getField("name");
            //获取对象
            Object obj = clazz.newInstance();
            /*
                设置一个值
                参数一：哪个对象的属性值
                参数二：参数
             */
            name.set(obj,"张三");
            System.out.println(obj);
        }

根据前面说的API，反射属性不难理解。

私有属性的反射也不难实现

public static void main(String[] args)
                throws ClassNotFoundException, NoSuchFieldException,
                IllegalAccessException, InstantiationException {
             //获取Class对象,参数全限定名
            Class<?> clazz = Class.forName("com.test.demo.Student");
            /*
                getDeclaredField():通过属性名获取（所有权限）属性
             */
            Field age = clazz.getDeclaredField("age");
            //暴力反射
            age.setAccessible(true);
            //创建对象
            Object obj = clazz.newInstance();
            /*
                设置一个值
                参数一：哪个对象的属性值
                参数二：参数
             */
            age.set(obj,20);
            System.out.println(obj);
        }

## 总结： ##

**使用java的反射机制，一般需要遵循三步：**

1.  获得你想操作类的Class对象
2.  通过第一步获得的Class对象去取得操作类的方法或是属性名
3.  操作第二步取得的方法或是属性

**那么反射到底有什么用？**

反射最主要还是运用在框架中，了解反射才更好的了解一些框架的原理。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODgxNjA4NA_size_16_color_FFFFFF_t_70]: /images/20220417/b90384ccbbc4429f9275cd6c6f6b5af5.png