概述

反射(Reflection)机制是指在运行时动态地获取类的信息以及操作类的成员(字段、方法、构造函数等)的能力。通过反射,我们可以在编译时期未知具体类型的情况下,通过运行时的动态查找和调用。 虽然 Java 是静态的编译型语言,但是反射特性的加入,提供一种直接操作对象外的另一种方式,让 Java 具备的一些灵活性和动态性,我们可以通过本篇文章来详细了解它

为什么需要反射 ?

Java 需要用到反射的主要原因包括以下几点:

  1. 运行时动态加载,创建类:Java中的类是在编译时加载的,但有时希望在运行时根据某些条件来动态加载和创建所需要类。反射就提供这种能力,这样的能力让程序可以更加的灵活,动态
  2. 动态的方法调用:根据反射获取的类和对象,动态调用类中的方法,这对于一些类增强框架(例如 Spring 的 AOP),还有安全框架(方法调用前进行权限验证),还有在业务代码中注入一些通用的业务逻辑(例如一些日志,等,动态调用的能力都非常有用
  3. 获取类的信息:通过反射,可以获取类的各种信息,如类名、父类、接口、字段、方法等。这使得我们可以在运行时检查类的属性和方法,并根据需要进行操作

一段示例代码

以下是一个简单的代码示例,展示基本的反射操作:

import java.lang.reflect.Method;

public class ReflectionExample {
public static void main(String[] args) {
// 假设在运行时需要调用某个类的方法,但该类在编译时未知
String className = "com.example.MyClass"; try {
// 使用反射动态加载类
Class<?> clazz = Class.forName(className); // 使用反射获取指定方法
Method method = clazz.getMethod("myMethod"); // 使用反射创建对象
Object obj = clazz.newInstance(); // 使用反射调用方法
method.invoke(obj); } catch (ClassNotFoundException e) {
System.out.println("类未找到:" + className);
} catch (NoSuchMethodException e) {
System.out.println("方法未找到");
} catch (IllegalAccessException | InstantiationException e) {
System.out.println("无法实例化对象");
} catch (Exception e) {
System.out.println("其他异常:" + e.getMessage());
}
}
}

在这个示例中,我们假设在编译时并不知道具体的类名和方法名,但在运行时需要根据动态情况来加载类、创建对象并调用方法。使用反射机制,我们可以通过字符串形式传递类名,使用 Class.forName() 动态加载类。然后,通过 getMethod() 方法获取指定的方法对象,使用 newInstance() 创建类的实例,最后通过 invoke() 方法调用方法。

使用场景

技术再好,如果无法落地,那么始终都是空中楼阁,在日常开发中,我们常常可以在以下的场景中看到反射的应用:

  1. 框架和库:许多框架和库使用反射来实现插件化架构或扩展机制。例如,Java 的 Spring 框架使用反射来实现依赖注入(Dependency Injection)和 AOP(Aspect-Oriented Programming)等功能。
  2. ORM(对象关系映射):ORM 框架用于将对象模型和关系数据库之间进行映射。通过反射,ORM 框架可以在运行时动态地读取对象的属性和注解信息,从而生成相应的 SQL 语句并执行数据库操作。
  3. 动态代理:动态代理是一种常见的设计模式,通过反射可以实现动态代理。动态代理允许在运行时创建代理对象,并拦截对原始对象方法的调用。这在实现日志记录、性能统计、事务管理等方面非常有用
  4. 反射调试工具:在开发和调试过程中,有时需要查看对象的结构和属性,或者动态调用对象的方法来进行测试。反射提供了一种方便的方式来检查和操作对象的内部信息,例如使用getDeclaredFields()获取对象的所有字段,或使用getMethod()获取对象的方法
  5. 单元测试:在单元测试中,有时需要模拟或替换某些对象的行为,以便进行有效的测试。通过反射,可以在运行时创建对象的模拟实例,并在测试中替换原始对象,以便控制和验证测试的行为

Class 对象

Class 对象是反射的第一步,我们先从 Class 对象聊起,因为在反射中,只要你想在运行时使用类型信息,就必须先得到那个 Class 对象的引用,他是反射的核心,它代表了Java类的元数据信息,包含了类的结构、属性、方法和其他相关信息。通过Class对象,我们可以获取和操作类的成员,实现动态加载和操作类的能力。

常见的获取 Class 对象的方式几种:

// 使用类名获取
Class<?> clazz = Class.forName("com.example.MyClass"); // 使用类字面常量获取
Class<?> clazz = MyClass.class; // 使用对象的 getClass() 方法获取
MyClass obj = new MyClass();
Class<?> clazz = obj.getClass();

需要注意的是,如果 Class.forName() 找不到要加载的类,它就会抛出异常 ClassNotFoundException

正如上面所说,获取 Class 对象是第一步,一旦获取了Class对象,我们可以使用它来执行各种反射操作,例如获取类的属性、方法、构造函数等。示例:

String className = clazz.getName(); // 获取类的全限定名
int modifiers = clazz.getModifiers(); // 获取类的修饰符,如 public、abstract 等
Class<?> superClass = clazz.getSuperclass(); // 获取类的直接父类
Class<?> superClass = clazz.getSuperclass(); // 获取类的直接父类
Class<?>[] interfaces = clazz.getInterfaces(); // 获取类实现的接口数组
Constructor<?>[] constructors = clazz.getConstructors(); // 获取类的公共构造函数数组
Method[] methods = clazz.getMethods(); // 获取类的公共方法数组
Field[] fields = clazz.getFields(); // 获取类的公共字段数组
Object obj = clazz.newInstance(); // 创建类的实例,相当于调用无参构造函数

上述示例仅展示了Class对象的一小部分使用方法,还有许多其他方法可用于获取和操作类的各个方面。通过Class对象,我们可以在运行时动态地获取和操作类的信息,实现反射的强大功能。

类型检查

在反射的代码中,经常会对类型进行检查和判断,从而对进行对应的逻辑操作,下面介绍几种 Java 中对类型检查的方法

instanceof 关键字

instanceof 是 Java 中的一个运算符,用于判断一个对象是否属于某个特定类或其子类的实例。它返回一个布尔值,如果对象是指定类的实例或其子类的实例,则返回true,否则返回false。下面来看看它的使用示例

1:避免类型转换错误

在进行强制类型转换之前,使用 instanceof 可以检查对象的实际类型,以避免类型转换错误或 ClassCastException 异常的发生:

if (obj instanceof MyClass) {
MyClass myObj = (MyClass) obj;
// 执行针对 MyClass 类型的操作
}

2:多态性判断

使用 instanceof 可以判断对象的具体类型,以便根据不同类型执行不同的逻辑。例如:

if (animal instanceof Dog) {
Dog dog = (Dog) animal;
dog.bark();
} else if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.meow();
}

