反射
1、反射机制
1、Java Reflection
- 反射被视为动态语言的关键，反射机制允许程序在执行期间借助于Reflection API取得任何类的内部信息(比如：成员变量，构造器，成员方法)，并能直接操作任意对象的内部属性及方法。
- 加载完类之后，在堆内存中就产生了一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
2、反射机制原理图
3、Java反射机制提供的功能：
-
在运行时判断任意一个对象所属的类
-
在运行时构造任意一个类的对象
-
在运行时判断任意一个类所具有的成员变量和方法
-
在运行时获取泛型信息
-
在运行时调用任意一个对象的成员变量和方法
-
在运行时处理注解
-
生成动态代理
4、反射相关的主要类
-
java.lang.Class：代表一个类，Class对象表示某个类加载后在堆内存中的对象
-
java.lang.reflect.Method：代表类的方法，Method对象表示某个类的方法
-
java.lang.reflect.Field：代表类的成员变量，Field对象表示某个类的成员变量
-
java.lang.reflect.Constructor****：代表类的构造方法，Constructor对象表示构造器
5、反射优点和缺点
- 优点：可以动态的创建和使用对象（就是框架底层核心），使用灵活，没有反射机制，框架技术就失去底层支撑
- 缺点：使用反射基本是解释执行，对执行速度有影响
6、反射调用优化-关闭访问检查
-
Method、Field、Constructor对象都有
setAccessible()方法 -
setAccessible()作用是启动和禁用访问安全检查开关 -
参数为true表示：反射的对象在使用时取消访问检查，提高反射的效率；参数为false表示：反射的对象执行访问检查
2、理解Class类并获取Class实例
1、Class类
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了某个特定结构(class/inteface/enum.annotation/primitive type/void/[])的有关信息。
public final class Class<T> implements java.io.Serializable,
GenericDeclaration,
Type,
AnnotatedElement {
private static final int ANNOTATION= 0x00002000;
private static final int ENUM = 0x00004000;
private static final int SYNTHETIC = 0x00001000;
private static native void registerNatives();
static {
registerNatives();
}
/*
* Private constructor. Only the Java Virtual Machine creates Class objects. //私有构造器，只有JVM才能调用创建Class对象
* This constructor is not used and prevents the default constructor being
* generated.
*/
private Class(ClassLoader loader) {
// Initialize final field for classLoader. The initialization value of non-null
// prevents future JIT optimizations from assuming this final field is null.
classLoader = loader;
}
-
Class本身也是一个类，因此也继承Object类
-
Class类只存在私有构造函数，因此Class对象只能由JVM创建和加载
-
对于某个类的Class对象，在内存只有一份，因为类只加载一次
-
每个类的实例都会记得自己是由哪个Class实例所生成
-
通过Class可以完整地得到一个类中地所有被加载的结构
-
Class对象存放在堆内存中
-
类的字节码二进制数据存放在方法区中，有的地方成为类的元数据(包括：方法，变量名，方法名，访问权限等)
-
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
2、常用方法
| 方法名 | 功能说明 |
|---|---|
| static Class forName(String name) | 返回执指定类名的Class对象 |
| Object newInstance() | 调用缺省构造函数，返回该Class对象的一个实例 |
| getName() | 返回此Class对象所表示的实体(类|接口|数组类|基本类型|void)名称 |
| Class[] getInterfaces() | 获取当前Class对象的接口 |
| ClassLoder getClassLoder() | 返回该类的类加载器 |
| Class getSuperClass() | 返回表示此Class所表示的实体的超类的Class |
| Constructor[] getConstructors() | 返回一个包含某些Constructor对象的数组 |
| Field[] getDeclaredFields() | 返回Field对象的一个数组 |
| Method getMethod(String name, Class... paramTypes) | 返回一个Method对象，此对象的形参类型为paramType |
3、哪些类型有Class对象
-
外部类、成员内部类、静态内部类、局部内部类、匿名内部类
-
接口
-
数组
-
枚举
-
注解
-
基本数据类型
-
void
4、获取Class类的实例
- 前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高
实例：Class clazz = String.class
- 前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
实例：Class clazz = "abc".getClass()
- 前提****：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
实例：Class clazz = Class.forName("java.lang.String")
3、类加载
1、基本说明
反射机制时Java实现动态语言的关键，也就是通过反射实现类的动态加载。
- 静态加载：编译时加载相关类，如果没有则报错，依赖性太强
- 动态加载：运行时加载需要的类，如果运行时不用该类，即使不存在该类，也不报错，降低了依赖性
2、类加载过程图
3、类加载三个阶段完成任务
1、加载阶段
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（及引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
2、连接阶段
- 验证：
-
- 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
-
包括：文件格式验证(是否以魔数
oxcafebabe开头)、元数据验证、字节码验证和符号以用验证 -
- 可以考虑使用
-Xverify:none参数来关闭大部分的类验证措施，缩短虚拟机类加载的时间
- 可以考虑使用
- 准备：JVM 会在该阶段为静态变量(static)分配内存并设置默认初始值，这些变量所使用的内存都将在方法区中进行分配
//类加载的连接阶段——准备
public class ClassLoad02 {
public static void main(String[] args) {
//...
}
}
class A {
//属性（成员变量，字段）
//分析类加载的连接阶段——准备，属性是如何处理：
//1. n1是成员变量，不是静态变量，因此在准备阶段，不会分配内存
//2. n2是静态变量，分配内存，n2是默认初始化0，而不是20
//3. n3是static final常量，和静态变量不一样，因为一旦赋值就不变，n3 = 30
public int n1 = 10;
public static int n2 = 20;
public static final int n3 = 30;
}
- 解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程
3、初始化：
-
- 到初始化阶段，才真正开始执行类中定义的 Java 程序代码，此阶段是执行类构造器
() 方法的过程。
- 到初始化阶段，才真正开始执行类中定义的 Java 程序代码，此阶段是执行类构造器
-
类构造器
()方法是由编译器自动收集类中所有静态变量的赋值动作和静态代码块中的语句合并产生的。 (类构造器是构造类信息的，不是构造该类对象的构造器) -
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化
-
虚拟机会保证一个类的
() 方法在多线程环境中被正确加锁和同步，如果多个线程同时区初始化一个类，那么只会有一个线程去执行这个类的() 方法，其他线程都需要阻塞等待，直到活动线程执行() 方法完毕
//类加载初始化阶段
public class ClassLoad03 {
public static void main(String[] args) throws Exception {
//1.加载B类，并生成对应的Class类对象
//2.连接 num = 0;
//3.初始化阶段：依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并合并
/*
clinit(){
System.out.println("B 静态代码块被执行");
//num = 300;
num = 100;
}
合并：num = 100;
*/
//new B(); //类加载
//System.out.println(B.num); //100，如果直接使用类的静态属性，也会导致类的加载
//加载类的时候，是有同步机制控制
/*
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
//正因为有这个机制，才能保证某个类在内存中，只有一个 Class 对象
synchronized (getClassLoadingLock(name)) {
//...
}
}
*/
B b = new B();
}
}
class B {
static {
System.out.println("B 静态代码块被执行");
num = 300;
}
static int num = 100;
public B() {
System.out.println("B 构造器被执行");
}
}
4、什么时候发生类初始化
1、类的主动引用(一定会发生类的初始化)
-
当虚拟机启动，先初始化main方法所在的类
-
new一个类的对象
-
调用类的静态成员(除了final常量)和静态方法
-
使用java.lang.reflect包的方法对类进行反射调用
-
当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
2、类的被动引用(不会发生类的初始化)
-
当访问一个静态域时，只有真正声明这个域的类才会被初始化
-
当通过子类引用父类的静态变量，不会导致子类初始化
-
通过数组定义类引用，不会触发此类的初始化
-
引用常量不会触发此类的初始化(常量在连接阶段就存入调用类的常量池中了)
4、ClassLoader的理解
1、类加载器的作用
- 类加载器的作用：将Class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时的数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口
- 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间，不过jvm垃圾回收机制可以回收这些Class对象
2、最常用方法
getResoureAsStream(String str)：获取类路径下的指定文件的输入流。
InputStream in = this.getClass().getClassLoader().getResourceAsStream("test.properties");
5、获取运行时的完整结构
1、Class类及其用法
| 方法名 | 说明 |
|---|---|
| forName() | 获取Class对象的一个引用 |
| getName() | 取全限定的类名(包括包名)，即类的完整名字 |
| getSimpleName() | 获取类名(不包括包名) |
| isInterface() | 判断Class对象是否是表示一个接口 |
| getInterfaces() | 返回Class对象数组，表示Class对象所引用的类所实现的所有接口 |
| getSupercalss() | 返回Class对象，表示Class对象所引用的类所继承的直接基类。应用该方法可在运行时发现一个对象完整的继承结构。 |
| getAnnotations() | 以Annotation[]形式返回注解信息 |
| newInstance() | 返回一个Oject对象，是实现“虚拟构造器”的一种途径。使用该方法创建的类，必须带有无参的构造器。 |
| getFields() | 获得所有public修饰的属性，包含本类以及父类的 |
| getDeclaredFields() | 获得本类中的所有属性 |
| getMethods() | 获取所有pubilc修饰的方法，包含本类以及父类的 |
| getDeclaredMethods() | 获取本类中的所有方法 |
| getConstructots() | 获取本类中所有public修饰的构造器 |
| getDeclaredConstructors() | 获取本类中的所有构造器 |
2、Field类及其用法
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| Field | getDeclaredField(String name) | 获取指定name名称的(包含private修饰的)字段，不包括继承的字段 |
| Field[] | getDeclaredFields() | 获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段 |
| Field | getField(String name) | 获取指定name名称、具有public修饰的字段，包含继承字段 |
| Field[] | getFields() | 获取修饰符为public的字段，包含继承字段 |
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| void | set(Object obj, Object value) | 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。 |
| Object | get(Object obj) | 返回指定对象上此 Field 表示的字段的值 |
| Class<?> | getType() | 返回一个 Class 对象，它标识了此Field 对象所表示字段的声明类型。 |
| String | getName() | 返回此 Field 对象表示的字段的名称 |
| void | setAccessible(boolean flag) | 将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性 |
3、Method类及其用法
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| Method | getDeclaredMethod(String name, Class<?>... parameterTypes) | 返回一个指定参数的Method对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。 |
| Method[] | getDeclaredMethods() | 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 |
| Method | getMethod(String name, Class<?>... parameterTypes) | 返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。 |
| Method[] | getMethods() | 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。 |
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| Object | invoke(Object obj, Object... args) | 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。 |
| Class<?> | getReturnType() | 返回一个 Class 对象，该对象描述了此 Method 对象所表示的方法的正式返回类型,即方法的返回类型 |
| Class<?>[] | getParameterTypes() | 按照声明顺序返回 Class 对象的数组，这些对象描述了此 Method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组 |
| String | getName() | 以 String 形式返回此 Method 对象表示的方法名称，即返回方法的名称 |
4、Constructor类及其用法
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| Constructor | getConstructor(Class<?>... parameterTypes) | 返回指定参数类型、具有public访问权限的构造函数对象 |
| Constructor<?>[] | getConstructors() | 返回所有具有public访问权限的构造函数的Constructor对象数组 |
| Constructor | getDeclaredConstructor(Class<?>... parameterTypes) | 返回指定参数类型、所有声明的（包括private）构造函数对象 |
| Constructor<?>[] | getDeclaredConstructor() | 返回所有声明的（包括private）构造函数对象 |
| T | newInstance() | 调用无参构造器创建此 Class 对象所表示的类的一个新实例。 |
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
//通过反射获取类的结构信息
public class ReflectionUtils {
@Test
public void api_02() throws Exception {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getDeclaredFields:获取本类中所有属性
//规定 说明: 默认修饰符 是0 ， public 是1 ，private 是 2 ，protected 是 4 , static 是 8 ，final 是 16
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName()
+ " 该属性的修饰符值=" + declaredField.getModifiers()
+ " 该属性的类型=" + declaredField.getType());
}
//getDeclaredMethods:获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("本类中所有方法=" + declaredMethod.getName()
+ " 该方法的访问修饰符值=" + declaredMethod.getModifiers()
+ " 该方法返回类型" + declaredMethod.getReturnType());
//输出当前这个方法的形参数组情况
Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println("该方法的形参类型=" + parameterType);
}
}
//getDeclaredConstructors:获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("====================");
System.out.println("本类中所有构造器=" + declaredConstructor.getName());
Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
for (Class<?> parameterType : parameterTypes) {
System.out.println("该构造器的形参类型=" + parameterType);
}
}
}
//第一组方法API
@Test
public void api_01() throws Exception {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getName:获取全类名
System.out.println(personCls.getName());
//getSimpleName:获取简单类名
System.out.println(personCls.getSimpleName());
//getFields:获取所有public修饰的属性，包含本类以及父类的
Field[] fields = personCls.getFields();
for (Field field : fields) {
System.out.println("本类以及父类的属性=" + field.getName());
}
//getDeclaredFields:获取本类中所有属性
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("本类中所有属性=" + declaredField.getName());
}
//getMethods:获取所有public修饰的方法，包含本类以及父类的
Method[] methods = personCls.getMethods();
for (Method method : methods) {
System.out.println("本类以及父类的方法=" + method.getName());
}
//getDeclaredMethods:获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("本类中所有方法=" + declaredMethod.getName());
}
//getConstructors: 获取所有public修饰的构造器，包含本类
Constructor<?>[] constructors = personCls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println("本类的构造器=" + constructor.getName());
}
//getDeclaredConstructors:获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("本类中所有构造器=" + declaredConstructor.getName());
}
//getPackage:以Package形式返回 包信息
System.out.println(personCls.getPackage());
//getSuperClass:以Class形式返回父类信息
Class<?> superclass = personCls.getSuperclass();
System.out.println("父类的class对象=" + superclass);
//getInterfaces:以Class[]形式返回接口信息
Class<?>[] interfaces = personCls.getInterfaces();
for (Class<?> anInterface : interfaces) {
System.out.println("接口信息=" + anInterface);
}
//getAnnotations:以Annotation[] 形式返回注解信息
Annotation[] annotations = personCls.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("注解信息=" + annotation);
}
}
}
class A {
public String hobby;
public void hi() {
}
public A() {
}
public A(String name) {
}
}
interface IA {
}
interface IB {
}
@Deprecated
class Person extends A implements IA, IB {
public String name;
protected static int age; // 4 + 8 = 12
String job;
private double sal;
//构造器
public Person() {
}
public Person(String name) {
}
//私有的
private Person(String name, int age) {
}
//方法
public void m1(String name, int age, double sal) {
}
protected String m2() {
return null;
}
void m3() {
}
private void m4() {
}
}
