java反射:Java:一步步带你深入了解神秘的Java反射

 2021-06-29 15:25    77  

前言在 Java中java反射,反射机制(Reflection)非常重要,但对于很多开发者来说,这并不容易理解,甚至觉得有点神秘今天,我将献上一份 Java反射机制的介绍 & 实战攻略,希望你们会喜欢。 目录

java反射:Java:一步步带你深入了解神秘的Java反射机制

1. 简介定义:Java语言中 一种 动态(运行时)访问java反射、检测 & 修改它本身的能力作用:动态(运行时)获取类的完整结构信息 & 调用对象的方法类的结构信息包括:变量、方法等正常情况下,Java类在编译前,就已经被加载到JVM中;而反射机制使得程序运行时还可以动态地去操作类的变量、方法等信息2. 特点2.1 优点

java反射:Java:一步步带你深入了解神秘的Java反射机制

灵活性高java反射。因为反射属于动态编译,即只有到运行时才动态创建 &获取对象实例。

java反射:Java:一步步带你深入了解神秘的Java反射机制

编译方式说明:

java反射:Java:一步步带你深入了解神秘的Java反射机制

1. 静态编译:在编译时确定类型 & 绑定对象。如常见的使用new关键字创建对象

java反射:Java:一步步带你深入了解神秘的Java反射机制

2. 动态编译:运行时确定类型 & 绑定对象。动态编译体现了Java的灵活性、多态特性 & 降低类之间的藕合性

java反射:Java:一步步带你深入了解神秘的Java反射机制

2.2 缺点

java反射:Java:一步步带你深入了解神秘的Java反射机制

执行效率低 因为反射的操作 主要通过JVM执行,所以时间成本会 高于 直接执行相同操作因为接口的通用性,Java的invoke方法是传object和object[]数组的。基本类型参数需要装箱和拆箱,产生大量额外的对象和内存开销,频繁促发GC。编译器难以对动态调用的代码提前做优化,比如方法内联。反射需要按名检索类和方法,有一定的时间开销。容易破坏类结构 因为反射操作饶过了源码,容易干扰类原有的内部逻辑3. 应用场景动态获取 类文件结构信息(如变量、方法等) & 调用对象的方法常用的需求场景有:动态代理、工厂模式优化、Java JDBC数据库操作等 下文会用实际例子详细讲解

java反射:Java:一步步带你深入了解神秘的Java反射机制

4. 具体使用4.1 Java反射机制提供的功能

java反射:Java:一步步带你深入了解神秘的Java反射机制

java反射:Java:一步步带你深入了解神秘的Java反射机制

4.2 实现手段

反射机制的实现 主要通过 操作java.lang.Class类下面将主要讲解 java.lang.Class 类4.2.1 java.lang.Class 类

定义:java.lang.Class类是反射机制的基础作用:存放着对应类型对象的 运行时信息在Java程序运行时,Java虚拟机为所有类型维护一个java.lang.Class对象该Class对象存放着所有关于该对象的 运行时信息泛型形式为Class<T>每种类型的Class对象只有1个 = 地址只有1个// 对于2个String类型对象,它们的Class对象相同

Class c1 = "Carson".getClass();

Class c2 = Class.forName("java.lang.String");

// 用==运算符实现两个类对象地址的比较

System.out.println(c1 ==c2);

// 输出结果:true

123456Java反射机制的实现除了依靠Java.lang.Class类,还需要依靠:Constructor类、Field类、Method类,分别作用于类的各个组成部分:

4.3 使用步骤

在使用Java反射机制时,主要步骤包括:

1. 获取 目标类型的Class对象

2. 通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象

3. 通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法&属性的具体信息,并进行后续操作

下面,我将详细讲解每个步骤中的使用方法。

步骤1:获取 目标类型的Class对象

// 获取 目标类型的`Class`对象的方式主要有4种

<-- 方式1:Object.getClass() -->

// Object类中的getClass()返回一个Class类型的实例

Boolean carson = true;

Class<?> classType = carson.getClass();

System.out.println(classType);

// 输出结果:class java.lang.Boolean

<-- 方式2:T.class 语法 -->

// T = 任意Java类型

Class<?> classType = Boolean.class;

System.out.println(classType);

// 输出结果:class java.lang.Boolean

// 注:Class对象表示的是一个类型,而这个类型未必一定是类

// 如,int不是类,但int.class是一个Class类型的对象

<-- 方式3:static method Class.forName -->

Class<?> classType = Class.forName("java.lang.Boolean");

// 使用时应提供异常处理器

System.out.println(classType);

// 输出结果:class java.lang.Boolean

<-- 方式4:TYPE语法 -->

Class<?> classType = Boolean.TYPE;

