Java反射
Java反射机制概述
Java Reflection
- Reflection(反射)是被视为动态语言的关键,反射机制允许程序在执行期 借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
- 加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可 以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看 到类的结构,所以,我们形象的称之为:反射。
补充:动态语言 vs 静态语言
- 动态语言 是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以 被引进,已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运 行时代码可以根据某些条件改变自身结构。
- 主要动态语言:Object-C、C#、JavaScript、PHP、Python、Erlang。
- 静态语言 与动态语言相对应的,运行时结构不可变的语言就是静态语言。
- 如Java、C、 C++。
- 补充:动态语言 vs 静态语言 Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活!
Java反射机制研究及应用
- Java反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
反射相关的主要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 |
反射的应用举例
1 | String str = "test4.Person"; |
获取Class类的实例(四种方法)
- 前提:若已知具体的类,通过类的class属性获取,该方法最为安全可靠, 程序性能最高 实例:Class clazz = String.class;
- 前提:已知某个类的实例,调用该实例的getClass()方法获取Class对象 实例:Class clazz = “www.atguigu.com”.getClass(); \
- 前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方 法forName()获取,可能抛出ClassNotFoundException 实例:Class clazz = Class.forName(“java.lang.String”);
- 其他方式(不做要求) ClassLoader cl = this.getClass().getClassLoader(); Class clazz4 = cl.loadClass(“类的全类名”);
哪些类型可以有Class对象?
- class: 外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
- interface:接口
- []:数组
- enum:枚举
- annotation:注解@interface
- primitive type:基本数据类型
- void
1 | Class c1 = Object.class; |
类的加载 与ClassLoader的理解
了解:类的加载过程
- 当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过 如下三个步骤来对该类进行初始化。
- 加载:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时 数据结构,然后生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问 入口(即引用地址)。所有需要访问和使用类数据只能通过这个Class对象。这个加载的 过程需要类加载器参与。
- 链接:将Java类的二进制代码合并到JVM的运行状态之中的过程。
- 验证:确保加载的类信息符合JVM规范,例如:以cafe开头,没有安全方面的问题
- 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存 都将在方法区中进行分配。
- 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。
- 初始化:
- 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中 所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信 息的,不是构造该类对象的构造器)。
- 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类 的初始化。
- 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。
1 | public class ClassLoadingTest { |
了解:什么时候会发生类初始化?
- 类的主动引用(一定会发生类的初始化)
- 当虚拟机启动,先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员(除了final常量)和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类
- 类的被动引用(不会发生类的初始化)
- 当访问一个静态域时,只有真正声明这个域的类才会被初始化
- 当通过子类引用父类的静态变量,不会导致子类初始化
- 通过数组定义类引用,不会触发此类的初始化
- 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常 量池中了)
1 | public class ClassLoadingTest { |
- 类加载器的作用:
- 类加载的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方 法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为 方法区中类数据的访问入口。
- 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器 中,它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
了解:ClassLoader
- 类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的 类的加载器。
1 | //1.获取一个系统类加载器 |
创建运行时类的对象
- 创建类的对象:调用Class对象的newInstance()方法
- 要 求:
- 类必须有一个无参数的构造器。
- 类的构造器的访问权限需要足够
- 要 求:
- 难道没有无参的构造器就不能创建对象了吗?
- 不是!只要在操作的时候明确的调用类中的构造器,并将参数传递进去之后,才可以实例化操作。 步骤如下:
- 通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类 型的构造器
- 向构造器的形参中传递一个对象数组进去,里面包含了构造器中所需的各个参数。
- 通过Constructor实例化对象。
- 不是!只要在操作的时候明确的调用类中的构造器,并将参数传递进去之后,才可以实例化操作。 步骤如下:
1 | //1.根据全类名获取对应的Class对象 |
获取运行时类的完整结构
通过反射获取运行时类的完整结构
Field、Method、Constructor、Superclass、Interface、Annotation
- 实现的全部接口
- 所继承的父类
- 全部的构造器
- 全部的方法
- 全部的Field
使用反射可以取得:
- 实现的全部接口
- public Class[] getInterfaces() 确定此对象所表示的类或接口实现的接口。
- 2.所继承的父类
- public Class getSuperclass() 返回表示此 Class 所表示的实体(类、接口、基本类型)的父类的 Class。
- 全部的构造器
- public Constructor[] getConstructors() 返回此 Class 对象所表示的类的所有public构造方法。
- public Constructor[] getDeclaredConstructors() 返回此 Class 对象表示的类声明的所有构造方法。
- Constructor类中:
- 取得修饰符: public int getModifiers();
- 取得方法名称: public String getName();
- 取得参数的类型:public Class[] getParameterTypes();
- 全部的方法
- public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法
- public Method[] getMethods() 返回此Class对象所表示的类或接口的public的方法
- Method类中:
- public Class getReturnType()取得全部的返回值
- public Class[] getParameterTypes()取得全部的参数
- public int getModifiers()取得修饰符
- public Class[] getExceptionTypes()取得异常信息
- 全部的Field
- public Field[] getFields() 返回此Class对象所表示的类或接口的public的Field。
- public Field[] getDeclaredFields() 返回此Class对象所表示的类或接口的全部Field。
- Field方法中:
- public int getModifiers() 以整数形式返回此Field的修饰符
- public Class getType() 得到Field的属性类型
- public String getName() 返回Field的名称。
- Annotation相关
- get Annotation(Class annotationClass)
- getDeclaredAnnotations()
- 泛型相关
- 获取父类泛型类型:Type getGenericSuperclass()
- 泛型类型:ParameterizedType
- 获取实际的泛型类型参数数组:getActualTypeArguments()
- 类所在的包 Package getPackage()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88package Intermediate.Reflection;
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
/**
* @author SansZhu
* @create 2021/11/14 19:09
*
* get method structure in runtime class
*/
public class getRuntimeClassMethods {
public void test1(){
Class clazz = Person.class;
//getMethods():get now runtime class and all public permission methods called in parent class
Method[] methods = clazz.getMethods();
for (Method method:
methods) {
System.out.println(method);
}
System.out.println("========================================");
//getDeclaredMethods():get all methods called in runtime class(dont around called by parent)
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method method:
declaredMethods) {
System.out.println(method);
}
}
//permission modifier return value methodName(type1 value1,...) throws XxxException{}
public void test2(){
Class clazz = User.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for (Method m :
declaredMethods) {
//1.get annotation of method declaration
Annotation[] annotations = m.getAnnotations();
for (Annotation a :
annotations) {
System.out.println(a);
}
//2. permission modifier
System.out.print(Modifier.toString(clazz.getModifiers())+"\t");
//3.return valueType
System.out.print(m.getReturnType().getName()+"\t");
//4. methodName
System.out.print(m.getName()+"\t");
System.out.print("(");
//5.get list of formal parameter
Class<?>[] parameterTypes = m.getParameterTypes();
if (!(parameterTypes == null && parameterTypes.length == 0)){
for (int i = 0;i < parameterTypes.length; i++){
System.out.print(parameterTypes[i].getName()+" arg_"+i+",");
if (i == parameterTypes.length-1){
System.out.print(parameterTypes[i].getName()+" arg_"+i);
}
}
}
System.out.print(")");
//6.throw exception
Class<?>[] exceptionTypes = m.getExceptionTypes();
if (exceptionTypes.length > 0){
System.out.print(" throws : ");
for (int i = 0; i < exceptionTypes.length; i++){
if (i == exceptionTypes.length-1) {
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.println(exceptionTypes[i].getName()+",");
}
}
System.out.println();
}
}
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99package Intermediate.Reflection;
import org.junit.Test;
import org.junit.runners.Parameterized;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* @author SansZhu
* @create 2021/11/15 15:51
*/
public class OtherTest {
//get constructor structure
public void test1(){
Class clazz = User.class;
//getConstructor : get constructor called with public in now runtime class
Constructor[] constructors = clazz.getConstructors();
for (Constructor c :
constructors) {
System.out.println(c);
}
System.out.println();
//getDeclaredConstructor : get all constructor in now runtime class
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for (Constructor c :
declaredConstructors) {
System.out.println(c);
}
}
//get parent class of runtime class
public void test2(){
Class clazz = User.class;
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
}
//get genericSuperclass of runtime class
public void test3(){
Class clazz = User.class;
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
//get genericType
Type[] actualTypeArguments = paramType.getActualTypeArguments();
System.out.println(actualTypeArguments[0]);
}
//get interface of runtime class
public void test4(){
Class clazz = User.class;
//get interface of runtime class
Class[] interfaces = clazz.getInterfaces();
for (Class c :
interfaces) {
System.out.println(c);
}
System.out.println();
//get interface of super class
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for (Class c :
interfaces1) {
System.out.println(c);
}
}
//get package of runtime class
public void test5(){
Class clazz = User.class;
Package aPackage = clazz.getPackage();
System.out.println(aPackage);
}
//get annotation of runtime class
public void test6(){
Class clazz = User.class;
Annotation[] annotations = clazz.getAnnotations();
for (Annotation a :
annotations) {
System.out.println(a );
}
}
}- 实现的全部接口
小结
- 在实际的操作中,取得类的信息的操作代码,并不会经常开发。
- 一定要熟悉java.lang.reflect包的作用,反射机制。
- 如何取得属性、方法、构造器的名称,修饰符等。
调用运行时类的指定结构
调用指定方法
- 通过反射,调用类中的方法,通过Method类完成。步骤:
- 通过Class类的getMethod(String name,Class…parameterTypes)方法取得 一个Method对象,并设置此方法操作时所需要的参数类型。
- 之后使用Object invoke(Object obj, Object[] args)进行调用,并向方法中 传递要设置的obj对象的参数信息。
Object invoke(Object obj, Object … args)
- Object 对应原方法的返回值,若原方法无返回值,此时返回null
- 若原方法若为静态方法,此时形参Object obj可为null
- 若原方法形参列表为空,则Object[] args为null
- 若原方法声明为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语言访问检查。
反射的应用:动态代理
代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原 始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原 始对象上。
之前为大家讲解过代理机制的操作,属于静态代理,特征是代理类和目标 对象的类都是在编译期间确定下来,不利于程序的扩展。同时,每一个代 理类只能为一个接口服务,这样一来程序开发中必然产生过多的代理。最 好可以通过一个代理类完成全部的代理功能。
动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时 根据需要动态创建目标类的代理对象。
动态代理使用场合:
- 调试
- 远程方法调用
动态代理相比于静态代理的优点: 抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中 处理,这样,我们可以更加灵活和统一的处理众多的方法。
Java动态代理相关API
- Proxy :专门完成代理的操作类,是所有动态代理类的父类。通过此类为一 个或多个接口动态地生成实现类。
- 提供用于创建动态代理类和动态代理对象的静态方法
动态代理步骤
- 创建一个实现接口InvocationHandler的类,它必须实现invoke方 法,以完成代理的具体操作。
- 创建被代理的类以及接口
通过Proxy的静态方法
1
2
3
4
5
6- newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理
- RealSubject target = new RealSubject();
- // Create a proxy to wrap the original implementation
- DebugProxy proxy = new DebugProxy(target);
- // Get a reference to the proxy through the Subject interface
- Subject sub = (Subject) Proxy.newProxyInstance( Subject.class.getClassLoader(),new Class[] { Subject.class }, proxy);通过 Subject代理调用RealSubject实现类的方法
1 | String info = sub.say(“Peter", 24); |
动态代理与AOP(Aspect Orient Programming)
- 前面介绍的Proxy和InvocationHandler,很难看出这种动态代理的优势,下 面介绍一种更实用的动态代理机制
- 改进后的说明:代码段1、代码段2、代码段3和深色代码段分离开了,但代码段1、2、3又和 一个特定的方法A耦合了!最理想的效果是:代码块1、2、3既可以执行方法A,又无须在程序 中以硬编码的方式直接调用深色代码的方法
1 | public interface Dog{ |
1 | public class DogUtil{ |
1 | public class MyInvocationHandler implements InvocationHandler{ |
1 | public class MyProxyFactory{ |
1 | public class Test{ |
- 使用Proxy生成一个动态代理时,往往并不会凭空产生一个动态代理,这样没有 太大的意义。通常都是为指定的目标对象生成动态代理
- 这种动态代理在AOP中被称为AOP代理,AOP代理可代替目标对象,AOP代理 包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异: AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理
1 | package Intermediate.Reflection; |