3:接口实现判断

在使用接口时,可以使用 instanceof 判断对象是否实现了某个接口,以便根据接口进行不同的处理

if (obj instanceof MyInterface) {
MyInterface myObj = (MyInterface) obj;
myObj.doSomething();
}

4:继承关系判断

instanceof 可以用于判断对象是否是某个类的子类的实例。这在处理继承关系时非常有用,可以根据对象的具体类型执行相应的操作

if (obj instanceof MyBaseClass) {
MyBaseClass myObj = (MyBaseClass) obj;
// 执行 MyBaseClass 类型的操作
}

instanceof 看似可以做很多事情,但是在使用时也有很多限制,例如:

  1. 无法和基本类型进行匹配:instanceof 运算符只能用于引用类型,无法用于原始类型
  2. 不能和 Class 对象类型匹配:只可以将它与命名类型进行比较
  3. 无法判断泛型类型参数:由于Java的泛型在运行时会进行类型擦除,instanceof 无法直接判断对象是否是某个泛型类型的实例

instanceof 看似方便,但过度使用它可能表明设计上的缺陷,可能违反了良好的面向对象原则。应尽量使用多态性和接口来实现对象行为的差异,而不是过度依赖类型检查。

isInstance() 函数

java.lang.Class 类也提供 isInstance() 类型检查方法,用于判断一个对象是否是指定类或其子类的实例。更适合在反射的场景下使用,代码示例:

Class<?> clazz = MyClass.class;
boolean result = clazz.isInstance(obj);

如上所述,相比 instanceof 关键字,isInstance() 提供更灵活的类型检查,它们的区别如下:

  1. isInstance() 方法的参数是一个对象,而 instanceof 关键字的操作数是一个引用类型。因此,使用 isInstance() 方法时,可以动态地确定对象的类型,而 instanceof 关键字需要在编译时指定类型。
  2. isInstance()方法可以应用于任何Class对象。它是一个通用的类型检查方法。而instanceof关键字只能应用于引用类型,用于检查对象是否是某个类或其子类的实例。
  3. isInstance()方法是在运行时进行类型检查,它的结果取决于实际对象的类型。而instanceof关键字在编译时进行类型检查,结果取决于代码中指定的类型。
  4. 由于Java的泛型在运行时会进行类型擦除,instanceof无法直接检查泛型类型参数。而isInstance()方法可以使用通配符类型(<?>)进行泛型类型参数的检查。

