反射学习笔记
一、反射入门案例
- 在反射中，万物皆对象，方法也是对象。
- 反射可以在不修改源码的情况下，只需修改配置文件，就能实现功能的改变。
实体类
/*** 动物猫类*/
public class Cat {private String name;public void hi(){System.out.println("hi "+name);}public void cry(){System.out.println(name+"喵喵喵...");}
}
re.properties配置文件
classfullpath=pers.jl.Cat
method=hi
反射demo
@SuppressWarnings({"all"})//抑制编译器的某些警告
public class ReflectionApplication {public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {//读取配置文件Properties properties = new Properties();properties.load(new FileInputStream("src/main/resources/re.properties"));//从配置文件重读取属性String classfullpath = properties.getProperty("classfullpath").toString();String methodName = properties.getProperty("method").toString();System.out.println("=======================================");// 根据类名加载类Class cls = Class.forName(classfullpath);// 获得类的实例Object o = cls.newInstance();// 打印对象的运行类型System.out.println("对象的运行类型是："+o.getClass());System.out.println("=======================================");// 根据方法名，获取类的方法对象Method method = cls.getMethod(methodName);// 通过方法对象实现调用方法method.invoke(o);}
}
二、反射机制
- 反射机制允许程序在执行期间借助于ReflectionAPI取得任何类的内部信息(比如成员变量，构造器，成员方法等)，并能操作对象的属性及方法。
- 加载完类后，在堆中就产生了一个Class类型的对象，这个对象包含了类的完整结构信息，我们可以通过这个对象得到类的结构。这个Class对象就像一面镜子，透过这个镜子看到类的结构，所以，形象的称之为：反射。
- 三个阶段逻辑：一个类的源码编译之后生成字节码文件也就是Class文件，然后经过类加载器ClassLoader在堆中加载了一个Class类对象，包含类源码中所有的属性和方法等，并且都用数组存放，比如成员变量都放在一个Fidld[]数组中，方法都放在一个Method[]数组中，然后我们就可以使用这个Class类对象new一个该类对象并调用该对象的方法。由于类对象和Class类对象一一对应，所以在后续中我们也可以从类对象直到该类对象的Class类对象，然后就可以进行一系列的操作。
反射相关类
-
java反射机制可以完成什么
- 在运行时判断一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时得到任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
- 生成动态代理
-
主要类
- java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象
- java.lang.reflect.Method:表示类的方法，Method对象标识某个类的方法
- java.lang.reflect.Field:代表类的成员变量，Field对象标识某个类的成员变量
- java.lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器
-
getField()方法不能得到私有的属性。
-
反射中，方法也好，成员变量也好，调用都是它们调用对象，反过来的，比如：成员变量.get(对象)就可以拿到成员变量的值。
System.out.println("=======================================");
Field field = cls.getField("age");
System.out.println("类中的成员变量年龄:"+field.get(o));Constructor constructor = cls.getConstructor();
System.out.println("无参构造："+constructor);Constructor constructor1 = cls.getConstructor(String.class);
System.out.println("有参构造："+constructor1);
反射调用优化
- 反射的优缺点
- 优点：可以动态的创建和使用对象(也是框架底层核心)，使用灵活，没有反射机制，框架技术就失去底层支撑。
- 缺点：使用反射基本是解释执行，对执行速度有影响。
- 反射调用优化(轻微优化)
- Method和Field、Constructor对象都有setAccessible()方法，setAccessible()的作用是启动和禁用访问安全检查的开关。
- 参数值为true表示反射的对象在使用时取消访问检查，提高反射的效率。参数值为false则表示反射的对象执行访问检查。
- 优化案例
/*** @author 鹿先生* @version 1.0* 测试反射调用的性能，和优化方案*/
@SuppressWarnings({"all"})
public class Reflection2 {public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {//Field//Method//Constructorm1();//传统m2();//反射m3();//反射优化}//传统方法来调用 hipublic static void m1() {Cat cat = new Cat();long start = System.currentTimeMillis();for (int i = 0; i < 90; i++) {cat.hi();}long end = System.currentTimeMillis();System.out.println("m1() 耗时=" + (end - start));}//反射机制调用方法 hipublic static void m2() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class cls = Class.forName("pers.jl.Cat");Object o = cls.newInstance();Method hi = cls.getMethod("hi");long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {hi.invoke(o);//反射调用方法}long end = System.currentTimeMillis();System.out.println("m2() 耗时=" + (end - start));}//反射调用优化 + 关闭访问检查public static void m3() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {Class cls = Class.forName("pers.jl.Cat");Object o = cls.newInstance();Method hi = cls.getMethod("hi");hi.setAccessible(true);//在反射调用方法时，取消访问检查long start = System.currentTimeMillis();for (int i = 0; i < 900000000; i++) {hi.invoke(o);//反射调用方法}long end = System.currentTimeMillis();System.out.println("m3() 耗时=" + (end - start));}
}
注意：查看类图更加方便理解类之间的关系，ctrl + alt + p查看该类的父类。
三、Class类
Class类分析
- Class也是类，因此也继承Object类。
- Class类对象不是new出来的，而是系统创建的。
- 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次。
- 每个类的实例都会记得自己是由哪个Class实例所生成。
- 通过Class对象可以完整地得到一个类的完整结构，同各国一系列API。
- Class对象是存放在堆的。
- 类的字节码二进制数据，是放在方法区的(在堆中创建Class对象时，就会在方法区创建该类字节码的二进制数据，二者之间有一些关系)，有的地方称为类的元素据(包括方法代码，变量名，方法名，访问权限等等)
- 可以通过获取Class类对象的hashcode值判断Class类对象是否是同一个。
常用方法
- 注意方法调用，打印字段都是反过来的。
/*** 演示class类的一些常用方法*/
@SuppressWarnings({"all"})
public class Reflection3 {public static void main(String[] args) throws Exception{//获取类名路径String classAllPath = "pers.jl.Car";// 1. 根据类名加载Class对象Class<?> cls = Class.forName(classAllPath);// 2. 输出clsSystem.out.println("Class对象类型："+cls);// class pers.jl.CarSystem.out.println("Class对象的运行类型："+cls.getClass());// class java.lang.Class// 3. 获取包名System.out.println("包名："+cls.getPackage().getName());// pers.jl// 4. 获取全类名System.out.println("全类名："+cls.getName());// pers.jl.Car// 5. 获取对象实例Car car = (Car) cls.newInstance();System.out.println("对象："+car);// Car{brand='宝马', price=500000, color='红色'}// 6. 通过属性名获取对象属性(正常情况下智能获取共有属性)Field brand = cls.getField("brand");System.out.println("对象属性："+brand.get(car));// 宝马// 7. 通过反射修改属性值brand.set(car,"奔驰");System.out.println("对象属性："+brand.get(car));// 奔驰// 8. 获取对象中的所有属性System.out.println("=========对象中的所有属性=========");for (Field field : cls.getFields()) {System.out.println("属性名："+field.getName());}}
}
四、获取Class类对象
- 四种方法
- Class.forName(代码阶段/编译阶段)
- 类名.class,应用场景: 用于参数传递(Class类加载阶段)
- 对象.getClass(),应用场景，有对象实例(RunTime运行阶段)
- 通过类加载器(4种)来获取到类的 Class 对象(编译阶段与Class类加载阶段之间)
/*** 获取Class对象的六种方式()本质上只有四种*/
public class Reflection4 {public static void main(String[] args) throws Exception {// 1. Class.forName(代码阶段/编译阶段)String classAllPath = "pers.jl.Car";Class<?> cls1 = Class.forName(classAllPath);System.out.println("方法一："+cls1);// 2. 类名.class,应用场景: 用于参数传递(Class类加载阶段)Class<Car> cls2 = Car.class;System.out.println("方法二："+cls2);// 3. 对象.getClass(),应用场景，有对象实例(RunTime运行阶段)Car car = new Car();Class<? extends Car> cls3 = car.getClass();System.out.println("方法三："+cls3);// 4. 通过类加载器(4种)来获取到类的 Class 对象(编译阶段与Class类加载阶段之间)ClassLoader classLoader = car.getClass().getClassLoader();Class<?> cls4 = classLoader.loadClass(classAllPath);System.out.println("方法四："+cls4);// 注：上述四种方法获取到的Class类对象都是同一个，因为堆中只会存放一个System.out.println("===============四种方法得到的Class类对象hashCode值=============");System.out.println(cls1.hashCode());System.out.println(cls2.hashCode());System.out.println(cls3.hashCode());System.out.println(cls4.hashCode());// 5. 基本数据(int,char,boolean,float,double,byte,long,short)按如下方式得到Class类对象System.out.println("===============直接打印基础数据类型的Class类对象=============");Class<Integer> integerClass = int.class;Class<Character> characterClass = char.class;Class<Double> doubleClass = double.class;System.out.println(integerClass);System.out.println(characterClass);System.out.println(doubleClass);// 6. 基本数据类型对应的包装类，可以通过.TYPE得到Class类对象System.out.println("===============直接打印基础数据类型的包装类的Class类对象=============");Class<Integer> type = Integer.TYPE;Class<Character> type1 = Character.TYPE;Class<Double> type2 = Double.TYPE;System.out.println(type);System.out.println(type1);System.out.println(type2);// 注：基础数据类型的Class类对象和包装类的Class类对象是同一个System.out.println("===============基础数据类型和包装类得到的Class类对象hashCode值=============");System.out.println(integerClass.hashCode());System.out.println(type.hashCode());}
}
五、哪些类型有Class类对象
如下类型有Class对象
- 外部类，成员内部类，静态内部类，局部内部类，匿名内部类。
- interface:接口
- 数组
- enum:枚举
- annotation:注解
- 基本数据类型
- void
/*** 查看哪些类有Class对象*/
@SuppressWarnings({"all"})
public class Reflection5 {public static void main(String[] args) {System.out.println("=====================打印这些Class类对象=======================");Class<String> cls1 = String.class;//外部类Class<Serializable> cls2 = Serializable.class;//接口Class<Integer[]> cls3 = Integer[].class;//数组Class<float[][]> cls4 = float[][].class;//二维数组Class<Deprecated> cls5 = Deprecated.class;//注解Class<Thread.State> cls6 = Thread.State.class;//枚举Class<Long> cls7 = long.class;//基础数据类型Class<Void> cls8 = void.class;//void数据类型System.out.println(cls1);System.out.println(cls2);System.out.println(cls3);System.out.println(cls4);System.out.println(cls5);System.out.println(cls6);System.out.println(cls7);System.out.println(cls8);}
}
六、类加载
基本说明
-
反射机制是Java实现动态语言的关键，也就是通过反射实现类动态加载。
-
静态加载：编译时加载相关的类，如果没有则报错，依赖性太强。
-
动态加载(延时加载)：运行时加载需要的类，如果运行时不使用该类，即使不存在该类，则不报错，降低了依赖性。
-
类加载时机
- 当创建对象时(new)
- 当子类被加载时，父类也被加载。
- 调用类中的静态成员时。
- 通过反射
注：前三种都是静态加载，最后一种是动态加载。
类加载案例
/*** 类的静态加载和动态加载*/
public class classloadtest {public static void main(String[] args) throws Exception {Scanner scanner = new Scanner(System.in);System.out.println("请输入key:");String key = scanner.next();switch (key) {case "1":Dog dog = new Dog();dog.cry();break;case "2":Class<?> cls = Class.forName("pers.jl.Person");Object o = cls.newInstance();Method method = cls.getMethod("hi");method.invoke(o);System.out.println("ok");break;default:System.out.println("do nothing..");break;}}
}//因为new Dog()是静态加载，没有编写Dog类，编译时就会报错
//Person类是动态加载，所以没有编写Person类也不会报错，只有动态加载该类时，才会报错
class Dog {public void cry() {System.out.println("小狗汪汪汪！");}
}class Person {public void hi() {System.out.println("小孩，hi!");}
}
类加载过程图
类加载各阶段完成任务
七、通过反射获取类的结构信息
java.lang.Class类
getName;//获取全类名
getSimpleName;//获取简单类名
getFields;//获取所有public修饰的属性，包含本类以及父类的
getDeclaredFields;//获取本类中的所有属性
getMethods;//获取所有public修饰的方法，包含本类以及父类的
getDeclaredMthods;//获取本类中的所有方法
getConsructors;//获取本类所有public修饰的构造器
getDeclaredConstructors;//获取本类中的所有构造器
getPackage;//以Package形式返回包信息
getSuperClass;//以Class类形式返回父类信息
getInterfaces;//以Class[]形式返回接口信息
getAnnotations://以Annotation[]形式返回注解信息
java.lang.reflect.Field类
getModifiers;//以int形式返回修饰符{默认修饰符是0，public是1，private是2，protected是4，static是8，final是0，public(1) + static(8) = 9}
getType;//以Class形式返回类型
getName;//返回属性名
java.lang.reflect.Method类
getModifiers;//以int形式返回修饰符{默认修饰符是0，public是1，private是2，protected是4，static是8，final是0，public(1) + static(8) = 9}
getReturnType;//以Class形式获取返回类型
getName;//返回方法名
getParameterTypes;//以Class[]返回参数类型数组
java.lang.reflect.Constructor类
getModifiers;//以int形式返回修饰符{默认修饰符是0，public是1，private是2，protected是4，static是8，final是0，public(1) + static(8) = 9}
getName;//返回构造器名
getParameterTypes;//以Class[]返回参数类型数组
八、通过反射创建对象
1.方式一：调用类中的public修饰的无参构造器
2.方式二：调用类中的指定构造器
3.Class类相关方法
- newInstance:调用类中的无参构造器，获取对应类的对象。
- getConstryctor(Class…clazz):根据参数列表，获取对应的public构造器对象
- getDecalaredConstructoe(Class…clazz):根据参数列表，获取对应的所有构造器对象
4.Contructor类相关方法
- setAccessible:爆破
- newInstance(Object…obj):调用构造器
5. 代码案例
public class Reflection6 {public static void main(String[] args) throws Exception {//1. 先获取到 User 类的 Class 对象Class<?> userClass = Class.forName("pers.jl.User");//2. 通过 public 的无参构造器创建实例Object o = userClass.newInstance();System.out.println(o);//3. 通过 public 的有参构造器创建实例//3.1 先得到对应构造器Constructor<?> constructor = userClass.getConstructor(String.class);//3.2 创建实例，并传入实参Object hsp = constructor.newInstance("hsp");System.out.println("hsp=" + hsp);//4. 通过非 public 的有参构造器创建实例//4.1 得到 private 的构造器对象Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);//4.2 创建实例//暴破【暴力破解】 , 使用反射可以访问 private 构造器/方法/属性, 反射面前，都是纸老虎constructor1.setAccessible(true);Object user2 = constructor1.newInstance(100, "张三丰");System.out.println("user2=" + user2);}
}class User { //User 类private int age = 10;private String name = "韩顺平教育";public User() {//无参 public}public User(String name) {//public 的有参构造器this.name = name;}private User(int age, String name) {//private 有参构造器this.age = age;this.name = name;}@Overridepublic String toString() {return "User [age=" + age + ", name=" + name + "]";}
}
九、通过反射访问类中的成员
访问属性
-
根据属性名获取Field对象
Fidle f = clazz对象.getDeclaredField(属性名)；
-
暴破：f.setAccessible(true);//f是Field
-
访问
f.set(o,值)；//o表示对象
syso(f.get(o));//o表示对象
注：如果是静态属性，则set和get中的参数o，可以写成null
代码示例
public class Reflection {public static void main(String[] args) throws Exception {//1. 得到 Student 类对应的 Class 对象Class<?> stuClass = Class.forName("pers.jl.Student");//2. 创建对象Object o = stuClass.newInstance();//o 的运行类型就是 StudentSystem.out.println(o.getClass());//Student//3. 使用反射得到 age 属性对象Field age = stuClass.getField("age");age.set(o, 88);//通过反射来操作属性System.out.println(o);//System.out.println(age.get(o));//返回 age 属性的值//4. 使用反射操作 name 属性Field name = stuClass.getDeclaredField("name");//对 name 进行暴破, 可以操作 private 属性name.setAccessible(true);//name.set(o, "老韩");name.set(null, "老韩~");//因为 name 是 static 属性，因此 o 也可以写出 nullSystem.out.println(o);System.out.println(name.get(o)); //获取属性值System.out.println(name.get(null));//获取属性值, 要求 name 是 stati}
}class Student {//类public int age;private static String name;public Student() {//构造器}
}
访问方法
- 根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名，XX.class);//得到本类的所有方法
- 获取对象：Object o = clazz.newInstance();
- 暴破：m.setAccessible(true);
- 访问：Object returnValue = m.invoke(o,实参列表)；//o就是对象
注：如果是静态方法，则invoke的参数o,可以写成null!
代码示例
public class Reflection7 {public static void main(String[] args) throws Exception {//1. 得到 Boss 类对应的 Class 对象Class<?> bossCls = Class.forName("pers.jl.Boss");//2. 创建对象Object o = bossCls.newInstance();//3. 调用 public 的 hi 方法//3.1 得到 hi 方法对象Method hi = bossCls.getMethod("hi", String.class);//OK//3.2 调用hi.invoke(o, "韩顺平教育~");//4. 调用 private static 方法//4.1 得到 say 方法对象Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);//4.2 因为 say 方法是 private, 所以需要暴破，原理和前面讲的构造器和属性一样say.setAccessible(true);System.out.println(say.invoke(o, 100, "张三", '男'));//4.3 因为 say 方法是 static 的，还可以这样调用 ，可以传入 nullSystem.out.println(say.invoke(null, 200, "李四", '女'));//5. 在反射中，如果方法有返回值，统一返回 Object , 但是他运行类型和方法定义的返回类型一致Object reVal = say.invoke(null, 300, "王五", '男');System.out.println("reVal 的运行类型=" + reVal.getClass());//String//在演示一个返回的案例Method m1 = bossCls.getDeclaredMethod("m1");Object reVal2 = m1.invoke(o);System.out.println("reVal2 的运行类型=" + reVal2.getClass());//Monster}
}class Monster {
}class Boss {//类public int age;private static String name;public Boss() {//构造器}public Monster m1() {return new Monster();}private static String say(int n, String s, char c) {//静态方法return n + " " + s + " " + c;}public void hi(String s) {//普通 public 方法System.out.println("hi " + s);}
}
