Java反射（原理剖析与使用）

冷不防 2023-09-27 00:29 71阅读 0赞

## 一、反射机制是什么 ##

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

## 二、反射的作用 ##

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

> 大家可以通过案例过个眼熟，只需看懂有什么用即可，关于反射的知识，我会再后面一一讲解

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

> 在众多都框架中使用到了反射，能动态的生成一个对象，并操作该对象的属性与方法，最经典的就是各种注解和Spring框架的AOP等等
> 
> 没有用到反射机制的时候，我们只能通过硬编码的方法更改代码中的逻辑，虽然这样的确是可行的
> 
> 但是对于一个超大的项目来说，这样的维护非常耗成本，并且框架就得不到通过配置动态的更新，框架就会变得累赘，Java 根本也就流行不起来

#### （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）、结果： ####

![在这里插入图片描述][a74a18c837df440db2bea7f7c934622e.png]

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

> 目前我们想用`案例1`中的`Cat类`，在初始化时，他的所有属性皆不是基本类型，所有默认初始值为`null`
> 
> 我们想获取该存在的类并改变它的名字（name属性）为：大白，其他字符从null，改为""
> 
> 如果不使用反射的话，我们就是一个个的通过set方法，改变该对象的属性，这样是可行的，但代码是不是会比较的冗长呢
> 
> 进阶：如果说该类的熟悉为private，且没有任何方法能改变属性呢。
> 
> 下面就一个通过案例解决上述问题

#### （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看一下，的确可以实现改熟悉的值 ####

![在这里插入图片描述][75cc6f3c0c174676a0061121dcdcff96.png]

## 三、反射原理 ##

> 要搞懂Java反射的原理，我们要从写好一个java文件，到编译成class文件，在通过类加载器加载到JVM的堆，加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造，形成每个对象对应的全局唯一的一个Class方法
> 
> 我就从Java程序计算机的三个阶段讲起：编译、类加载、运行

### 1、编译 ###

> 一个我们编写的java文件，这个文件时面向与程序员的，可以通过javaSE很直观明了的代码的逻辑，但是计算机是看不懂的，计算机只能识别强弱电信号，就是以二进制形式存在的二进制文件，所以我们需要通过编译得到class字节码文件，再由jvm转换为计算机可识别的二进制数据
> 
> 第一步，很简单就是通过javac命令，让java文件编译成class文件

#### 图解 ####

![在这里插入图片描述][734f4c6ba4814981a5a8ea3cbd50c3e3.png]

#### Java文件与Class文件对比 ####

![在这里插入图片描述][6d8e72cd06534908a736b29cb3bb7961.png]

### 2、类加载 ###

> 通过ClassLoader的defineClass 方法自动构造的，全局唯一的Class对象
> 
> 把他的所有的成员变量、构造方法、成员方法封装为Class类中的Field数组、Constructor数组、Method数组，这个数组里面存放的就是类中的成员变量、构造方法、成员方法等信息

#### 图解 ####

![在这里插入图片描述][a9f4c131ec5d4467ac758c2cbb7a5574.png]

#### DeBug看一下 ####

![在这里插入图片描述][36cd257253914b8faf5d322d43f40dc3.png]

#### 查看Class对象是否是唯一的 ####

![在这里插入图片描述][50a33545a5e84e7fa6afe5a3f32dab4d.png]

### 3、运行 ###

> 通过主方法运行 `Cat cat = new Cat()`代码时，会先找对应的Class对象信息，把信息加载到堆中，生成一个cat对象
> 
> Class对象，可以想象成一个镜子，镜子里面有类的各种信息，反射就是指，通过这面镜子拿到自己想要的信息

![在这里插入图片描述][07fd6f6582454491b84a4b9c7a37dca4.png]

## 四、使用反射 ##

> 反射类集中在`java.lang.reflect`包下面

### 反射机制相关的重要的类 ###

<table> 
 <thead> 
  <tr> 
   <th align="center">类</th> 
   <th align="center">含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">java.lang.Class</td> 
   <td align="center">代表整个字节码。代表一个类型，代表整个类。</td> 
  </tr> 
  <tr> 
   <td align="center">java.lang.reflect.Method</td> 
   <td align="center">代表字节码中的方法字节码。代表类中的方法。</td> 
  </tr> 
  <tr> 
   <td align="center">java.lang.reflect.Constructor</td> 
   <td align="center">代表字节码中的构造方法字节码。代表类中的构造方法。</td> 
  </tr> 
  <tr> 
   <td align="center">java.lang.reflect.Field</td> 
   <td align="center">代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。</td> 
  </tr> 
 </tbody> 
