编程技术是改变世界的力量。
本站
当前位置:网站首页 > 后端语言 > 正文

JAVA反射机制详解,一学就会 java反射机制的原理和用途

gowuye 2024-04-04 11:57 8 浏览 0 评论

目录

何为反射?

反射(Reflection),是指Java程序具有 在运行期 分析类以及修改其本身状态或行为的能力

通俗点说 就是 通过反射我们可以 动态地 获取一个类的所有属性和方法,还可以操作这些方法和属性。

实例的创建

一般我们创建一个对象实例 Person zhang = new Person();
虽然是简简单单一句,但JVM内部的实现过程是复杂的:

  1. 将硬盘上指定位置的Person.class文件加载进内存
  2. 执行main方法时,在栈内存中开辟了main方法的空间(压栈-进栈),然后在main方法的栈区分配了一个变量zhang。
  3. 执行new,在堆内存中开辟一个 实体类的 空间,分配了一个内存首地址值
  4. 调用该实体类对应的构造函数,进行初始化(如果没有构造函数,Java会补上一个默认构造函数)。
  5. 将实体类的 首地址赋值给zhang,变量zhang就引用了该实体。(指向了该对象)

其中上图步骤1 Classloader(类加载器) 将class文件加载到内存中具体分为3个阶段:加载、连接、初始化

而又在 加载阶段,类加载器将类对应的.class文件中的二进制字节流读入到内存中,将这个字节流转化为方法区的运行时数据结构,然后在堆区创建一个**java.lang.Class 对象**(类相关的信息),作为对方法区中这些数据的访问入口

然后再通过 类的实例 来执操作 类的方法和属性 ,比如 zhang.eat(), zhang.getHeight() 等等

如果我们使用反射的话,我们需要拿到该类Person的Class对象,再通过Class对象来操作 类的方法和属性或者创建类的实例

Class personClass = Person.class;//这边只是举一个例子,获取class对象的多种方式,本文后面再慢慢道来
Object person = personClass.newInstance();

我们可以发现 通过new创建类的实例和反射创建类的实例,都绕不开.class文件 和 Class类的。

.class文件

首先我们得先了解一下 什么是.class文件

举个简单的例子,创建一个Person类:

public class Person {
    /**
     * 状态 or 属性
     */
    String name;//姓名
    String sex;//性别
    int height;//身高
    int weight;//体重
    
    /**
     * 行为
     */
    public void sleep(){
    	System.out.println(this.name+"--"+ "睡觉");
	}
    public void eat(){
        System.out.println("吃饭");
    }
    public void Dance(){
        System.out.println("跳舞");
    }
}

我们执行javac命令,编译生成Person.class文件

然后我们通过vim 16进制 打开它

#打开file文件
vim Person.class 

#在命令模式下输入.. 以16进制显示
 :%!xxd
 
#在命令模式下输入.. 切换回默认显示
:%!xxd -r

不同的操作系统,不同的 CPU 具有不同的指令集,JAVA能做到平台无关性,依靠的就是 Java 虚拟机。

.java源码是给人类读的,而 .class字节码是给JVM虚拟机读的 ,计算机智能识别 0 和 1组成的二进制文件,所以虚拟机就是我们编写的代码和计算机之间的桥梁。

虚拟机将我们编写的 .java 源程序文件编译为 字节码 格式的 .class 文件,字节码是各种虚拟机与所有平台统一使用的程序存储格式,class文件主要用于解决平台无关性的中间文件

Person.class文件 包含Person类的所有信息

Class类

我们来看下jdk的官方api文档对其的定义:

Class类的类表示正在运行的Java应用程序中的类和接口。 枚举是一种类,一个注释是一种界面。 每个数组也属于一个反映为类对象的类,该对象由具有相同元素类型和维数的所有数组共享。

原始Java类型( boolean , byte , char , short , int , long , float和double ),和关键字void也表示为类对象。

类没有公共构造函数。 相反, 类对象由Java虚拟机自动构建,因为加载了类,并且通过调用类加载器中的defineClass方法。。

