首页 > 资讯 > 后端开发 > Python >JavaSE基础之反射机制(反射Class)详解

133

分享到

JavaSE基础之反射机制(反射Class)详解

2024-04-02 19:04:59 133人浏览薄情痞子

Python 官方文档：入门教程 => 点击学习

摘要

目录一：反射机制概述二：反射Class1. 获取Class的三种方式 2. 通过反射实例化(创建)对象3. 通过读配置属性文件实例化对象4. 只让静态代码块执行5. 获取类

一：反射机制概述

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("完整类名带包名");

1、静态方法

2、方法的参数是一个字符串。

3、字符串需要的是一个完整类名。

4、完整类名必须带有包名。java.lang包也不能省略。

第二种：Class c = 对象（引用）.getClass();

第三种：Class c = 任何类型.class;

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
 
    }
 
}

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);
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

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
...

这些高级框架底层实现原理：都采用了反射机制。所以反射机制很重要的；学会了反射机制有利于我们理解剖析框架底层的源代码。

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);
        
 
        // 怎么体现灵活性？
        // 这里的代码我们都不改变，只改变classinfo.properties配置文件
        // 例如改成：className=java.util.Date
        // 此时执行的结果就变了：Wed Aug 03 15:40:02 CST 2022
 
    }
}

4. 只让静态代码块执行

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

（1）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. 获取类路径下文件的绝对路径

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

（2）例如：

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

Thread.currentThread() 当前线程对象
getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
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是类的根路径】
 
        //Thread.currentThread() 当前线程对象
        //getContextClassLoader() 是线程对象的方法，可以获取到当前线程的类加载器对象。
        //getResource() 【获取资源】这是类加载器对象的方法，当前线程的类加载器默认从类的根路径下加载资源。
        // 写成下面这种形式，放到linux环境下也是没问题的
        // 假设classinfo.properties刚好在src下
        String path = Thread.currentThread().getContextClassLoader()
                .getResource("classinfo.properties").getPath();
        // 拿到绝对路径
        System.out.println(path); // C:/Users/86177/IdeaProjects/JavaSe1/out/production/day08/classinfo.properties
 
        // 假设有一个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下的才可以；在模块下的就不行）获取绝对路径，然后创建流：

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

第二种方式：直接返回一个流（InputStream）

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

注意：这两种方式还是还是使用IO流+properties集合的方式，使用绝对路径而不是相对路径更加的通用：

第一种方式先得到绝对路径，返回String，然后在创建IO流

第二种方式直接返回的就是一个流InputStream

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必须放到类路径下。

资源绑定器，只能绑定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
扩展类加载器：ext/*.jar
应用类加载器：classpath

（3）假设有这样一段代码：String s = "abc";

代码在开始执行之前，会将所需要类全部加载到JVM当中。通过类加载器加载，看到以上代码类加载器会找String.class文件，找到就加载，那么是怎么进行加载的呢？

首先通过“启动类加载器”加载

注意：启动类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\rt.jarrt.jar中都是JDK最核心的类库。

如果通过“启动类加载器”加载不到的时候，然后会通过"扩展类加载器"加载

注意：扩展类加载器专门加载：C:\Program Files\Java\jdk1.8.0_101\jre\lib\ext\*.jar

如果“扩展类加载器”没有加载到，那么会通过“应用类加载器”加载

注意：应用类加载器专门加载：classpath中的类。

（4）java中为了保证类加载的安全，使用了双亲委派机制。

优先从启动类加载器中加载，这个称为“父”，“父”无法加载到，再从扩展类加载器中加载，这个称为“母”。

双亲委派。如果都加载不到，才会考虑从应用类加载器中加载。直到加载到为止。

小总结

1、回顾反射机制

（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 = int.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();    
 
String path = Thread.currentThread().getContextClassLoader()
    .getResource("abc").getPath();    //必须保证src下有abc文件。
 
String path = Thread.currentThread().getContextClassLoader()
    .getResource("a/db").getPath();    //必须保证src下有a目录，a目录下有db文件。

这种方式是为了获取一个文件的绝对路径。（通用方式，不会受到环境移植的影响）

但是该文件要求放在类路径下，换句话说：也就是放到src下面。src下是类的根路径。

// 直接以流的形式返回：
InputStream in = Thread.currentThread().getContextClassLoader()
     .getResourceAsStream("com/bjpowernode/test.properties");

（8）IO流 + Properties集合，怎么快速绑定属性资源文件？

// 第一：第一这个文件必须在类路径(src)下
// 第二：这个文件必须是以.properties结尾，但是写的时候不能带上.properties。
ResourceBundle bundle = ResourceBundle.getBundle("com/bjpowernode/test");
String value = bundle.getString(key);

到此这篇关于JavaSE基础之反射机制(反射Class)详解的文章就介绍到这了,更多相关JavaSE反射机制内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

--结束END--

本文标题: JavaSE基础之反射机制(反射Class)详解

本文链接: https://lsjlt.com/news/166581.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341