</table>

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

> 如果使用的类形同，那么获取的是同一个Class对象
> 
> class对象一般要配合Method、Constructor、Field对象来使用

<table> 
 <thead> 
  <tr> 
   <th align="center">方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">Class.forName(“全类名”)</td> 
  </tr> 
  <tr> 
   <td align="center">对象.getClass()</td> 
  </tr> 
  <tr> 
   <td align="center">类.class</td> 
  </tr> 
 </tbody> 
</table>

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类 ###

> 其实这个类取的名字是带有误解性的，因为他是的的确确存在与`java.lang`包下的一个类，与我上述讲解的class对象，不是一个东西，但又有千丝万缕的关系
> 
> Class 类没有公共构造方法。Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。

#### Class类常用的方法 ####

> 特别强调一下`newInstance()`方法，可以反射实例化对象

<table> 
 <thead> 
  <tr> 
   <th align="center">方法名</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">public T <strong>newInstance</strong>()</td> 
   <td align="center">创建对象</td> 
  </tr> 
  <tr> 
   <td align="center">public String <strong>getName</strong>()</td> 
   <td align="center">返回完整类名带包名</td> 
  </tr> 
  <tr> 
   <td align="center">public String <strong>getSimpleName</strong>()</td> 
   <td align="center">返回类名</td> 
  </tr> 
  <tr> 
   <td align="center">public Field[] <strong>getFields</strong>()</td> 
   <td align="center">返回类中public修饰的属性</td> 
  </tr> 
  <tr> 
   <td align="center">public Field[] <strong>getDeclaredFields</strong>()</td> 
   <td align="center">返回类中所有的属性</td> 
  </tr> 
  <tr> 
   <td align="center">public Field <strong>getDeclaredField</strong>(String name)</td> 
   <td align="center">根据属性名name获取指定的属性</td> 
  </tr> 
  <tr> 
   <td align="center">public native int <strong>getModifiers</strong>()</td> 
   <td align="center">获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合Modifier类的toString(int x)方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">ublic Method[] <strong>getDeclaredMethods</strong>()</td> 
   <td align="center">返回类中所有的实例方法</td> 
  </tr> 
  <tr> 
   <td align="center">public Method <strong>getDeclaredMethod</strong>(String name, Class&lt;?&gt;… parameterTypes)</td> 
   <td align="center">根据方法名name和方法形参获取指定方法</td> 
  </tr> 
  <tr> 
   <td align="center">public Constructor&lt;?&gt;[] <strong>getDeclaredConstructors</strong>()</td> 
   <td align="center">返回类中所有的构造方法</td> 
  </tr> 
  <tr> 
   <td align="center">public Constructor <strong>getDeclaredConstructor</strong>(Class&lt;?&gt;… parameterTypes)</td> 
   <td align="center">根据方法形参获取指定的构造方法</td> 
  </tr> 
  <tr> 
   <td align="center">public native Class&lt;? super T&gt; <strong>getSuperclass</strong>()</td> 
   <td align="center">返回调用类的父类</td> 
  </tr> 
  <tr> 
   <td align="center">public Class&lt;?&gt;[] <strong>getInterfaces</strong>()</td> 
   <td align="center">返回调用类实现的接口集合</td> 
  </tr> 
 </tbody> 
</table>

### 三、反射获取方法（Method） ###

#### Method类 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">方法名</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">public String <strong>getName</strong>()</td> 
   <td align="center">返回方法名</td> 
  </tr> 
  <tr> 
   <td align="center">public int <strong>getModifiers</strong>()</td> 
   <td align="center">获取方法的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合Modifier类的toString(int x)方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public Class&lt;?&gt; <strong>getReturnType</strong>()</td> 
   <td align="center">以Class类型，返回方法类型【一般配合Class类的getSimpleName()方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public Class&lt;?&gt;[] <strong>getParameterTypes</strong>()</td> 
   <td align="center">返回方法的修饰符列表（一个方法的参数可能会有多个。）【结果集一般配合Class类的getSimpleName()方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public Object <strong>invoke</strong>(Object obj, Object… args)</td> 
   <td align="center">调用方法</td> 
  </tr> 
 </tbody> 
</table>

#### 案例： ####

##### 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、结果 #####

