Java 第三阶段增强分析需求，代码实现能力【反射】
代码链接：https://download.csdn.net/download/qq_52354698/86461082?spm=1001.2014.3001.5501
1. 反射机制
1. Java Reflection
- 反射机制运行程序在执行期间借助于 ReflectionAPI 取得任何类的内部信息（比如成员变量，构造器，成员方法等待），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
- 加载完类，在堆中就产生了一个 Class 类型的对象（一个类只有一个 Class 对象），这个对象包含了类的完整结构信息。通过这个对象到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射。
2. Java 反射机制原理示意图
3. Java 反射机制可以完成
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时得到任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
- 生成动态代理
4. 反射相关的主要类
- java.lang.Class:代表一个类， Class对象表示某 个类加载后在堆中的对象
- java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法
- java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量
- java.lang.reflect.Constructor代表类的构造方法，Constructor对象表示构造器
package com.qdu.reflection;
import java.io.FileInputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Properties;
/**
* @author dell
* @version 1.0
*/
public class Reflection01 {
public static void main(String[] args) throws Exception {
//1. 使用Properties 类, 可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("src\\re.properties"));
String classfullpath = properties.get("classfullpath").toString();//"com.qdu.Cat"
String methodName = properties.get("method").toString();//"hi"
//2. 使用反射机制解决
//(1) 加载类, 返回Class类型的对象cls
Class cls = Class.forName(classfullpath);
//(2) 通过 cls 得到你加载的类 com.qdu.Cat 的对象实例
Object o = cls.newInstance();
System.out.println("o的运行类型=" + o.getClass()); //运行类型
//(3) 通过 cls 得到你加载的类 com.qdu.Cat 的 methodName"hi" 的方法对象
// 即：在反射中，可以把方法视为对象（万物皆对象）
Method method1 = cls.getMethod(methodName);
//(4) 通过method1 调用方法: 即通过方法对象来实现调用方法
System.out.println("=============================");
method1.invoke(o); //传统方法 对象.方法() , 反射机制 方法.invoke(对象)
//java.lang.reflect.Field: 代表类的成员变量, Field对象表示某个类的成员变量
//得到name字段
//getField不能得到私有的属性
Field nameField = cls.getField("age"); //
System.out.println(nameField.get(o)); // 传统写法 对象.成员变量 , 反射 : 成员变量对象.get(对象)
//java.lang.reflect.Constructor: 代表类的构造方法, Constructor对象表示构造器
Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型, 返回无参构造器
System.out.println(constructor);//Cat()
Constructor constructor2 = cls.getConstructor(String.class); //这里老师传入的 String.class 就是String类的Class对象
System.out.println(constructor2);//Cat(String name)
}
}
5. 反射有点和缺点
- 优点：可以动态的创建和使用对象（也是框架底层的核心），使用；灵活，没有反射机制，框架技术就失去底层支撑。
- 缺点：使用反射基本是解释执行，对执行速度有影响。
package com.qdu.reflection;
import com.qdu.Cat;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author dell
* @version 1.0
* 测试反射调用性能和优化方案
*/
public class Reflection02 {
public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchMethodException {
m1();
m2();
}
//普通方法
public static void m1(){
Cat cat = new Cat();
long start = System.currentTimeMillis();
for (int i = 0; i < 90000000; i ++ ){
cat.hi();
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
//反射机制
public static void m2() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.qdu.Cat");
Object o = cls.newInstance();
Method hi = cls.getMethod("hi");
long start = System.currentTimeMillis();
for (int i = 0; i < 90000000; i ++ ){
hi.invoke(o);
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
}
6. 反射调用优化-关闭访问检查
- Method 和 Field、Constructor 对象都有 setAccessible() 方法
- setAccessible 左右是启动和禁用访问安全检查的开关
- 参数值为 true 表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false 则表示反射的对象执行访问检查。
public static void m3() throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
Class cls = Class.forName("com.qdu.Cat");
Object o = cls.newInstance();
Method hi = cls.getMethod("hi");
hi.setAccessible(true);
long start = System.currentTimeMillis();
for (int i = 0; i < 90000000; i ++ ){
hi.invoke(o);
}
long end = System.currentTimeMillis();
System.out.println(end - start);
}
2. Class类
1. 基本介绍
- Class 类也是类，继承自 Object 类
- Class 类不是 new 出来的，而是系统创建的
- 对于某个类的 Class 类对象，在内存中只有一份，因为类只加载一次
- 每个类的实例都会记得自己是由那个 Class 实例所生成的
- 通过 Class 对象可以完整地得到一个类的完整结构，通过一些列 API
- Class 独享是存放在堆中的
- 类的字节码二进制数据，是放在方法区的，有的地方称为类的元数据（包括方法飞马、变量名、方法名、访问权限等等）
2. Class 类的常用方法
package com.qdu.reflection.class_;
import com.qdu.Car;
import java.lang.reflect.Field;
/**
* @author dell
* @version 1.0
*/
public class Class02 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
String classAllPath = "com.qdu.Car";
//获取到Car类，对应的Class对象
//<?>表示不确定的Java类型
Class<?> cls = Class.forName(classAllPath);
//输出cls
System.out.println(cls);
//输出cls运行类型
System.out.println(cls.getClasses());
//得到包名
System.out.println(cls.getPackage().getName());
//得到类名
System.out.println(cls.getName());
//通过cls创建对象实例
Car car = (Car) cls.newInstance();
System.out.println(car);
//通过反射获取属性
Field brand = cls.getField("brand");
System.out.println(brand.get(car));
//通过反射给属性赋值
brand.set(car, "奔驰");
System.out.println(brand.get(car));
//遍历所有属性
Field[] fields = cls.getFields();
for (Field field : fields){
System.out.println(field.getName());
}
}
}
3. 获取Class对象六种方式
前提：一直一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取。
实例：Class cls1 = Class.forName("java.lang.Cat");
应用场景：多用于配置文件，读取类全路径，加载类。前提：若已知具体的类，通过类的class获取，该方式最为安全可靠，程序性能最高。
实例：Class cls2 = Cat.class;
应用场景：多用于参数传递，比如通过反射得到对应构造器对象前提：已知某个类的实例，调用该实例的getClass()方式获取Class对象
实例：Class clazz = 对象.getClass();
应用场景：通过创建好的对象，获取Class对象其他方式
ClassLoader cl = 对象.getClass().getClassLoader();
Class clazz4 = cl.loadClass("类的全类名");
- 基本数据按如下方式得到Class类对象
Class cls = 基本数据类型.class
- 基本数据类型对应的包装类，可以通过.TYPE得到Class类对象
Class cls = 包装类.TYPE
4. 那些类型有Class对象
- 外部类，成员内部类，静态内部类，局部内部类，匿名内部类
- interface :接口
- 数组
- enum :枚举
- annotation :注解
- 基本数据类型
- void
package com.qdu.reflection.class_;
import java.io.Serializable;
/**
* @author dell
* @version 1.0
*/
public class AllTypeClass {
public static void main(String[] args) {
Class<String> stringClass = String.class;
Class<Serializable> serializableClass = Serializable.class;
Class<Integer[]> integerClass = Integer[].class;
Class<float[][]> floatClass = float[][].class;
Class<Deprecated> deprecatedClass = Deprecated.class;
Class<Thread.State> stateClass = Thread.State.class;
Class<Long> longClass = Long.class;
Class<Void> voidClass = Void.class;
Class<Class> classClass = Class.class;
System.out.println(stringClass);
System.out.println(serializableClass);
System.out.println(integerClass);
System.out.println(floatClass);
System.out.println(deprecatedClass);
System.out.println(stateClass);
System.out.println(longClass);
System.out.println(voidClass);
System.out.println(classClass);
}
}
5. 类加载
1. 基本说明
反射机制是java实现动态语言的关键，也就是通过反射实现类动态加载。
- 静态加载：编译时加载相关的类，如果没有则报错，依赖性太强。
- 动态加载：运行时加载需要的类没如果运行时不用该类，即使不存在该类，也不报错，降低了依赖性。
2. 类加载时机
- 创建对象时（new）：静态加载
- 当子类被加载时，父类也加载：静态加载
- 调用类中的静态成员时：静态加载
- 通过反射：动态加载
3. 类加载过程图
4. 类记载各阶段完成任务
5. 加载阶段
JVM 在该阶段的主要目的是将字节码从不同的数据源（可能是class文件，也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lan.Class对象
6. 连接阶段-验证
- 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。
- 包括：文件格式验证（是否以魔数 oxcafebabe开头）、元数据验证、字节码验证和符号引用验证。
- 可以考虑使用 -Xverify:none 参数来关闭大部分的验证措施，缩短虚拟机类加载的时间。
7. 连接阶段-准备
JVM 会在该阶段对静态变量，分配内存并默认初始化（对于不同的数据默认初始化的值不同（0，null，0L，false等））。这些变量所使用的北村都将在方法区中进行分配。
8. 连接阶段-解析
9. Initialization（初始化）
- 到初始化阶段，才真正开始执行类中定义的java代码，此阶段是执行 < clinit>() 方法的过程。
- < clinit>() 方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
- 虚拟机会保证一个类的< clinit>() 方法在多线程环境中被正确地枷锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的< clinit>() 方法，其他线程都需要阻塞等待，知道活动线程执行< clinit>() 方法完毕。
6. 反射获取类的结构信息
1. 第一组：java.lang.Class类
- getName:获取全类名
- getSimpleName:获取简单类名
- getFields:获取所有public修饰的属性，包含本类以及父类的
- getDeclaredFields:获取本类中所有属性
- getMethods:获取所有public修饰的方法，包含本类以及父类的
- getDeclaredMethods:获取本类中所有方法
- getConstructors:获取本类所有public修饰的构造器
- getDeclaredConstructors:获取本类中所有构造器
- getPackage:以Package形式返回 包信息
- getSuperClass:以Class形式返回父类信息
- getInterfaces:以Class[]形式返回接口信息
- getAnnotations:以Annotation[]形式返回注解信息
@Test
public void api_01() throws ClassNotFoundException {
Class<?> personCls = Class.forName("com.qdu.reflection.Person");
System.out.println(personCls.getName());
System.out.println(personCls.getSimpleName());
Field[] fields = personCls.getFields();
for (Field field : fields){
System.out.println(field.getName());
}
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField.getName());
}
Method[] methods = personCls.getMethods();
for (Method method : methods) {
System.out.println(method.getName());
}
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println(declaredMethod.getName());
}
Constructor<?>[] constructors = personCls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println(constructor.getName());
}
Constructor<?>[] declaredConstructor = personCls.getDeclaredConstructors();
for (Constructor<?> constructor : declaredConstructor) {
System.out.println(constructor.getName());
}
System.out.println(personCls.getPackage());
Class<?> superclass = personCls.getSuperclass();
System.out.println(superclass);
Class<?>[] anInterface = personCls.getInterfaces();
for (Class<?> aClass : anInterface) {
System.out.println(aClass);
}
Annotation[] annotations = personCls.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotations);
}
}
2. 第二组：java.lang.reflect.Field类
- getModifiers:以int形式返回修饰符[说明:默认修饰符是0 , public 是1，private是2 , protected是4, static是8 , final 是16] , public(1) + static (8) = 9
- getType:以Class形式返回类型
- getName:返回属性名
@Test
public void api_02() throws ClassNotFoundException {
Class<?> personCls = Class.forName("com.qdu.reflection.Person");
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println(declaredField.getName() + " " + declaredField.getModifiers() + " " + declaredField.getType());
}
}
3. 第三组：java.lang.reflect.Method类
- getModifiers:以int形式返回修饰符[说明:默认修饰符是0，public 是1 , private是2， protected是4, static是8 , final 是16]
- getReturnType:以Class形式获取返回类型
- getName:返回方法名
- getParameter Types:以Class[]返回参数类型数组
@Test
public void api_03() throws ClassNotFoundException {
Class<?> personCls = Class.forName("com.qdu.reflection.Person");
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);
}
}
}
4. 第四组：java.lang.reflect.Constructor类
- getModifiers:以int形式返回修饰符
- getName:返回构造器名(全类名)
- getParameterTypes:以Class[]返回参数类型数组
7. 通过反射创建对象
方式一：调用类中的public修饰无参构造器
方式二：调用类中的指定构造器
Class类相关方法
newInstance：调用类中的无参构造器，获取对应类的对象
getConstructor(Class…clazz)：根据参数列表，获取对应的public构造器对象
getDecalaredConstructor(Class…clazz)：根据参数列表，获取对应的所有构造其对象Constructor类相关方法
setAccessible：暴破
newInstance(Object…obj)：调用构造器
package com.qdu.reflection;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
/**
* @author dell
* @version 1.0
*/
public class ReflecCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//先获取到User类的Class对象
Class<?> userClass = Class.forName("com.qdu.reflection.User");
//通过public的无参构造器创建实例
Object o = userClass.newInstance();
System.out.println(o);
//通过public的有参构造器创建实例
Constructor<?> constructor = userClass.getConstructor(String.class);
Object o1 = constructor.newInstance("qdu...");
System.out.println(o1);
//通过非public的有参构造器创建实例
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
constructor1.setAccessible(true);//暴破（暴力破解）：使用反射可以访问私有的private构造器/方法/属性
Object o2 = constructor1.newInstance(99, "qdu...hi");
System.out.println(o2);
}
}
class User{
private int age = 10;
private String name = "qdu";
public User(){
}
public User(String name) {
this.name = name;
}
private User(int age, String name) {
this.age = age;
this.name = name;
}
@Override
public String toString() {
return "User{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
8. 通过反射访问类中的成员
1. 访问属性
根据属性获取Field对象
Field f = clazz对象.getDeclaredField(属性名);暴破：f.setAccessible(true);//f 是Field
访问
f.set(o, 值);//o 表示对象
syso(f.get(o));//o 表示对象
注意：如果是静态属性，则set和get中的参数o，可以写成null
package com.qdu.reflection;
import java.lang.reflect.Field;
/**
* @author dell
* @version 1.0
*/
public class RelecAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
//得到Student类对应的Class对象
Class<?> stuClass = Class.forName("com.qdu.reflection.Student");
//创建对象
Object o = stuClass.newInstance();
System.out.println(o.getClass());
//使用反射得到age属性对象
Field age = stuClass.getField("age");
age.set(o, 88);//通过反射来操作属性
System.out.println(o);
System.out.println(age.get(o));
//使用反射操作name属性
Field name = stuClass.getDeclaredField("name");
name.setAccessible(true);//对name进行暴破：可以操作private属性
name.set(o, "qdu...hi...");
System.out.println(name.get(o));
name.set(null, "hello");//因为name是static属性，因此o也可以写成null
System.out.println(name.get(null));
}
}
class Student{
public int age;
private static String name;
public Student() {
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}
2. 访问方法
- 根据方法名和参数列表获取Method方法对象: Method m = clazz.getDeclaredMethod(方法名，XX.class); //得到本类的所有方法
- 获取对象: Object o= clazz.newlnstance();
- 暴破: m.setAccessible(true);
- 访问: Object returnValue = m.invoke(o,实参列表);//o就是对象
- 注意:如果是静态方法，则invoke的参数o,可以写成null!
package com.qdu.reflection;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
* @author dell
* @version 1.0
*/
public class ReflecAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//得到Boss类对应的Class对象
Class<?> bossClass = Class.forName("com.qdu.reflection.Boss");
//创建对象
Object o = bossClass.newInstance();
//调用public的hi方法
// Method hi = bossClass.getMethod("hi", String.class);
Method hi = bossClass.getDeclaredMethod("hi", String.class);
hi.invoke(o, "hello...qdu...");
//调用private static 方法
Method say = bossClass.getDeclaredMethod("say", int.class, String.class, char.class);
say.setAccessible(true);//因为say方法是私有的，所以需要暴破
System.out.println(say.invoke(o, 100, "小明", '女'));
}
}
class Boss{
public int age;
private static String name;
public Boss() {
}
private static String say(int n, String s, char c){
return n + " " + s + " " + c;
}
public void hi(String s){
System.out.println("hi " + s);
}
}