总体而言,isInstance()方法是一个动态的、通用的类型检查方法,可以在运行时根据实际对象的类型来判断对象是否属于某个类或其子类的实例。与之相比,instanceof关键字是在编译时进行的类型检查,用于检查对象是否是指定类型或其子类的实例。它们在表达方式、使用范围和检查方式等方面有所差异。在具体的使用场景中,可以根据需要选择合适的方式进行类型检查。

代理

代理模式

代理模式是一种结构型设计模式,其目的是通过引入一个代理对象,控制对原始对象的访问。代理对象充当了原始对象的中间人,可以在不改变原始对象的情况下,对其进行额外的控制和扩展。这是一个简单的代理模式示例:

// 定义抽象对象接口
interface Image {
void display();
} // 定义原始对象
class RealImage implements Image {
private String fileName; public RealImage(String fileName) {
this.fileName = fileName;
loadFromDisk();
} private void loadFromDisk() {
System.out.println("Loading image:" + fileName);
} @Override
public void display() {
System.out.println("Displaying image:" + fileName);
}
} // 定义代理对象
class ImageProxy implements Image {
private String filename;
private RealImage realImage; public ImageProxy(String filename) {
this.filename = filename;
} @Override
public void display() {
if (realImage == null) {
realImage = new RealImage(filename);
}
realImage.display();
}
} public class ProxyPatternExample {
public static void main(String[] args) {
// 使用代理对象访问实际对象
Image image = new ImageProxy("test_10mb.jpg");
// 第一次访问,加载实际对象
image.display();
// 第二次访问,直接使用已加载的实际对象
image.display();
}
}

输出结果:

Loading image:test_10mb.jpg
Displaying image:test_10mb.jpg
Displaying image:test_10mb.jpg

在上述代码中,我们定义了一个抽象对象接口 Image,并有两个实现类:RealImage 代表实际的图片对象,ImageProxy 代表图片的代理对象。在代理对象中,通过控制实际对象的加载和访问,实现了延迟加载和额外操作的功能。客户端代码通过代理对象来访问图片,实现了对实际对象的间接访问。

动态代理

Java的动态代理是一种在运行时动态生成代理类和代理对象的机制,它可以在不事先定义代理类的情况下,根据接口或父类来动态创建代理对象。动态代理使用Java的反射机制来实现,通过动态生成的代理类,可以在方法调用前后插入额外的逻辑。

以下是使用动态代理改写上述代码的示例:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; // 定义抽象对象接口
interface Image {
void display();
} // 定义原始对象
class RealImage implements Image {
private String filename; public RealImage(String filename) {
this.filename = filename;
loadFromDisk();
} private void loadFromDisk() {
System.out.println("Loading image: " + filename);
} public void display() {
System.out.println("Displaying image: " + filename);
}
} // 实现 InvocationHandler 接口的代理处理类
class ImageProxyHandler implements InvocationHandler { private Object realObject; public ImageProxyHandler(Object realObject) {
this.realObject = realObject;
} @Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
if (method.getName().equals("display")) {
System.out.println("Proxy: before display");
result = method.invoke(realObject, args);
System.out.println("Proxy: after display");
}
return result;
}
} public class DynamicProxyExample { public static void main(String[] args) {
// 创建原始对象
Image realImage = new RealImage("image.jpg");
// 创建动态代理对象
Image proxyImage = (Image) Proxy.newProxyInstance(Image.class.getClassLoader(), new Class[]{Image.class}, new ImageProxyHandler(realImage));
// 使用代理对象访问实际对象
proxyImage.display();
}
}

在上述代码中,我们使用 java.lang.reflect.Proxy 类创建动态代理对象。我们定义了一个 ImageProxyHandler 类,实现了 java.lang.reflect.InvocationHandler 接口,用于处理代理对象的方法调用。在 invoke() 方法中,我们可以在调用实际对象的方法之前和之后执行一些额外的逻辑。

输出结果:

Loading image: image.jpg
Proxy: before display
Displaying image: image.jpg
Proxy: after display

在客户端代码中,我们首先创建了实际对象 RealImage,然后通过 Proxy.newProxyInstance() 方法创建了动态代理对象 proxyImage,并指定了代理对象的处理类为 ImageProxyHandler。最后,我们使用代理对象来访问实际对象的 display() 方法。

