提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  后端

当前栏目

JavaSE进阶 | 反射机制(反射Class)，通过反射机制创建对象

JavaSE反射 通过 机制 进阶 Class 创建对象
2023-09-14 09:04:53 时间

目录

一：反射机制概述

二：反射Class

1. 获取Class的四种方式 

2. 通过反射实例化(创建)对象

3. 通过读配置属性文件实例化对象

4. 只让静态代码块执行

5. 获取类路径下文件的绝对路径

6. 扩展：类加载器概述

反射机制总结

一：反射机制概述

（1）反射机制有什么用？
通过java语言中的反射机制可以操作字节码文件。（class文件）
优点：类似于黑客，可以读和修改字节码文件。   
（2）反射机制的相关类在哪个包下？java.lang.reflect.*;   
（3）反射机制相关的重要的类有哪些？
java.lang.Class：代表整个字节码，代表一个类型，代表整个类。
java.lang.reflect.Method：代表字节码中的方法字节码，代表类中的方法。
java.lang.reflect.Constructor：代表字节码中的构造方法字节码，代表类中的构造方法。
java.lang.reflect.Field：代表字节码中的属性字节码，代表类中的成员变量（静态变量+实例变量）。     

   // java.lang.Class：（整个是一个class）
            public class User{
                // Field （成员变量）
                int no;

                // Constructor（构造方法）
                public User(){
                
                }
                public User(int no){
                    this.no = no;
                }
 

                // Method（方法）
                public void setNo(int no){
                    this.no = no;
                }
                public int getNo(){
                    return no;
                }
            }

二：反射Class

1. 获取Class的四种方式 

要操作一个类的字节码，需要首先获取到这个类的字节码！

怎么获取java.lang.Class实例？三种方式：
第一种：Class c = Class.forName("完整类名带包名"); 调用Class的静态方法
①静态方法；
②方法的参数是一个字符串； 
③字符串需要的是一个完整类名；
④完整类名必须带有包名；java.lang包也不能省略。
第二种：Class c = 对象(引用).getClass(); 调用运行时类的对象的getClass()方法
第三种：Class c = 任何类型.class; 调用运行时类的静态属性：class

第四种：使用系统的类加载器

Class c = ClassLoader.getSystemClassLoader().loadClass("java.util.Date"); 

package com.bjpowernode.java.reflect;

import java.util.Date;

public class ReflectTest01 {
    public static void main(String[] args) {

        // 第一种方式：Class.forName()
        Class c1 = null;
        Class c2 = null;
        try {
            // c1代表String.class文件，或者说c1代表String类型。
            c1 = Class.forName("java.lang.String"); 
            // c2代表Date类型
            c2 = Class.forName("java.util.Date"); 
            // c3代表Integer类型
            Class c3 = Class.forName("java.lang.Integer"); 
            // c4代表System类型
            Class c4 = Class.forName("java.lang.System");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        // 第二种方式：对象.getClass()
        // java中任何一个对象都有一个方法：getClass()
        String s = "abc";
        // x代表String.class字节码文件；x代表String类型
        Class x = s.getClass(); 
        // true（==判断的是对象的内存地址）
        System.out.println(x == c1); 

        Date time = new Date();
        Class y = time.getClass();
        // true (c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件)
        System.out.println(c2 == y); 

        // 第三种方式，java语言中任何一种类型，包括基本数据类型，它都有.class属性。
        // z代表String类型
        Class z = String.class;
        // k代表Date类型 
        Class k = Date.class; 
        // f代表int类型
        Class f = int.class; 
        // e代表double类型
        Class e = double.class; 
        System.out.println(c1 == x && x == z); // true

        // 第四种方式：使用类加载器（了解）
        Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass("java.util.Date");
        System.out.println(clazz.newInstance());

    }

}

注：怎么才算同一个Class?

答：只要元素类型与维度一样，就是同一个Class；和长度没有关系！