System.out.println(classType);

// 输出结果:boolean

12345678910111213141516171819202122232425262728此处额外讲一下java.lang.reflect.Type类

java.lang.reflect.Type是 Java中所有类型的父接口这些类型包括:

之间的关系如下

步骤2:通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象

// 即以下方法都属于`Class` 类的方法。

<-- 1. 获取类的构造函数(传入构造函数的参数类型)->>

// a. 获取指定的构造函数 (公共 / 继承)

Constructor<T> getConstructor(Class<?>... parameterTypes)

// b. 获取所有的构造函数(公共 / 继承)

Constructor<?>[] getConstructors();

// c. 获取指定的构造函数 ( 不包括继承)

Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

// d. 获取所有的构造函数( 不包括继承)

Constructor<?>[] getDeclaredConstructors();

// 最终都是获得一个Constructor类对象

// 特别注意:

// 1. 不带 "Declared"的方法支持取出包括继承、公有(Public) & 不包括有(Private)的构造函数

// 2. 带 "Declared"的方法是支持取出包括公共(Public)、保护(Protected)、默认(包)访问和私有(Private)的构造方法,但不包括继承的构造函数

// 下面同理

<-- 2. 获取类的属性(传入属性名) -->

// a. 获取指定的属性(公共 / 继承)

Field getField(String name) ;

// b. 获取所有的属性(公共 / 继承)

Field[] getFields() ;

// c. 获取指定的所有属性 (不包括继承)

Field getDeclaredField(String name) ;

// d. 获取所有的所有属性 (不包括继承)

Field[] getDeclaredFields() ;

// 最终都是获得一个Field类对象

<-- 3. 获取类的方法(传入方法名 & 参数类型)-->

// a. 获取指定的方法(公共 / 继承)

Method getMethod(String name, Class<?>... parameterTypes) ;

// b. 获取所有的方法(公共 / 继承)

Method[] getMethods() ;

// c. 获取指定的方法 ( 不包括继承)

Method getDeclaredMethod(String name, Class<?>... parameterTypes) ;

// d. 获取所有的方法( 不包括继承)

Method[] getDeclaredMethods() ;

// 最终都是获得一个Method类对象

<-- 4. Class类的其他常用方法 -->

getSuperclass();

// 返回父类

String getName();

// 作用:返回完整的类名(含包名,如java.lang.String )

Object newInstance();

// 作用:快速地创建一个类的实例

// 具体过程:调用默认构造器(若该类无默认构造器,则抛出异常

// 注:若需要为构造器提供参数需使用java.lang.reflect.Constructor中的newInstance()

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152步骤3:通过 Constructor类对象、Method类对象 & Field类对象分别获取类的构造函数、方法 & 属性的具体信息 & 进行操作

// 即以下方法都分别属于`Constructor`类、`Method`类 & `Field`类的方法。

<-- 1. 通过Constructor 类对象获取类构造函数信息 -->

String getName();// 获取构造器名

Class getDeclaringClass();// 获取一个用于描述类中定义的构造器的Class对象

int getModifiers();// 返回整型数值,用不同的位开关描述访问修饰符的使用状况

Class[] getExceptionTypes();// 获取描述方法抛出的异常类型的Class对象数组

Class[] getParameterTypes();// 获取一个用于描述参数类型的Class对象数组

<-- 2. 通过Field类对象获取类属性信息 -->

String getName();// 返回属性的名称

Class getDeclaringClass(); // 获取属性类型的Class类型对象

Class getType();// 获取属性类型的Class类型对象

int getModifiers(); // 返回整型数值,用不同的位开关描述访问修饰符的使用状况

Object get(Object obj) ;// 返回指定对象上 此属性的值

void set(Object obj, Object value) // 设置 指定对象上此属性的值为value

<-- 3. 通过Method 类对象获取类方法信息 -->

String getName();// 获取方法名

Class getDeclaringClass();// 获取方法的Class对象

int getModifiers();// 返回整型数值,用不同的位开关描述访问修饰符的使用状况

Class[] getExceptionTypes();// 获取用于描述方法抛出的异常类型的Class对象数组

Class[] getParameterTypes();// 获取一个用于描述参数类型的Class对象数组

<--额外:java.lang.reflect.Modifier类 -->

// 作用:获取访问修饰符

static String toString(int modifiers)

// 获取对应modifiers位设置的修饰符的字符串表示

static boolean isXXX(int modifiers)

// 检测方法名中对应的修饰符在modifiers中的值

1234567891011121314151617181920212223242526272829303132至此,关于Java反射机制的步骤说明已经讲解完毕。

4.4 特别注意:访问权限问题

背景 反射机制的默认行为受限于Java的访问控制如,无法访问( private )私有的方法、字段