**java 万物皆是Class类 **

【图片】

我们来看下Class类的源码,源码太多了,挑了几个重点:

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration,
                              Type,
                              AnnotatedElement {
    private static final int ANNOTATION= 0x00002000;
    private static final int ENUM      = 0x00004000;
    private static final int SYNTHETIC = 0x00001000;

    private static native void registerNatives();
    static {
        registerNatives();
    }

    /*
     * Private constructor. Only the Java Virtual Machine creates Class objects.
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader) { //私有化的 构造器
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }
    ...
    
    // reflection data that might get invalidated when JVM TI RedefineClasses() is called
    private static class ReflectionData<T> {
        volatile Field[] declaredFields;//字段
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;//方法
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;//构造器
        volatile Constructor<T>[] publicConstructors;
        // Intermediate results for getFields and getMethods
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        volatile Class<?>[] interfaces;//接口

        // Value of classRedefinedCount when we created this ReflectionData instance
        final int redefinedCount;

        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }
      ...
     //注释数据
     private volatile transient AnnotationData annotationData;

    private AnnotationData annotationData() {
        while (true) { // retry loop
            AnnotationData annotationData = this.annotationData;
            int classRedefinedCount = this.classRedefinedCount;
            if (annotationData != null &&
                annotationData.redefinedCount == classRedefinedCount) {
                return annotationData;
            }
            // null or stale annotationData -> optimistically create new instance
            AnnotationData newAnnotationData = createAnnotationData(classRedefinedCount);
            // try to install it
            if (Atomic.casAnnotationData(this, annotationData, newAnnotationData)) {
                // successfully installed new AnnotationData
                return newAnnotationData;
            }
        }
    } 
    ...

我们可以发现Class也是类,是一种特殊的类,将我们定义普通类的共同的部分进行抽象,保存类的属性,方法,构造方法,类名、包名、父类,注解等和类相关的信息。

Class类的构造方法是private, 只有JVM能创建Class实例 ,我们开发人员 是无法创建Class实例的,JVM在构造Class对象时,需要传入一个 类加载器

类也是可以用来存储数据的,Class类就像 普通类的模板 一样,用来保存“类所有相关信息”的类。

我们来继续看这个利用反射的例子: Class personClass = Person.class;

由于JVM为加载的 Person.class创建了对应的Class实例,并在该实例中保存了该 Person.class的所有信息,因此,如果获取了Class实例(personClass ),我们就可以通过这个Class实例获取到该实例对应的 Person类 的所有信息。

反射的使用

获取Class实例4种方式

  1. 通过对象调用 getClass() 方法来获取
Person p1 = new Person();
Class c1 = p1.getClass();

像这种已经创建了对象的,再去进行反射的话,有点多此一举。

一般是用于传过来的是Object类型的对象,不知道具体是什么类,再用这种方式比较靠谱

  1. 类名.class
Class c2 = Person.class;

这种需要提前知道导入类的包,程序性能更高,比较常用,通过此方式获取 Class 对象 ,Person类不会进行初始化

  1. 通过 Class 对象的 forName() 静态方法来获取,最常用的一种方式
Class c3 = Class.forName("com.zj.demotest.domain.Person");

这种只需传入类的全路径 Class.forName会进行初始化initialization步骤 ,即静态初始化(会初始化类变量,静态代码块)。

  1. 通过类加载器对象的 loadClass() 方法
public class TestReflection {
    public static void main(String[] args) throws ClassNotFoundException {
        Person p1 = new Person();
        Class c1 = p1.getClass();

        Class c2 = Person.class;

        Class c3 = Class.forName("com.zj.demotest.domain.Person");

        //第4中方式,类加载器
        ClassLoader classLoader = TestReflection.class.getClassLoader();
        Class c4 = classLoader.loadClass("com.zj.demotest.domain.Person");


        System.out.println(c1.equals(c2));
        System.out.println(c2.equals(c3));
        System.out.println(c3.equals(c4));
        System.out.println(c1.equals(c4));
    }
}

loadClass的源码:

public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

loadClass 传入的第二个参数是"false",因此它不会对类进行连接这一步骤,根据 类的生命周期 我们知道,如果一个类没有进行验证和准备的话,是无法进行初始化过程的,即 不会进行类初始化,静态代码块和静态对象也不会得到执行

我们将c1,c2,c3,c4进行 equals 比较

System.out.println(c1.equals(c2));
System.out.println(c2.equals(c3));
System.out.println(c3.equals(c4));
System.out.println(c1.equals(c4));

结果:

true  true  true  true

因为Class实例在JVM中是唯一的,所以,上述方法获取的Class实例是同一个实例, 一个类在 JVM 中只会有一个 Class 实例

Class类常用的API

日常开发的时候,我们一般使用反射是为了 创建类实例(对象)、反射获取类的属性和调用类的方法

getName()

获得类的完整名字

getFields()

获得类的public类型的属性

getDeclaredFields()

获得类的所有属性。包括 private 声明的和继承类

getMethods()

获得类的public类型的方法

getDeclaredMethods()

获得类的所有方法。包括 private 声明的和继承类

getMethod(String name, Class[] parameterTypes)

获得类的特定方法,name参数指定方法的名字,parameterTypes 参数指定方法的参数类型。

getConstructors()

获得类的public类型的构造方法

getConstructor(Class[] parameterTypes)

获得类的特定构造方法,parameterTypes 参数指定构造方法的参数类型

newInstance()

通过类的不带参数的构造方法创建这个类的一个对象

getSuperClass()

用于返回表示该 Class 表示的任何类、接口、原始类型或任何 void 类型的 超类的Class(即父类)

...

...

我们这边就不全部展开讲了,挑几个重点讲解一下

创建对象

  1. 调用class对象的 newInstance() 方法
Class c1 = Class.forName("com.zj.demotest.domain.Person");
Person p1 = (Person) c1.newInstance();
p1.eat();

结果:

吃饭

注意:Person类必须有一个 无参的构造器类的构造器的访问权限不能是private

  1. 使用指定构造方法 Constructor 来创建对象

如果我们非得让Person类的无参构造器设为private呢,我们可以获取对应的Constructor来创建对象

Class c1 = Class.forName("com.zj.demotest.domain.Person");
Constructor<Person> con =  c1.getDeclaredConstructor();
con.setAccessible(true);//允许访问
Person p1 = con.newInstance();
p1.eat();

结果:

吃饭

注意:setAccessible()方法能在运行时 压制 Java语言访问控制检查(Java language access control checks),从而能任意调用 被私有化 保护的方法、域和构造方法。

由此我们可以发现** 单例模式不再安全,反射可破之!**

访问属性

Field getField(name)

根据字段名获取某个public的field(包括父类)

Field getDeclaredField(name)

根据字段名获取当前类的某个field(不包括父类)

Field[] getFields()

获取所有public的field(包括父类)

Field[] getDeclaredFields()

获取当前类的所有field(不包括父类)

我们来看一个例子:

public class TestReflection3 {
    
    public static void main(String[] args) throws Exception {
        Object p = new Student("li hua");
        Class c = p.getClass();
        Field f = c.getDeclaredField("name");//获取属性
        f.setAccessible(true);//允许访问
        Object val= f.get(p);
        System.out.println(val);
    }


    static class Student {
        private String name;

        public Student(String name) {
            this.name = name;
        }
    }
}

结果:

li hua

我们可以发现 反射可以破坏类的封装

调用方法

Method getMethod(name, Class...)

获取某个public的Method(包括父类)

Method getDeclaredMethod(name, Class...)

获取当前类的某个Method(不包括父类)

Method[] getMethods()

获取所有public的Method(包括父类)

Method[] getDeclaredMethods()

获取当前类的所有Method(不包括父类)

我们来看一个例子:

public class TestReflection4 {

    public static void main(String[] args) throws Exception {

        //获取私有方法,需要传参:方法名和参数
        Method h = Student.class.getDeclaredMethod("setName",String.class);

        h.setAccessible(true);

        Student s1 =new Student();
        System.out.println(s1.name);
        //传入目标对象,调用对应的方法
        h.invoke(s1,"xiao ming");
        System.out.println(s1.name);
    }


    static class Student {
        private String name;

        private void setName(String name) {
            this.name = name;
        }
    }
}

结果:

null  xiao ming

我们发现获取方法getMethod()时,需要传参 方法名和参数

这是因为.class文件中通常有 不止一个方法 ,获取方法getMethod()时,会去调用searchMethods方法循环遍历所有Method,然后根据 方法名和参数类型 找到唯一符合的Method返回。

我们知道类的方法是在JVM的方法区中 ,当我们new 多个对象时,属性会另外开辟堆空间存放,而方法只有一份,不会额外消耗内存,方法就像一套指令模板,谁都可以传入数据交给它执行,然后得到对应执行结果。

method.invoke(obj, args) 时传入目标对象,即可调用对应对象的方法

如果获取到的Method表示一个静态方法,调用静态方法时, 无需指定实例对象 ,所以invoke方法传入的第一个参数永远为null, method.invoke(null, args)

那如果 方法重写了呢, 反射依旧遵循 多态 的原则

反射的应用场景

如果平时我们只是写业务代码,很少会接触到直接使用反射机制的场景,毕竟我们可以直接new一个对象,性能比还反射要高。

但如果我们是工具框架的开发者,那一定非常熟悉,像 Spring/Spring Boot、MyBatis 等等框架中都大量使用反射机制, 反射被称为框架的灵魂

比如:

  1. Mybatis Plus可以让我们只写接口,不写实现类,就可以执行SQL
  2. 开发项目时,切换不同的数据库只需更改配置文件即可
  3. 类上加上@Component注解,Spring就帮我们创建对象
  4. 在Spring我们只需 @Value注解就读取到配置文件中的值
  5. 等等

扩展:反射配置文件

我们来模拟一个配置高于编码的例子

新建my.properties,将其放在resources的目录下

#Person类的包路径
className=com.zj.demotest.domain.Person 
methodName=eat

Person类 还是本文 一直用的,在文章的开头有

最后我们来编写一个测试类

public class TestProp {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {

        Properties properties = new Properties();

        ClassLoader classLoader = TestProp.class.getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("my.properties");// 加载配置文件
        properties.load(inputStream);

        String className = properties.getProperty("className");
        System.out.println("配置文件中的内容:className="+className);
        String methodName = properties.getProperty("methodName");
        System.out.println("配置文件中的内容:methodName="+methodName);

        Class name = Class.forName(className);
        Object object = name.newInstance();

        Method method = name.getMethod(methodName);
        method.invoke(object);
    }
}

结果:

配置文件中的内容:className=com.zj.demotest.domain.Person

配置文件中的内容:methodName=eat

吃饭

紧接着,我们修改配置文件:

className=com.zj.demotest.domain.Person
methodName=eat

结果变为:

配置文件中的内容:className=com.zj.demotest.domain.Person

配置文件中的内容:methodName=Dance

跳舞

是不是很方便?

尾语

反射机制是一种功能强大的机制,让Java程序具有在 运行期 分析类以及修改其本身状态或行为的能力

对于特定的复杂系统编程任务,它是非常必要的,为各种框架提供开箱即用的功能提供了便利,为解耦合提供了保障机制。

但是世事无绝对,反射相当于一系列解释操作,通知 JVM 要做的事情,性能比直接访问对象要差点(JIT优化后,对于框架来说实际是影响不大的),还会增加程序的复杂性等(明明直接new一下就能解决的事情,非要写一大段代码)。

相关推荐

爱上开源之golang入门至实战第四章-切片(Slice)

前言Go数组的长度不可改变,在特定场景中这样的集合就不太适用,Go中提供了一种灵活,功能强悍的内置类型切片("动态数组"),与数组相比切片的长度是不固定的,可以追加元素,在追加时可...

Go语言入门必知教程-切片

切片是一种灵活的和可扩展的数据结构,用于实现和管理数据集。切片由多个元素组成,所有元素都是相同类型的。切片是动态数组的一部分,可以根据需要进行增长和收缩。与数组一样,切片也可以索引。切片具有容量和长度...

Go语言基础-切片

切片是什么?切片是Go语言的一种数据结构。和数组相似,不过切片可以在它的结尾增加更多的元素。这样可变长度在实际编程中更为有用。声明切片切片的声明和数组也很相似,只是声明切片时不需要指定大小。例:va...

5分钟掌握GO中切片的基本使用方法

最近Golang越来越火,不少小伙伴都纷纷开始学习Golang,但对于原先为C++或者JAVA的同学,用习惯了数据、list、vector等,会对Go的切片slice不习惯,下面整理出go中slice...

揭秘 Go 切片(Slice)的秘密

当向切片添加新参数时,底层数组会发生什么变化?它会扩展以容纳更多元素吗?在这篇文章中,我们将深入探讨切片的内部工作原理,以及如何利用这些知识来进行更好的内存管理和性能优化。具体而言,我们将探索Go...

【Go语言slice详解】深入掌握Go语言中的slice类型及常用操作!

Go语言中的slice(切片)是一种非常方便的数据结构,可以动态地增加或减少其元素数量,且可以访问底层数组的任意一个子序列。本文将对Go语言中的slice进行详细的讲解。Slice的定义在Go语言中,...

掌握GO中的Slice,这就够了

最近Golang越来越火,不少小伙伴都纷纷开始学习Golang,但对于原先为C++或者JAVA的同学,用习惯了数据、list、vector等,会对Go的切片slice不习惯,下面整理出go中slice...

golang2021面向对象(26)Go语言类型内嵌和结构体内嵌

结构体可以包含一个或多个匿名(或内嵌)字段,即这些字段没有显式的名字,只有字段的类型是必须的,此时类型也就是字段的名字。匿名字段本身可以是一个结构体类型,即结构体可以包含内嵌结构体。?可以粗略地将这个...

2022-11-13:以下go语言代码中,如何获取结构体列表以及结构体内

2022-11-13:以下go语言代码中,如何获取结构体列表以及结构体内的指针方法列表?以下代码应该返回{"S1":["M1","M2"],"S...

Go语言文件和目录操作

文件和目录操作概述一、文件和目录操作概述在计算机中,文件和目录是存储数据的重要方式。在Go语言中,我们可以使用os和io/ioutil包提供的函数和结构体来进行文件和目录操作。本文将详细介绍Go语言中...

跟我一起学习go语言(五)golang中结构体的初始化方法

1、自定义一个结构体typeVertexstruct{X,Yfloat64}2、初始化方法-指针:rect1:=new(Vertex)rect2:=&Vertex...

Go复合数据类型:结构体

一种通用的、对实体对象进行聚合抽象的能力,在Go中,提供这种聚合抽象能力的类型是结构体类型,也就是struct。自定义一个新类型在Go中,我们自定义一个新类型一般有两种方法。第一种是类型定义...

Go语言基础:方法

导读在阅读本文章前,假定你具备如下能力:?已掌握结构体1.方法1.1方法的概念在理解程序中方法的概念时,我们先看看现实中的一些情况,这样相对比较好理解一些。在农村的朋友可能会知道,在医疗落后的情况...

为什么 Go 语言 struct 要使用 tags

在Go语言中,struct是一种常见的数据类型,它可以用来表示复杂的数据结构。在struct中,我们可以定义多个字段,每个字段可以有不同的类型和名称。除了这些基本信息之外,Go还提供了s...

一文带你掌握掌握 Golang结构体与方法

1.Golang结构体的概念及定义结构体是Golang中一种复合类型,它是由一组具有相同或不同类型的数据字段组成的数据结构。结构体是一种用户自定义类型,它可以被用来封装多个字段,从而实现数据的...

取消回复欢迎 发表评论: