You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
467 lines
15 KiB
467 lines
15 KiB
---
|
|
反射
|
|
---
|
|
|
|
#### 目录
|
|
|
|
1. 思维导图
|
|
2. 定义
|
|
3. 简单示例
|
|
4. Class
|
|
- 如何获取 Class
|
|
- 通过 Class 获取类修饰符和类型
|
|
5. Member
|
|
- Field
|
|
- Method
|
|
- Constructor
|
|
6. 数组和枚举
|
|
7. 反射优缺点
|
|
8. 参考
|
|
|
|
#### 思维导图
|
|
|
|
|
|
|
|
#### 定义
|
|
|
|
1. 对于任意一个类，都能知道这个类的所有属性和方法
|
|
2. 对于任意一个对象，都能知道调用它的任意一个属性和方法
|
|
|
|
这种动态获取信息以及动态调用对象的方法的功能成为 Java 语言的反射机制。
|
|
|
|
反射机制主要设计两个类：Class 和 Member。
|
|
|
|
#### 简单示例
|
|
|
|
```java
|
|
public class UserInfo {
|
|
private String name;
|
|
private int age;
|
|
|
|
private UserInfo(String name, int age) {
|
|
this.name = name;
|
|
this.age = age;
|
|
// try {
|
|
// throw new Exception("SingleTon can't ref");
|
|
// } catch (Exception e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "UserInfo{" +
|
|
"name='" + name + '\'' +
|
|
", age=" + age +
|
|
'}';
|
|
}
|
|
}
|
|
```
|
|
|
|
既然构造方法都私有化了，怎么获取类实例呢？
|
|
|
|
```java
|
|
public class RefDemo {
|
|
public static void main(String[] args) throws Exception {
|
|
Class c = UserInfo.class;
|
|
Constructor constructor = c.getDeclaredConstructor(String.class, int.class);
|
|
constructor.setAccessible(true);
|
|
UserInfo userInfo = (UserInfo) constructor.newInstance("Omooo", 18);
|
|
System.out.println(userInfo.toString());
|
|
}
|
|
}
|
|
|
|
输出：UserInfo{name='Omooo', age=18}
|
|
```
|
|
|
|
#### Class
|
|
|
|
Class 是反射操作的基础，每个 class 类，无论创建多少个实例对象，在 JVM 中都对应同一个 Class 对象。
|
|
|
|
##### 如何获取 Class
|
|
|
|
Java 反射包 java.lang.reflect 中的所有类都没有 public 构造方法，想要获取这些类的实例，只能通过 Class 类获取，所以说如何想使用反射，必须先获取的 Class 对象。
|
|
|
|
获取 Class 对象有以下几种方法：
|
|
|
|
1. Object.getClass()
|
|
|
|
通过对象实例获取对应的 Class 对象。
|
|
|
|
```java
|
|
Class c = "Omooo".getClass();
|
|
```
|
|
|
|
2. The.Class
|
|
|
|
```java
|
|
Class c = String.class;
|
|
```
|
|
|
|
3. Class.forName()
|
|
|
|
```java
|
|
Class c = Class.forName("java.lang.String");
|
|
//对于数组比较特殊 String[]：
|
|
Class cStringArray = Class.forName("[[Ljava.lang.String;")
|
|
```
|
|
|
|
4. The.TYPE
|
|
|
|
```java
|
|
Class c = Double.TYPE;
|
|
```
|
|
|
|
5. Class.getSuperclass()
|
|
|
|
##### 通过 Class 获取类修饰符和类型
|
|
|
|
```java
|
|
public static void main(String[] args) throws Exception {
|
|
Class c = HashMap.class;
|
|
//获取类名 UserInfo
|
|
String className = c.getName();
|
|
System.out.println("类名: " + className);
|
|
//获取类限定符 public
|
|
String modifier = Modifier.toString(c.getModifiers());
|
|
System.out.println("类限定符: " + modifier);
|
|
//获取类泛型参数
|
|
TypeVariable[] typeParameters = c.getTypeParameters();
|
|
if (typeParameters.length > 0) {
|
|
StringBuilder sb = new StringBuilder("泛型参数：");
|
|
for (TypeVariable typeVariable : typeParameters) {
|
|
sb.append(typeVariable.getName());
|
|
sb.append("___");
|
|
}
|
|
System.out.println(sb.toString());
|
|
} else {
|
|
System.out.println("类泛型参数为空！");
|
|
}
|
|
//获取类所实现的接口
|
|
Type[] interfaces = c.getGenericInterfaces();
|
|
if (interfaces.length > 0) {
|
|
StringBuilder sb = new StringBuilder("接口信息：");
|
|
for (Type type : interfaces) {
|
|
sb.append(type.toString());
|
|
sb.append("___");
|
|
}
|
|
System.out.println(sb.toString());
|
|
} else {
|
|
System.out.println("类接口信息为空！");
|
|
}
|
|
//获取继承的父类信息
|
|
List<Class> superClazzs = new ArrayList<>();
|
|
getSuperClassName(c, (ArrayList<Class>) superClazzs);
|
|
if (superClazzs.size() != 0) {
|
|
StringBuilder sb = new StringBuilder("父类信息：");
|
|
for (Class clazz : superClazzs) {
|
|
sb.append(clazz.getName());
|
|
sb.append("___");
|
|
}
|
|
System.out.println(sb.toString());
|
|
}
|
|
//获取类注解信息
|
|
Annotation[] annotations = c.getAnnotations();
|
|
if (annotations.length != 0) {
|
|
StringBuilder sb = new StringBuilder("类注解信息：");
|
|
for (Annotation annotation : annotations) {
|
|
sb.append(annotation.toString());
|
|
sb.append("___");
|
|
}
|
|
System.out.println(sb.toString());
|
|
} else {
|
|
System.out.println("类注解信息为空！");
|
|
}
|
|
}
|
|
|
|
输出：
|
|
类名: java.util.HashMap
|
|
类限定符: public
|
|
泛型参数：K___V___
|
|
接口信息：java.util.Map<K, V>___interface java.lang.Cloneable___interface java.io.Serializable___
|
|
父类信息：java.util.AbstractMap___java.lang.Object___
|
|
类注解信息为空！
|
|
```
|
|
|
|
#### Member
|
|
|
|
Member 有三个实现类：
|
|
|
|
1. Field 对应类变量
|
|
2. Method 对应类方法
|
|
3. Constructor 对应类构造方法
|
|
|
|
##### Field
|
|
|
|
通过 Field 你可以访问给定对象的类变量，包括获取变量的类型、修饰符、注解、变量名、变量值等等，即使变量是 private 的。
|
|
|
|
- 获取 Field
|
|
|
|
Class 提供了四种方法获得给定类的 Field。
|
|
|
|
- getDeclaredField(String name) 获取指定的变量，包括 private 的
|
|
- getField(String name) 获取指定的变量，只能是 public 的
|
|
- getDweclaredFields() 获取所有的变量，包括 private 的
|
|
- getFields() 获取所有的变量，只能是 public 的
|
|
|
|
- 获取变量类型、修饰符、注解
|
|
|
|
```java
|
|
public static void main(String[] args) {
|
|
Class clazz = UserInfo.class;
|
|
Field[] fields = clazz.getDeclaredFields();
|
|
if (fields.length > 0) {
|
|
for (Field field : fields) {
|
|
StringBuilder sb = new StringBuilder();
|
|
//变量名
|
|
String name = field.getName();
|
|
sb.append("变量名：");
|
|
sb.append(name);
|
|
//变量类型
|
|
String type = field.getType().getName();
|
|
sb.append("变量类型：");
|
|
sb.append(type);
|
|
//变量修饰符
|
|
String modifer = Modifier.toString(field.getModifiers());
|
|
sb.append("变量修饰符：");
|
|
sb.append(modifer);
|
|
//变量上的注解
|
|
Annotation[] annotations = field.getDeclaredAnnotations();
|
|
if (annotations.length > 0) {
|
|
for (Annotation annotation : annotations) {
|
|
String annName = annotation.toString();
|
|
sb.append("注解：");
|
|
sb.append(annName);
|
|
}
|
|
}
|
|
System.out.println(sb);
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
- 获取、设置变量值
|
|
|
|
```java
|
|
public static void main(String[] args) throws Exception {
|
|
UserInfo userInfo = new UserInfo("Omooo", 18);
|
|
System.out.println("Before: " + userInfo.toString());
|
|
Class clazz = userInfo.getClass();
|
|
Field nameField = clazz.getDeclaredField("name");
|
|
nameField.setAccessible(true);
|
|
Field ageField = clazz.getField("age");
|
|
nameField.set(userInfo, "Tom");
|
|
ageField.setInt(userInfo, 19);
|
|
System.out.println("After: " + userInfo.toString());
|
|
}
|
|
```
|
|
|
|
其中，对于 private 的属性、方法或者构造函数，比如要有：
|
|
|
|
```java
|
|
xxx.setAccessible(true);
|
|
```
|
|
|
|
这个方法是 AccessibleObject 中的一个方法，Field、Method、Constructor 都是其子类，该方法的作用就是可以取消 Java 语言访问权限检查。
|
|
|
|
##### Method
|
|
|
|
- 获取 Method
|
|
|
|
Class 依然提供了四种方法获取 Method：
|
|
|
|
```
|
|
getDeclaredMethod(String name, Class<?>... parameterTypes)
|
|
getMethod(Sting name, Class<?>... parameterTypes)
|
|
getDeclaredMethods()
|
|
getMethods()
|
|
```
|
|
|
|
获取带参数方法时，如果参数类型错误会报 NoSuchMethodException，对于参数是泛型的情况下，泛型必须当成 Object 处理。
|
|
|
|
- 获取方法返回类型
|
|
|
|
```java
|
|
getReturnType() 获取目标方法返回类型对应的 Class 对象
|
|
getGenericReturnType() 获取目标方法返回类型对应的 Type 对象
|
|
```
|
|
|
|
对于返回值是普通类型如 Object、int、String 等，两者返回值一样。但是有两种特殊情况：
|
|
|
|
```java
|
|
//1.返回值是泛型
|
|
public T function()
|
|
getReturnType() : class java.lang.Object
|
|
getGenericReturnType() : T
|
|
//2.返回值为参数化类型
|
|
public Class<String> function()
|
|
getReturnType(): class java.lang.Class
|
|
getGenericReturnType(): java.lang.Class<java.lang.String>
|
|
```
|
|
|
|
- 获取方法参数类型
|
|
|
|
```java
|
|
getParameterTypes() 获取目标方法各参数类型对应的 Class 对象
|
|
getGenericParameterTypes() 获取目标方法各参数类型对应的 Type 对象
|
|
```
|
|
|
|
返回值为数组。
|
|
|
|
- 获取方法声明抛出的异常的类型
|
|
|
|
```java
|
|
getExceptionTypes() 获取目标方法抛出的异常类型对应的 Class 对象
|
|
getGenericExceptionTypes() 获取目标方法抛出的异常类型对应的 Type 对象
|
|
```
|
|
|
|
返回值为数组。
|
|
|
|
- 获取方法参数名称
|
|
|
|
.class 文件中默认不存储方法参数名称，如果想要获取方法参数名称，需要在编译的时候加上 -parameters 参数。构造方法的参数获取同样。
|
|
|
|
```java
|
|
public static void main(String[] args) throws Exception {
|
|
UserInfo userInfo = new UserInfo("Omooo", 18);
|
|
Class clazz = userInfo.getClass();
|
|
Method nameMethod = clazz.getMethod("setName", String.class);
|
|
Parameter[] parameters = nameMethod.getParameters();
|
|
if (parameters.length > 0) {
|
|
for (Parameter p : parameters) {
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.append("参数类型: ");
|
|
sb.append(p.getType());
|
|
sb.append("参数名称: ");
|
|
sb.append(p.getName());
|
|
System.out.println(sb.toString());
|
|
}
|
|
}
|
|
}
|
|
输出：参数类型: class java.lang.String参数名称: arg0
|
|
```
|
|
|
|
如果编译未加上 -parameters 参数，返回的参数名则形如 ”argX“，X 代表参数的位置。
|
|
|
|
- 获取方法修饰符
|
|
|
|
```java
|
|
method.getModifiers()
|
|
```
|
|
|
|
- 通过反射调用方法
|
|
|
|
反射通过 Method 的 invoke() 方法来调用目标方法。第一个参数为需要调用的目标类对象，如果方法是 static 的，则该参数为 null，后面的参数都为目标方法的参数值，顺序与目标方法声明中的参数顺序一致。
|
|
|
|
需要注意的是，被调用的方法本身所抛出的异常在反射中都会以 InvocationTargetException 抛出。换句话说，反射调用过程中如果异常 InvocationTargetException 抛出，说明反射调用本身是成功，因为这个异常是目标方法本身所抛出的异常。
|
|
|
|
##### Constructor
|
|
|
|
通过反射访问构造方法并通过构造方法构建新的对象。
|
|
|
|
- 获取构造方法
|
|
|
|
和 Method 一样，Class 也提供了四种方法获取：
|
|
|
|
```java
|
|
getDeclaredConstructor(Class<?>... parameterTypes)
|
|
getConstructor(Class<?>... parameterTypes)
|
|
getDeclaredConstructors()
|
|
getConstructors()
|
|
```
|
|
|
|
构造方法的名称、限定符、参数、声明的异常等获取方法和 Method 一致。
|
|
|
|
- 创建对象
|
|
|
|
创建对象有两种方法：
|
|
|
|
1. java.lang.reflect.Constructor.newInstance()
|
|
2. Class.newInstance()
|
|
|
|
一般来讲，优先使用第一种方法，第二种方法已经被废弃了。它们之间的区别有：
|
|
|
|
- 方法一可以调用任意参数的构造方法，而方法二只能调用无参的构造方法
|
|
- 方法一会将原方法抛出的异常都包装成 InvocationTaregtException 抛出，而方法二会将原方法中的异常不做处理原样抛出
|
|
- 方法一不需要方法权限，方法二只能调用 public 的构造方法
|
|
|
|
需要注意的是：反射不支持自动装箱，传入参数时要小心。自动装箱是在编译期间的，而反射是在运行期间。
|
|
|
|
#### 数组和枚举
|
|
|
|
数组和枚举也是对象，但是在反射中，对数组和枚举的创建、访问和普通对象有点不同，Java 反射为数组和枚举提供了一些特定的 API 接口。
|
|
|
|
##### 数组
|
|
|
|
- 数组类型
|
|
|
|
数组本质上也是一个对象，所以它也有自己的类型。例如对于 int[] array，数组类型为 class [I。数组类型中的 [ 个数表示数组的维度，其后面的字母代表数组元素类型，即 int，一般为类型的首字母大小。（ long 类型例外，为 J，因为 L 被引用对象类型占用了）
|
|
|
|
- 创建和初始化数组
|
|
|
|
Java 反射为我们提供了 java.lang.reflect.Array 类用来创建和初始化数组。
|
|
|
|
```java
|
|
Array.newInstance(Class<?> componentType, int... dimensions)
|
|
Array.set(Object array, int index, int value)
|
|
Array.get(Object array, int index)
|
|
```
|
|
|
|
例如，用反射创建 int[] array = new int[]{1, 2}：
|
|
|
|
```java
|
|
public static void main(String[] args) throws Exception {
|
|
Object array = Array.newInstance(int.class, 2);
|
|
Array.set(array, 0, 1);
|
|
Array.set(array, 1, 2);
|
|
System.out.println(Array.get(array, 1));
|
|
}
|
|
```
|
|
|
|
- 多维数组
|
|
|
|
Java 反射没有提供能够直接访问多维数组元素的 API，但你可以把多维数组当成数组的数组处理。
|
|
|
|
```java
|
|
public static void main(String[] args) throws Exception {
|
|
Object matrix = Array.newInstance(int.class, 2, 2);
|
|
Object row1 = Array.get(matrix, 0);
|
|
Object row2 = Array.get(matrix, 1);
|
|
Array.set(row1, 0, 1);
|
|
Array.set(row1, 1, 2);
|
|
Array.set(row2, 0, 3);
|
|
Array.set(row2, 1, 4);
|
|
}
|
|
```
|
|
|
|
##### 枚举
|
|
|
|
枚举隐式继承自 java.lang.Enum，Enum 继承自 Object，所以枚举本质上也是一个类，也可以有成员变量、构造方法、方法等。对于普通类所能使用的反射方法，枚举都能使用，另外，Java 反射额外提供了几个方法。
|
|
|
|
```java
|
|
Class.isEnum()
|
|
Class.getEnumConstants()
|
|
java.lang.reflect.Field.isEnumConstant()
|
|
```
|
|
|
|
#### 反射优缺点
|
|
|
|
优点：动态改变类行为
|
|
|
|
缺点：
|
|
|
|
1. 性能开销
|
|
|
|
反射涉及类型动态解析，所以 JVM 无法对这些代码进行优化。因此，反射操作的效率低下，尽量避免在高性能要求下使用反射。
|
|
|
|
2. 安全限制
|
|
|
|
使用反射要求程序必须在一个没有安全限制的环境中运行。
|
|
|
|
3. 内部曝光
|
|
|
|
由于反射允许代码执行一些在正常情况下不被允许的操作，所以使用反射可能会导致意料之外的副作用。
|
|
|
|
#### 参考
|
|
|
|
[Java 反射完全解析](https://www.jianshu.com/p/607ff4e79a13) |