冲突 Java安全机制只允许查看任意对象有哪些域,而不允许读它们的值若强制读取,将抛出异常

解决方案 脱离Java程序中安全管理器的控制、屏蔽Java语言的访问检查,从而脱离访问控制具体实现手段:使用Field类、Method类 & Constructor类对象的setAccessible()void setAccessible(boolean flag)

// 作用:为反射对象设置可访问标志

// 规则:flag = true时 ,表示已屏蔽Java语言的访问检查,使得可以访问 & 修改对象的私有属性

boolean isAccessible()

// 返回反射对象的可访问标志的值

static void setAccessible(AccessibleObject[] array, boolean flag)

// 设置对象数组可访问标志

1234567895. 实例应用讲解5.1 基础应用讲解

实例1:利用反射获取类的属性 & 赋值

<-- 测试类定义-->

public class Student {

public Student() {

System.out.println("创建了一个Student实例");

}

private String name;

}

<-- 利用反射获取属性 & 赋值 -->

// 1. 获取Student类的Class对象

Class studentClass = Student.class;

// 2. 通过Class对象创建Student类的对象

Object mStudent = studentClass.newInstance();

// 3. 通过Class对象获取Student类的name属性

Field f = studentClass.getDeclaredField("name");

// 4. 设置私有访问权限

f.setAccessible(true);

// 5. 对新创建的Student对象设置name值

f.set(mStudent, "Carson_Ho");

// 6. 获取新创建Student对象的的name属性 & 输出

System.out.println(f.get(mStudent));

123456789101112131415161718192021222324252627测试结果

Demo地址 Carson_Ho的Github地址:Reflect_Demo1实例2:利用反射调用类的构造函数

<-- 测试类定义-->

public class Student {

// 无参构造函数

public Student() {

System.out.println("调用了无参构造函数");

}

// 有参构造函数

public Student(String str) {

System.out.println("调用了有参构造函数");

}

private String name;

}

<-- 利用反射调用构造函数 -->

// 1. 获取Student类的Class对象

Class studentClass studentClass = Student.class;

// 2.1 通过Class对象获取Constructor类对象,从而调用无参构造方法

// 注:构造函数的调用实际上是在newInstance(),而不是在getConstructor()中调用

Object mObj1 = studentClass.getConstructor().newInstance();

// 2.2 通过Class对象获取Constructor类对象(传入参数类型),从而调用有参构造方法

Object mObj2 = studentClass.getConstructor(String.class).newInstance("Carson");

1234567891011121314151617181920212223242526272829测试结果

Demo地址 Carson_Ho的Github地址:Reflect_Demo2实例3:利用反射调用类对象的方法

<-- 测试类定义-->

public class Student {

public Student() {

System.out.println("创建了一个Student实例");

}

// 无参数方法

public void setName1 (){

System.out.println("调用了无参方法:setName1()");

}

// 有参数方法

public void setName2 (String str){

System.out.println("调用了有参方法setName2(String str):" + str);

}

}

<-- 利用反射调用方法 -->

// 1. 获取Student类的Class对象

Class studentClass = Student.class;

// 2. 通过Class对象创建Student类的对象

Object mStudent = studentClass.newInstance();

// 3.1 通过Class对象获取方法setName1()的Method对象:需传入方法名

// 因为该方法 = 无参,所以不需要传入参数

Method msetName1 = studentClass.getMethod("setName1");

// 通过Method对象调用setName1():需传入创建的实例

msetName1.invoke(mStudent);

// 3.2 通过Class对象获取方法setName2()的Method对象:需传入方法名 & 参数类型

Method msetName2 = studentClass.getMethod("setName2",String.class);

// 通过Method对象调用setName2():需传入创建的实例 & 参数值

msetName2.invoke(mStudent,"Carson_Ho");

123456789101112131415161718192021222324252627282930313233343536373839测试结果

Demo地址 Carson_Ho的Github地址:Reflect_Demo35.2 常见需求场景讲解

实例1:工厂模式优化

背景 采用简单工厂模式冲突 操作成本高:每增加一个接口的子类,必须修改工厂类的逻辑系统复杂性提高:每增加一个接口的子类,都必须向工厂类添加逻辑关于 简单工厂模式的介绍 & 使用 请看文章:简单工厂模式(SimpleFactoryPattern)- 最易懂的设计模式解析

解决方案 采用反射机制: 通过 传入子类名称 & 动态创建子类实例,从而使得在增加产品接口子类的情况下,也不需要修改工厂类的逻辑实例演示步骤1. 创建抽象产品类的公共接口

Product.java

abstract class Product{

public abstract void show();

}