通过动态代理,我们可以更加灵活地对实际对象的方法进行控制和扩展,而无需显式地创建代理类。动态代理在实际开发中常用于 AOP(面向切面编程)等场景,可以在方法调用前后添加额外的逻辑,如日志记录、事务管理等。

违反访问权限

在 Java 中,通过反射机制可以突破对私有成员的访问限制。以下是一个示例代码,展示了如何使用反射来访问和修改私有字段:

import java.lang.reflect.Field;

class MyClass {
private String privateField = "Private Field Value";
} public class ReflectionExample { public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
MyClass myObj = new MyClass();
// 获取私有字段对象
Field privateField = MyClass.class.getDeclaredField("privateField"); // 取消对私有字段的访问限制
privateField.setAccessible(true); // 获取私有字段的值
String fieldValue = (String) privateField.get(myObj);
System.out.println("Original value of privateField: " + fieldValue); // 修改私有字段的值
privateField.set(myObj, "New Field Value"); // 再次获取私有字段的值
fieldValue = (String) privateField.get(myObj);
System.out.println("Modified value of privateField: " + fieldValue);
}
}

在上述代码中,我们定义了一个 MyClass 类,其中包含一个私有字段 privateField。在 ReflectionExample 类的 main 方法中,我们使用反射获取了 privateField 字段,并通过 setAccessible(true) 方法取消了对私有字段的访问限制。然后,我们使用 get() 方法获取私有字段的值并输出,接着使用 set() 方法修改私有字段的值。最后,再次获取私有字段的值并输出,验证字段值的修改。

输出结果:

Original value of privateField: Private Field Value
Modified value of privateField: New Field Value

除了字段,通过反射还可以实现以下违反访问权限的操作:

  • 调用私有方法
  • 实例化非公开的构造函数
  • 访问和修改静态字段和方法
  • 绕过访问修饰符检查

虽然反射机制可以突破私有成员的访问限制,但应该慎重使用。私有成员通常被设计为内部实现细节,并且具有一定的安全性和封装性。过度依赖反射访问私有成员可能会破坏代码的可读性、稳定性和安全性。因此,在使用反射突破私有成员限制时,请确保了解代码的设计意图和潜在风险,并谨慎操作。

总结

反射技术自 JDK 1.1 版本引入以来,一直被广泛使用。它为开发人员提供了一种在运行时动态获取类的信息、调用类的方法、访问和修改类的字段等能力。在过去的应用开发中,反射常被用于框架、工具和库的开发,以及动态加载类、实现注解处理、实现代理模式等场景。反射技术为Java的灵活性、可扩展性和动态性增添了强大的工具。

当下,反射技术仍然发挥着重要的作用。它被广泛应用于诸多领域,如框架、ORM(对象关系映射)、AOP(面向切面编程)、依赖注入、单元测试等。反射技术为这些领域提供了灵活性和可扩展性,使得开发人员能够在运行时动态地获取和操作类的信息,以实现更加灵活和可定制的功能。同时,许多流行的开源框架和库,如 Spring、Hibernate、JUnit 等,也广泛使用了反射技术。

反射技术可能继续发展和演进。随着 Java 平台的不断发展和语言特性的增强,反射技术可能会在性能优化,安全性,模块化等方面进一步完善和改进反射的应用。然而,需要注意的是,反射技术应该谨慎使用。由于反射涉及动态生成代码、绕过访问限制等操作,如果使用不当,可能导致代码的可读性和性能下降,甚至引入安全漏洞。因此,开发人员在使用反射时应该充分理解其工作原理和潜在的风险,并且遵循最佳实践。