    @Test
    public void test(){
        int[] a = new int[10];
        int[] b = new int[100];
        // 调用getClass方法获取Class
        Class c1 = a.getClass();
        Class c2 = b.getClass();
        // 都是一维的，类型也相同
        System.out.println(c1 == c2); // true

    }

2. 通过反射实例化(创建)对象

（1）获取到Class，通过Class的newInstance()方法来实例化（创建）对象。
（2）newInstance()方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以；所以一旦我们写上了有参构造方法，无参构造方法也要写上！ 如果有有参构造方法，而没有写无参构造方法会出现异java.lang.InstantiationException 实例化异常

package com.bjpowernode.java.reflect;

import com.bjpowernode.java.bean.User;

public class ReflectTest02 {
    public static void main(String[] args) {

        // 第一种方法创建对象：不使用反射机制
        User user = new User();
        System.out.println(user);

        // 第二种方法创建对象：以反射机制的方式创建对象。（这种方式比较灵活）
        try {
            // 通过反射机制，获取Class，通过Class来实例化（创建）对象
            Class c = Class.forName("com.bjpowernode.java.bean.User");
            Object obj = c.newInstance();
           
            System.out.println(obj);
            /*
            执行结果：
                无参数构造方法
                com.bjpowernode.java.bean.User@4554617c
            */
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

User类 

package com.bjpowernode.java.bean;

public class User {
    // 无参构造（不写也行，默认会有）
    public User() {
        System.out.println("无参数构造方法");
    }

    // 有参构造写了，无参构造必须写；不然调用newInstance()会出现异常
    public User(String s) {
        System.out.println("无参数构造方法");
    }

}

3. 通过读配置属性文件实例化对象

（1）通过读配置属性文件实例化对象，java代码写一遍，再不改变java源代码的基础之上，只改变配置文件，可以做到不同对象的实例化；非常之灵活。（符合OCP开闭原则：对扩展开放，对修改关闭）

（2）配置文件写好，命名为xxx.properties，然后使用IO流+Properties

（3）后期我们要学习的是高级框架，而工作过程中，也都是使用高级框架，
    包括： ssh ssm
    Spring SpringMVC MyBatis
    Spring Struts Hibernate
    ...
这些高级框架底层实现原理：都采用了反射机制。所以反射机制很重要的；学会了反射机制有利于我们理解剖析框架底层的源代码。

（4）步骤：

第一步：创建字符输入流FileStream；

第二步：创建集合Properties对象；

第三步：调用Properties对象的load方法，把FileStream流对象加载进去；

第四步：调用Properties对象的getProperties(key)方法拿到类名；

第五步：通过类加载方式创建对象：

①Class.forName(类名)，拿到类的字节码

②然后在调用newInstance方法完成对象的创建

（5）执行非常的灵活，怎么体现灵活性？
这里的所有代码我们都不需要改变，只改变classinfo.properties配置文件；例如改成：className=java.util.Date；此时执行的结果就变了：Wed Aug 03 15:40:02 CST 2022

package com.bjpowernode.java.reflect;

import java.io.FileReader;
import java.util.Properties;

public class ReflectTest03 {
    public static void main(String[] args) throws Exception {
        // IO流+Properties集合
        // 通过IO流读classinfo.properties配置文件
        // 配置文件内容是：className=com.bjpowernode.java.bean.User
        FileReader reader = new FileReader("day08\\classinfo.properties");
        // 创建属性类对象Map，properties的key和value都是String
        Properties pro = new Properties();
        // 加载
        pro.load(reader);
        // reader关闭流
        reader.close();
        // 通过key获取value
        String s = pro.getProperty("className");
        //System.out.println(s); // com.bjpowernode.java.bean.User

        // 最后在通过反射机制实例化对象
        Class c = Class.forName(s);
        Object obj = c.newInstance();
        System.out.println(obj);
        /*
        执行结果：
            无参数构造方法
            com.bjpowernode.java.bean.User@4554617c
        */

    }
}

4. 只让静态代码块执行

Class.forName()执行发生了什么？

Class.forName("完整类名")；这个方法的执行会导致类加载，类加载时，静态代码块执行。如果你只是希望一个类的静态代码块执行，其它代码一律不执行，使用Class.forName()！

进行测试

package com.bjpowernode.java.reflect;

public class ReflectTest04 {
    public static void main(String[] args) {
        try {
            // Class.forName()这个方法的执行会导致：类加载。
            // 类加载，静态代码块就会执行
            Class.forName("com.bjpowernode.java.reflect.MyClass");
            // 执行结果：MyClass类的静态代码块执行了！
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class MyClass{
    // 静态代码块在类加载时执行，并且只执行一次
    static{
        System.out.println("MyClass类的静态代码块执行了！");
    }
}

5. 获取类路径下文件的绝对路径

一定要注意大前提：文件需要在类路径下（也就是src目录下）！

（1）怎么获取一个文件的绝对路径。以下讲解的这种方式是通用的，但前提是：文件需要在类路径(src)下才能用这种方式。

（2） 例如：User.properties是在src目录下的

 String path = Thread.currentThread().getContextClassLoader()
               .getResource("User.properties").getPath();

Thread.currentThread()：当前线程对象。
getContextClassLoader()：是线程对象的方法，可以获取到当前线程的类加载器对象。
getResource() ：【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下(src路径下)加载资源。 

getPath() ：获取路径。

package com.bjpowernode.java.reflect;

import java.io.FileReader;

// 研究一下文件路径的问题
public class AboutPath {
    public static void main(String[] args) throws Exception {
        // 我们写成下面这种路径形式，只能在IDEA工具中才能找到，不够通用！
        FileReader reader = new FileReader("day08\\classinfo.properties");

        // 通用的一种方式：
        // 注意：使用以下通用方式的前提是：这个文件必须在类路径下。
        // 什么类路径下？方式在src下的都是类路径下。【src是类的根路径】

        // 写成下面这种形式，放到Linux环境下也是没问题的
        // 假设classinfo.properties刚好在src下
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo.properties").getPath();
        // 拿到绝对路径
// C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/classinfo.properties
        System.out.println(path); 


        // 假设有一个example文件没有直接在src下面，而是bean下面（com/bjpowernode/java/bean/example）
        String path2 = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/example").getPath();
        // 获取绝对路径
        System.out.println(path2); // C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/com/bjpowernode/java/bean/example
    }
}

这样我们就可以修改原来的代码，得到更加通用的方式！

第一种：先通过相对路径（这里的相对路径前提：一定是在src下的才可以；在模块下的就不行）获取绝对路径，返回的是一个String类型；然后创建流：

// 1.得到相对路径
String path =Thread.currentThread().getContextClassLoader().getResource("相对路径").getPath(); 
// 2.创建流
 FileReader reader = new FileReader(path);

第二种方式：直接返回一个流（InputStream）；就不要创健FileReader流！

InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/bjpowernode/java/bean/example");

注意：以上这两种方式最终还是要使用 IO流+properties集合 的方式，并且使用绝对路径而不是相对路径，更加的通用。

package com.bjpowernode.java.reflect;

import java.io.FileReader;
import java.io.InputStream;
import java.util.Properties;

public class ReflectTest05 {
    public static void main(String[] args) throws Exception {
         // 第一种方式：先拿到绝对路径，然后创建流
          //还是以example为例（className=java.util.Date），先拿到绝对路径
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("com/bjpowernode/java/bean/example").getPath();
        FileReader reader = new FileReader(path);
      
        // 第二种方式：直接返回一个流（InputStream）
        InputStream reader = Thread.currentThread().getContextClassLoader()
                .getResourceAsStream("com/bjpowernode/java/bean/example");

        // 创建Map集合对象
        Properties pro = new Properties();
        pro.load(reader);
        reader.close();
        // 通过key获取value
        String className = pro.getProperty("className");

        // 创建对象
        Class c = Class.forName(className);
        Object obj= c.newInstance();
        System.out.println(obj); // Wed Aug 03 17:00:36 CST 2022

    }
}

 第三种方式：利用资源绑定器（常用），简化代码，但没有前两种方式通用！

（1）前两种方式都需要创建一个流，而是用资源绑定器就不需要了！

（2）java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。
（3）使用这种方式的时候，属性配置文件xxx.properties必须放到类路径src下。
资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下。文件扩展名也必须是properties
（4）并且在写路径的时候，路径后面的扩展名.properties不能写。

满足以上条件后，只需要两行代码即可以拿到类名：

ResourceBundle boudle = ResourceBundle.getBundle("classinfo");
String className = boudle.getString("className");

测试代码： 

package com.bjpowernode.java.reflect;

import java.util.ResourceBundle;

public class ResourceBundleTest {
    public static void main(String[] args) throws Exception {
        // 例如：classinfo.properties（className=java.util.Date）
        ResourceBundle boudle = ResourceBundle.getBundle("classinfo");
        // 通过key获取value
        String className = boudle.getString("className");
        //System.out.println(className); // java.util.Date
        // 实例化对象
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        System.out.println(obj); // Wed Aug 03 19:31:20 CST 2022

    }
}

6. 扩展：类加载器概述

关于JDK中自带的类加载器：（不需要掌握）
（1）什么是类加载器？
        专门负责加载类的命令/工具；ClassLoader
（2）JDK中自带了3个类加载器
启动类加载器：rt.jar；rt.jar中都是JDK最核心的类库。
扩展类加载器：ext/*.jar
应用类加载器：classpath
（3）假设有这样一段代码：String s = "abc"；代码在开始执行之前，会将所需要类全部加载到JVM当中。通过类加载器加载，看到以上代码类加载器会找String.class文件，找到就加载，那么是怎么进行加载的呢？

首先通过“启动类加载器”加载；注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jar
如果通过“启动类加载器”加载不到的时候，然后会通过"扩展类加载器"加载；注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar
如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载；注意：应用类加载器专门加载：classpath中的类。
（4）java中为了保证类加载的安全，使用了双亲委派机制。
优先从启动类加载器中加载，这个称为“父”，“父”无法加载到，再从扩展类加载器中加载，这个称为“母”；双亲委派。如果都加载不到，才会考虑从应用类加载器中加载，直到加载到为止。

类加载器的分类(JDK8 为例) 【了解】

JVM 支持两种类型的类加载器，分别为引导类加载器（Bootstrap ClassLoader）和自定义类加载器（User-Defined ClassLoader）。 从概念上来讲，自定义类加载器一般指的是程序中由开发人员自定义的一类类加载器，但是 Java 虚拟机规范却没有这么定义，而是将所有派生于抽象类 ClassLoader 的类加载器都划分为自定义类加载器。无论类加载器的类型如何划 分，在程序中我们最常见的类加载器结构主要是如下情况：

 （1）启动类加载器（引导类加载器，Bootstrap ClassLoader）

①这个类加载使用 C/C++语言实现的，嵌套在 JVM 内部。获取它的对象时往往返回 null。

②它用来加载 Java 的核心库（JAVA_HOME/jre/lib/rt.jar 或 sun.boot.class.path 路径下的内容）。用于提供 JVM 自身需要的类。

③并不继承自 java.lang.ClassLoader，没有父加载器。

④ 出于安全考虑，Bootstrap 启动类加载器只加载包名为 java、javax、sun 等开头的类。

⑤加载扩展类和应用程序类加载器，并指定为他们的父类加载器。

（2）扩展类加载器（Extension ClassLoader）

①Java 语言编写，由 sun.misc.Launcher$ExtClassLoader 实现。

②继承于 ClassLoader 类 。

③父类加载器为启动类加载器。

④从 java.ext.dirs 系统属性所指定的目录中加载类库，或从 JDK 的安装目录的 jre/lib/ext 子目录下加载类库。如果用户创建的 JAR 放在此目录下，也会自动由扩展类加载器加载。

（3）应用程序类加载器（系统类加载器，AppClassLoader）

①java 语言编写，由 sun.misc.Launcher$AppClassLoader 实现 

②继承于 ClassLoader 类。

③父类加载器为扩展类加载器。 

④它负责加载环境变量 classpath 或系统属性 java.class.path 指定路径下的类库

⑤ 应用程序中的类加载器默认是系统类加载器。

⑥它是用户自定义类加载器的默认父加载器

⑦通过 ClassLoader 的 getSystemClassLoader()方法可以获取到该类加载器

总结：

①ClassLoader.getSystemClassLoader() 系统类加载器，即Application ClassLoader，用于加载ClassPath下的类。

②Thread.currentThread().getContextClassLoader() 线程上下文类加载器，用于解决基础类访问子类的问题。

③getClass().getClassLoader() 当前类的类加载器。

package com.bjpowernode.array;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.util.ResourceBundle;

public class Test {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        // 读取属性配置文件的内容
        // 第一种方式：使用File，默认是从工程下开始找
        File file = new File("clazz.properties");
        Properties pro = new Properties();
        try {
            pro.load(new FileReader(file));
            String clazz = pro.getProperty("className");
            Object o = Class.forName(clazz).newInstance();
            System.out.println(o);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        // 第二种方式：使用类加载器，直接返回一个IO（从src目录下开始找）
        //1. 系统类加载器
        InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("jd.properties");
        try {
            Properties pro2 = new Properties();
            pro2.load(is);
            System.out.println(pro2.getProperty("driver"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        //2. 上下文类加载器
        InputStream iss = Thread.currentThread().getContextClassLoader().getResourceAsStream("jd.properties");
        try {
            Properties pro3 = new Properties();
            pro3.load(iss);
            System.out.println(pro3.getProperty("driver"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        
    }

}

、

反射机制总结

（1）什么是反射机制？反射机制有什么用？
反射机制：可以操作字节码文件
作用：可以让程序更加灵活

（2）反射机制相关的类在哪个包下？java.lang.reflect.*;

（3）反射机制相关的主要的类？
java.lang.Class
java.lang.reflect.Method;
java.lang.reflect.Constructor;
java.lang.reflect.Field;

（4）在java中获取Class的三种方式？
第一种：Class c = Class.forName("完整类名");
第二种：Class c = 对象.getClass();
第三种：Class c = 类型.class;

（5）获取了Class之后，可以调用无参数构造方法来实例化对象      

//c代表的就是日期Date类型
Class c = Class.forName("java.util.Date");
//实例化一个Date日期类型的对象
Object obj = c.newInstance();

一定要注意：newInstance()方法底层调用的是该类型的无参数构造方法；如果没有这个无参数构造方法会出现"实例化"异常。
（6）如果你只想让一个类的“静态代码块”执行的话，你可以怎么做？
Class.forName("该类的类名");这样类就加载，类加载的时候，静态代码块执行！
（7）关于路径问题？  

String path = Thread.currentThread().getContextClassLoader().getResource("写相对路径，但是这个相对路径从src出发开始找").getPath();  

这种方式是为了获取一个文件的绝对路径。（通用方式，不会受到环境移植的影响）
但是该文件要求放在类路径下，换句话说：也就是放到src下面，src是类的根路径。  

String path = Thread.currentThread().getContextClassLoader()
    .getResource("abc").getPath();    //必须保证src下有abc文件。
String path = Thread.currentThread().getContextClassLoader()
    .getResource("a/db").getPath();    //必须保证src下有a目录，a目录下有db文件。
// 然后在创建IO流，把path放进去
FileReader reader = new FileReader(path);

// 也可以直接就返回一个流对象
InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("a/db"); 
// 也可以使用系统类加载器
InputStream is = ClassLoader.getSystemClassLoader().getResourceAsStream("a/db"); 

（8）怎么快速绑定属性资源文件？

条件1：这个文件必须在类路径(src)下。
条件2：这个文件必须是以.properties结尾，但是写的时候不能带上.properties。

ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/test");
String value = bundle.getString(key);

相关文章