JAVA——反射机制
概述
简介
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
正常方式：引入需要的”包类”名称 ->通过new实例化 -> 取得实例化对象
反射方式：实例化对象 -> getClass()方法 -> 得到完整的“包类”名称
功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
主要API
- java.lang.Class:代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造器
- ...
理解Class类并获取Class实例
Class类
在Object类中定义了以下的方法，此方法将被所有子类继承：
public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：
可以通过对象反射求出类的名称。
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含
了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
- Class本身也是一个类
- Class 对象只能由系统建立对象
- 一个加载的类在 JVM 中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
Class类的常用方法
| 方法名 | 功能说明 |
|---|---|
| static Class forName(String name) | 返回指定类名 name 的 Class 对象 |
| Object newInstance() | 调用缺省构造函数，返回该Class对象的一个实例 |
| getName() | 返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称 |
| Class getSuperClass() | 返回当前Class对象的父类的Class对象 |
| Class [] getInterfaces() | 获取当前Class对象的接口 |
| ClassLoader getClassLoader() | 返回该类的类加载器 |
| Class getSuperclass() | 返回表示此Class所表示的实体的超类的Class |
| Constructor[] getConstructors() | 返回一个包含某些Constructor对象的数组 |
| Field[] getDeclaredFields() | 返回Field对象的一个数组 |
| Method getMethod(String name,Class … paramTypes) | 返回一个Method对象，此对象的形参类型为paramType |
示例
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ReflectionExample {
public static void main(String[] args) throws Exception {
// 定义类名
String className = "test.Person";
// 通过类名获取 Class 对象
Class<?> clazz = Class.forName(className);
// 获取类实现的接口
Class<?>[] interfaces = clazz.getInterfaces();
System.out.println("Implemented Interfaces:");
for (Class<?> iface : interfaces) {
System.out.println(iface.getName()); //java.lang.Runnable
}
// 获取类的类加载器
ClassLoader classLoader = clazz.getClassLoader();
System.out.println("Class Loader: " + classLoader); //Class Loader: jdk.internal.loader.ClassLoaders$AppClassLoader@63947c6b
// 获取类的构造方法
Constructor<?>[] constructors = clazz.getConstructors();
System.out.println("Constructors:");
for (Constructor<?> constructor : constructors) {
System.out.println(constructor);
} //public test.Person() public test.Person(java.lang.String)
// 获取类的所有字段（包括私有字段）
Field[] fields = clazz.getDeclaredFields();
System.out.println("Declared Fields:");
for (Field field : fields) {
System.out.println(field.getName()); //name
}
// 获取类的方法
Method[] methods = clazz.getMethods();
System.out.println("Methods:");
for (Method method : methods) {
System.out.println(method.getName()); //run, wait, equals, toString, hashCode, getClass, notify, notifyAll
}
}
}
class Person implements Runnable {
public String name;
public Person() {
}
public Person(String name) {
this.name = name;
}
public void run() {
System.out.println(name + " is running.");
}
}
获取Class类的实例
若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
Class clazz = String.class;
已知某个类的实例，调用该实例的getClass()方法获取Class对象
Class clazz = “test.Person”.getClass();
已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
Class clazz = Class.forName(“test.Person”);
哪些类型可以有Class对象？
（1）class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
（2）interface：接口
（3）[]：数组
（4）enum：枚举
（5）annotation：注解@interface
（6）primitive type：基本数据类型
（7）void
创建运行时类的对象
有了Class对象，能做什么？
创建类的对象：调用Class对象的newInstance()方法
要 求：
1）类必须有一个无参数的构造器。
2）类的构造器的访问权限需要足够。
难道没有无参的构造器就不能创建对象了吗？
不是！只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。
步骤如下：
1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3）通过Constructor实例化对象。
示例——
假设有一个类Person，它没有提供无参数的构造器，而是提供了一个带有参数的构造器，用来初始化姓名和年龄。
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 其他类方法...
}
import java.lang.reflect.Constructor;
public class Main {
public static void main(String[] args) throws Exception {
// 获取Person类的Class对象
Class<?> personClass = Class.forName("Person");
// 获取带有参数的构造器，参数是String和int类型
Constructor<?> constructor = personClass.getDeclaredConstructor(String.class, int.class);
// 构造器所需的参数值
String name = "Alice";
int age = 30;
// 创建一个对象数组，包含构造器中所需的参数
Object[] constructorArgs = { name, age };
// 使用构造器实例化对象
Person person = (Person) constructor.newInstance(constructorArgs);
// 现在你可以访问person对象的属性和方法
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
调用运行时类的指定结构
调用指定方法
通过反射，调用类中的方法，通过Method类完成。步骤：
1.通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。
2.之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。
说明：
1.Object 对应原方法的返回值，若原方法无返回值，此时返回null
2.若原方法若为静态方法，此时形参Object obj可为null
3.若原方法形参列表为空，则Object[] args为null
4.若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。
调用指定属性
在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。
- public Field getField(String name) 返回此Class对象表示的类或接口的指定的public的Field。
- public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field (不考虑字段的可见性修饰符)。
在Field中：
- public Object get(Object obj) 取得指定对象obj上此Field的属性内容。
- public void set(Object obj,Object value) 设置指定对象obj上此Field的属性内容。
关于setAccessible方法的使用
- Method和Field、Constructor对象都有setAccessible()方法。
- setAccessible启动和禁用访问安全检查的开关。
- 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
- 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
- 使得原本无法访问的私有成员也可以访问
- 参数值为false则指示反射的对象应该实施Java语言访问检查。
反射的应用：动态代理
代理设计模式原理
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
定义
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
优点
静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
动态代理，抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。
相关API
Proxy: 专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
用于创建动态代理类和动态代理对象的静态方法——
static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces): 创建一个动态代理类所对应的Class对象static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h): 直接创建一个动态代理对象
步骤
1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。
2.创建被代理的类以及接口
3.通过Proxy的静态方法 newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理
4.通过 Subject代理调用RealSubject实现类的方法
示例
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 创建一个实现 InvocationHandler 接口的代理处理器类
class MyInvocationHandler implements InvocationHandler {
private Object realSubject;
public MyInvocationHandler(Object realSubject) {
this.realSubject = realSubject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 在代理方法中可以进行额外的操作，例如日志记录、性能分析等
System.out.println("Before method invocation");
// 调用被代理对象的方法
Object result = method.invoke(realSubject, args);
System.out.println("After method invocation");
return result;
}
}
// 创建被代理的接口
interface Subject {
void doSomething();
}
// 创建被代理的实现类
class RealSubject implements Subject {
@Override
public void doSomething() {
System.out.println("RealSubject is doing something.");
}
}
// 创建代理对象并调用被代理对象的方法
public class DynamicProxyDemo {
public static void main(String[] args) {
// 创建一个真实对象
Subject realSubject = new RealSubject();
// 创建代理处理器
InvocationHandler handler = new MyInvocationHandler(realSubject);
// 创建代理对象，代理 Subject 接口
Subject proxySubject = (Subject) Proxy.newProxyInstance(
Subject.class.getClassLoader(),
new Class[] { Subject.class },
handler
);
// 通过代理对象调用被代理对象的方法
proxySubject.doSomething();
}
}
Before method invocation
RealSubject is doing something.
After method invocation
浙公网安备 33010602011771号