反射学习笔记
反射学习笔记
一、反射入门案例
- 在反射中，万物皆对象，方法也是对象。
- 反射可以在不修改源码的情况下，只需修改配置文件，就能实现功能的改变。
实体类
/**
* 动物猫类
*/
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
//Constructor
m1();//传统
m2();//反射
m3();//反射优化
}
//传统方法来调用 hi
public 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));
}
//反射机制调用方法 hi
public 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. 输出cls
System.out.println("Class对象类型："+cls);// class pers.jl.Car
System.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;
}
@Override
public 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 的运行类型就是 Student
System.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 也可以写出 null
System.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 的，还可以这样调用 ，可以传入 null
System.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);
}
}