123步骤2. 创建具体产品类(继承抽象产品类),定义生产的具体产品

<-- 具体产品类A:ProductA.java -->

public class ProductA extends Product{

@Override

public void show() {

System.out.println("生产出了产品A");

}

}

<-- 具体产品类B:ProductB.java -->

public class ProductB extends Product{

@Override

public void show() {

System.out.println("生产出了产品B");

}

}

12345678910111213141516171819步骤3. 创建工厂类

Factory.java

public class Factory {

// 定义方法:通过反射动态创建产品类实例

public static Product getInstance(String ClassName) {

Product concreteProduct = null;

try {

// 1. 根据 传入的产品类名 获取 产品类类型的Class对象

Class product_Class = Class.forName(ClassName);

// 2. 通过Class对象动态创建该产品类的实例

concreteProduct = (Product) product_Class.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

// 3. 返回该产品类实例

return concreteProduct;

}

}

123456789101112131415161718192021222324步骤4:外界通过调用工厂类的静态方法(反射原理),传入不同参数从而创建不同具体产品类的实例

TestReflect.java

public class TestReflect {

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

// 1. 通过调用工厂类的静态方法(反射原理),从而动态创建产品类实例

// 需传入完整的类名 & 包名

Product concreteProduct = Factory.getInstance("scut.carson_ho.reflection_factory.ProductA");

// 2. 调用该产品类对象的方法,从而生产产品

concreteProduct.show();

}

}

1234567891011展示结果

Demo地址 Carson_Ho的Github地址:Reflection_Factory1如此一来,通过采用反射机制(通过 传入子类名称 & 动态创建子类实例),从而使得在增加产品接口子类的情况下,也不需要修改工厂类的逻辑 & 增加系统复杂度

实例2:应用了反射机制的工厂模式再次优化

背景 在上述方案中,通过调用工厂类的静态方法(反射原理),从而动态创建产品类实例(该过程中:需传入完整的类名 & 包名)冲突 开发者 无法提前预知 接口中的子类类型 & 完整类名解决方案 通过 属性文件的形式( Properties) 配置所要的子类信息,在使用时直接读取属性配置文件从而获取子类信息(完整类名)具体实现步骤1:创建抽象产品类的公共接口

Product.java

abstract class Product{

public abstract void show();

}

123步骤2. 创建具体产品类(继承抽象产品类),定义生产的具体产品

<-- 具体产品类A:ProductA.java -->

public class ProductA extends Product{

@Override

public void show() {

System.out.println("生产出了产品A");

}

}

<-- 具体产品类B:ProductB.java -->

public class ProductB extends Product{

@Override

public void show() {

System.out.println("生产出了产品B");

}

}

12345678910111213141516171819步骤3. 创建工厂类

Factory.java

public class Factory {

// 定义方法:通过反射动态创建产品类实例

public static Product getInstance(String ClassName) {

Product concreteProduct = null;

try {

// 1. 根据 传入的产品类名 获取 产品类类型的Class对象

Class product_Class = Class.forName(ClassName);

// 2. 通过Class对象动态创建该产品类的实例

concreteProduct = (Product) product_Class.newInstance();

} catch (Exception e) {

e.printStackTrace();

}

// 3. 返回该产品类实例

return concreteProduct;

}

}

123456789101112131415161718192021222324步骤4:创建属性配置文件

Product.properties

// 写入抽象产品接口类的子类信息(完整类名)

ProductA = scut.carson_ho.reflection_factory.ProductA

ProductB = scut.carson_ho.reflection_factory.ProductB

123步骤5:将属性配置文件 放到src/main/assets文件夹中

若没assets文件夹,则自行创建

步骤6:在动态创建产品类对象时,动态读取属性配置文件从而获取子类完整类名

TestReflect.java

public class TestReflect {

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

// 1. 读取属性配置文件

Properties pro = new Properties() ;

pro.load(this.getAssets().open("Product.properties"));

// 2. 获取属性配置文件中的产品类名

String Classname = pro.getProperty("ProductA");

// 3. 动态生成产品类实例

Product concreteProduct = Factory.getInstance(Classname);

// 4. 调用该产品类对象的方法,从而生产产品

concreteProduct.show();

}

1234567891011121314151617测试结果

Demo地址 Carson_Ho的Github地址:Reflection_Factory2实例3:动态代理

通过反射机制实现动态代理,具体请看文章:设计模式:这是一份全面 & 清晰的动态代理模式(Proxy Pattern)学习指南

6. 总结本文全面讲解了Java反射机制(Reflection)的相关知识,相信您对Java反射机制已经非常了解

本文标签:Java步步反射

原文链接:https://www.xgfox.com/alpx/28.html

本文版权:如无特别标注,本站文章均为原创。