Java 世界的法外狂徒:反射的更多相关文章

  1. java 世界中Annotation

    java 世界中Annotation 在github上开始汇总一些自己学习,收集,总结,经验的一些信息,有利于跟踪,修改,提升.如果你感兴趣 可以关注一下,也可以提供自己的内容进来. https:// ...

  2. Java 世界的盘古和女娲 —— Zygote

    本文基于 Android 9.0 , 代码仓库地址 : android_9.0.0_r45 文中源码链接: Zygote.java ZygoteInit.java ZygoteServer.java ...

  3. Java类加载和类反射回顾

    今天学习Spring,突然想重新复习一下Java类加载和类反射的.巩固一下底层原理.部分参考了李刚老师的<疯狂Java讲义>和陈雄华.林开雄的<Spring3.x企业应用开发实战&g ...

  4. 【GoLang】golang 如何像Java 一样通过类名反射对象?

    结论: golang不支持解析string然后执行. golang的反射机制只能存在于已经存在的对象上面. 不知道后续的版本有没有规划,现在只能先加载注册,然后实现类似Java工厂模式的反射. 代码示 ...

  5. 使用Cydia Substrate 从Native Hook Android Java世界

    这里介绍了如何使用Cydia Substrate Hook安卓Java世界.这篇文章介绍如何从Native中Hook 安卓Java世界. 手机端配置见之前文章. 一.建立工程 建立一个Android工 ...

  6. java学习:用反射构造bean

    先贴一些反射的基本知识:-------------------------------------------------------------------- 一.什么是反射:反射的概念是由Smit ...

  7. 反射那些事儿——Java动态装载和反射技术

    一直以来反射都是只闻其声,却无法将之使用,近日尽心下来学习下,发现了很多精妙之处. Java动态装载和反射技术 一.类的动态装载 1.Java代码编译和执行的整个过程包含了以下三个重要的机制: ● J ...

  8. Java基础学习笔记二十三 Java核心语法之反射

    类加载器 类的加载 当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过加载,链接,初始化三步来实现对这个类进行初始化. 加载就是指将class文件读入内存,并为之创建一个Class对象.任 ...

  9. Java提升篇之反射的原理

    Java提升篇之反射的原理 1.构造方法的反射 import java.lang.reflect.Constructor; public class ReflectConstructor { publ ...

  10. 原来Java世界里也有这么多精彩的故事,学Java真有趣!

    大千世界,无所不有.这世上不光有人类世界,还有咱们的java世界.今天就由我这个实习导游带领你们了解了解咱们的java世界奇妙之处.   有一种暖男叫catch,有一种真爱叫try---catch,世 ...

随机推荐

  1. Command Injection-命令注入(命令执行)

    什么是命令注入? 命令注入是滥用应用程序的行为在操作系统上执行命令,使用与设备上的应用程序运行时相同的权限.例如,在作为名为joe的用户运行的web服务器上实现命令注入将在该joe用户下执行命令,从而 ...

  2. IDEA学生认证的步骤详解

    步骤详解 在上次使用学生认证的方法对jetbrains认证成功之后,咱们在IDEA这里认证一下吧! 一.点击help这里的register 如图所示: 进入这样一个界面: 然后点击左下角的的Log I ...

  3. Linux0.11源码学习(三)

    Linux0.11源码学习(三) linux0.11源码学习笔记 参考资料: https://github.com/sunym1993/flash-linux0.11-talk https://git ...

  4. Mybatis数据库驱动

    Mybatis数据库驱动 最近在学习mybatis的源码,有一个databaseIdProvider根据不同数据库执行不同sql的功能,我正好有一个mysql还有一个瀚高数据库,就去试了一下,使用如下 ...

  5. 2020 ccpc秦皇岛 赛后总结!!!!

    amazing!!!! 金牌!!!!! 总结一下这次的发挥,以及如何冲到了金牌. 1 有队友单开了银牌题,50分钟过了K题,当时只有5个人过K.他敲的过程中另个队友想出来另外一题的思路,等过了K,我直 ...

  6. 使用python-gitlab获取本地gitlab仓库project信息的方法

    代码中有注释,直接看代码 #coding:utf8 #!/usr/bin/env python #@author: 9527 import gitlab import openpyxl import ...

  7. 全球IP whois信息获取与情报挖掘

    全球IP的whois信息获取与情报挖掘 什么是whois信息? Whois是一种网络协议,也是一种网络服务,能够让客户端查询域名或者IP是否注册,以及注册人的相关信息.我们通常所说的whois信息就是 ...

  8. vue中新的状态管理器-pinia

    背景 对于pinia的使用,可参考官方文档在这不做过多赘述.这边主要来讲讲pinia中 少用且好用的方法,为什么我们选择pinia而不用vuex ps: 以下写法全部基于组合式API 使用方式: 先下 ...

  9. 基于docker和cri-dockerd部署k8sv1.26.3

    cri-dockerd是什么? 在 Kubernetes v1.24 及更早版本中,我们使用docker作为容器引擎在k8s上使用时,依赖一个dockershim的内置k8s组件:k8s v1.24发 ...

  10. 运输问题和指派问题—R实现

    运输问题和指派问题 运输问题经常出现在计划货物配送和从某些供给地区到达需求地区之间的服务中,特别是每个供给地区(起点)的货物可获得量是有限的,每个需求地区(目的地)的货物需求量是已知的.运输问题中最常 ...