![在这里插入图片描述][660c9cdf568e4535b5cadc048fe06620.png]

### 四、反射获取字段（Field） ###

#### Field类 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">方法名</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">public String <strong>getName</strong>()</td> 
   <td align="center">返回属性名</td> 
  </tr> 
  <tr> 
   <td align="center">public int <strong>getModifiers</strong>()</td> 
   <td align="center">获取属性的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合Modifier类的toString(int x)方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public Class&lt;?&gt; <strong>getType</strong>()</td> 
   <td align="center">以Class类型，返回属性类型【一般配合Class类的getSimpleName()方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public void <strong>set</strong>(Object obj, Object value)</td> 
   <td align="center">设置属性值</td> 
  </tr> 
  <tr> 
   <td align="center">public Object <strong>get</strong>(Object obj)</td> 
   <td align="center">读取属性值</td> 
  </tr> 
 </tbody> 
</table>

#### 案例： ####

##### 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、测试案例： #####

> 借用一下案例二的例子
> 
> 目前我们想用`案例1`中的`Cat类`，在初始化时，他的所有属性皆不是基本类型，所有默认初始值为`null`
> 
> 我们想获取该存在的类并改变它的名字（name属性）为：大白，其他字符从null，改为""

@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 #####

![在这里插入图片描述][fdbe5bdf12934edcb09bfe94359b6ecf.png]

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

#### Constructor类 ####

<table> 
 <thead> 
  <tr> 
   <th align="center">方法名</th> 
   <th align="center">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">public String <strong>getName</strong>()</td> 
   <td align="center">返回构造方法名</td> 
  </tr> 
  <tr> 
   <td align="center">public int <strong>getModifiers</strong>()</td> 
   <td align="center">获取构造方法的修饰符列表,返回的修饰符是一个数字，每个数字是修饰符的代号【一般配合Modifier类的toString(int x)方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public Class&lt;?&gt;[] <strong>getParameterTypes</strong>()</td> 
   <td align="center">返回构造方法的修饰符列表（一个方法的参数可能会有多个。）【结果集一般配合Class类的getSimpleName()方法使用】</td> 
  </tr> 
  <tr> 
   <td align="center">public T <strong>newInstance</strong>(Object … initargs)</td> 
   <td align="center">创建对象【参数为创建对象的数据】</td> 
  </tr> 
 </tbody> 
</table>

#### 案例： ####

##### 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、结果 #####

![在这里插入图片描述][e6703d6de3cc4df3b2a2e3fa4959d1e1.png]

[a74a18c837df440db2bea7f7c934622e.png]: https://img-blog.csdnimg.cn/a74a18c837df440db2bea7f7c934622e.png
[75cc6f3c0c174676a0061121dcdcff96.png]: https://img-blog.csdnimg.cn/75cc6f3c0c174676a0061121dcdcff96.png
[734f4c6ba4814981a5a8ea3cbd50c3e3.png]: https://img-blog.csdnimg.cn/734f4c6ba4814981a5a8ea3cbd50c3e3.png
[6d8e72cd06534908a736b29cb3bb7961.png]: https://img-blog.csdnimg.cn/6d8e72cd06534908a736b29cb3bb7961.png
[a9f4c131ec5d4467ac758c2cbb7a5574.png]: https://img-blog.csdnimg.cn/a9f4c131ec5d4467ac758c2cbb7a5574.png
[36cd257253914b8faf5d322d43f40dc3.png]: https://img-blog.csdnimg.cn/36cd257253914b8faf5d322d43f40dc3.png
[50a33545a5e84e7fa6afe5a3f32dab4d.png]: https://img-blog.csdnimg.cn/50a33545a5e84e7fa6afe5a3f32dab4d.png
[07fd6f6582454491b84a4b9c7a37dca4.png]: https://img-blog.csdnimg.cn/07fd6f6582454491b84a4b9c7a37dca4.png
[660c9cdf568e4535b5cadc048fe06620.png]: https://img-blog.csdnimg.cn/660c9cdf568e4535b5cadc048fe06620.png
[fdbe5bdf12934edcb09bfe94359b6ecf.png]: https://img-blog.csdnimg.cn/fdbe5bdf12934edcb09bfe94359b6ecf.png
[e6703d6de3cc4df3b2a2e3fa4959d1e1.png]: https://img-blog.csdnimg.cn/e6703d6de3cc4df3b2a2e3fa4959d1e1.png