一个需求引出反射
请看下面问题:
- 根据配置文件
re.properties
指定的信息,创建对象并调用方法
//re.properties
classfullpath=com.Cat
method=hi
快速入门,com.ReflectionQuestion.java
package com;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Properties;
public class ReflectionQuestion {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//根据配置文件re.properties指定的信息,创建对象并调用方法
//传统方式 new 对象-》调用方法
Cat cat = new Cat();
cat.hi();
//1、使用Properties类,可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("./18反射/re.properties"));
String classfullpath = properties.get("classfullpath").toString();
String method = properties.get("method").toString();
// List method = List.of(properties.get("method").toString().split(","));
System.out.println("classfullpath:" + classfullpath);
System.out.println("method:" + method);
//2、创建对象,使用反射机制
//(1)加载类,返回Class类型的对象
Class aClass = Class.forName(classfullpath);
//(2)通过aClass得到加载的类com.Cat的对象实例
Object o = aClass.newInstance();
System.out.println(o.getClass());//运行类型
// (3) 通过getMethod(),得到加载的类com.Cat的methodName "hi"的方法对象
// 即,在反射中,可以把方法视为对象
Method method1 = aClass.getMethod(method);
//(4)通过method1 调用方法,即通过方法对象实现调用方法
method1.invoke(o); //传统方法 对象方法(),反射机制 方法.invoke(对象)
//多方法
// for (int i = 0; i < method.size(); i++) {
// Method method1 = aClass.getMethod((String) method.get(i));
// method1.invoke(o); //传统方法 对象方法(),反射机制 方法.invoke(对象)
//
// }
}
}
public class Cat {
private String name="miaomiao";
public void hi(){
System.out.println("hi"+name);
}
public void hi2(){
System.out.println("hi2"+name);
}
}
反射机制
Java Reflection
- 允许程序在执行期借助于Reflection API 取得任何类的内部信息, 比如成员变量、构造器、成员方法等等。 并能操作对象的属性及方法。 反射在设计模式和框架底层都会用到。
- 加载完类之后,在堆中就产生了一个Class类型的对象,一个类只有一个Class对象,这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为反射
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rn5IYF8U-1661650781637)(https://secure2.wostatic.cn/static/aH8niBaDe8RxvGsgkuLAKs/image.png)]
反射机制可以完成
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时得到任意一个类所具有的成员变量和方法
- 在运行时调用任意一个对象的成员变量和方法
- 生成动态代理
反射相关的主要类,com.Reflection01.java
- java.lang.Class:代表一个类,Class对象表示某个类加载后在堆中的对象
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造方法
这些类在java.lang.reflection,提供用于反射的接口
package com;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.*;
import java.util.Properties;
public class Reflection01 {
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
Cat cat = new Cat();
cat.hi();
//1、使用Properties类,可以读写配置文件
Properties properties = new Properties();
properties.load(new FileInputStream("./18反射/re.properties"));
String classfullpath = properties.get("classfullpath").toString();
String method = properties.get("method").toString();
//2、创建对象,使用反射机制
//(1)加载类,返回Class类型的对象
Class cls = Class.forName(classfullpath);
//(2)通过cls得到加载的类com.Cat的对象实例
Object o = cls.newInstance();
// (3) 通过getMethod(),得到加载的类com.Cat的methodName "hi"的方法对象
// 即,在反射中,可以把方法视为对象
Method method1 = cls.getMethod(method);
//(4)通过method1 调用方法,即通过方法对象实现调用方法
method1.invoke(o); //传统方法 对象方法(),反射机制 方法.invoke(对象)
// java.lang.reflect.Field:代表类的成员变量,Field对象表示某个类的成员变量
//得到name字段
//getField不能得到私有的属性
//Field name = cls.getField("name");
Field age = cls.getField("age");
System.out.println(age.get(o));
//java.lang.reflect.Constructor:代表类的构造方法,Constructor对象表示构造器
Constructor constructor = cls.getConstructor();//()中指定构造器参数类型,
System.out.println(constructor);
Constructor constructor1 = cls.getConstructor(String.class);//传入的String.class就是String类的Class对象
System.out.println(constructor1);
}
}
反射优点和缺点,com.Reflection02.java
- 优点: 可以动态的创建和使用对象(也是框架底层核心) 使用灵活,没有反射机制, 框架技术就是去底层支撑
- 缺点:使用反射基本是解释执行,对执行速度有影响
反射调用优化-关闭访问检查
- Method和Field、Constructor对象都有setAccessible()方法
- setAccessible作用是开启和关闭访问安全检查
- 参数值为true表示反射的对象在使用时取消访问检查,提高反射的效率。参数值为false则表示反射的对象执行访问检查
Class类,com.Class01.java
- Class也是类,因此也继承Object类
- Class类对象不是new出来的,而是系统创建的
- 对于某个类的Class类对象,在内存中只有一份,因为类只加载一次
- 每个类的实例都会记得自己是由哪个Class实例所生成
- 通过Class可以完整地得到一个类的完整结构,通过一系列API
- Class对象是存放在堆的
- 类的字节码二进制数据,是放在方法区的,有的地方称为类的元数据(包括方法代码,变量名,方法名,访问权限等等)
package com;
public class Class01 {
public static void main(String[] args) throws ClassNotFoundException {
//Class对象不是new的,而是系统创建的
//(1)传统new对象
// Cat cat = new Cat();
//(2)反射方式
Class<?> cls1 = Class.forName("com.Cat");
//对于某个类的Class类对象,在内存中只有一份,因为类只加载一次[演示]
Class<?> cls2 = Class.forName("com.Cat");
System.out.println(cls1.hashCode());//1175962212
System.out.println(cls2.hashCode());//1175962212
}
}
Class类常用方法,com.Class02.java
package com;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class Class02 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
String classAllPath="com.Car";
//1、获取Car类对应的Class对象
//<?>表示不能确定的Java类型
Class<?> cls = Class.forName(classAllPath);
//2、输出cls
//(1)输出cls是哪个类的cls对象
System.out.println(cls);//class Car
//(2)输出cls运行类型
System.out.println(cls.getClass());//class java.lang.Class
//3、得到包名
System.out.println(cls.getPackage().getName());
//4、得到类名
System.out.println(cls.getName());
//5、通过cls创建对象实例
Car car = (Car) cls.newInstance();
System.out.println(car);//Car{brand='宝马', price=100, color='白色'}
//6、通过反射获取属性 brand,私有属性会报错
Field brand = cls.getField("brand");
System.out.println(brand.get(car));//宝马
//7、通过反射给属性赋值
brand.set(car,"奔驰");
System.out.println(brand.get(car));//奔驰
//8、遍历所有属性
Field[] fields = cls.getFields();
for (Field f :fields) {
System.out.println(f.getName());//所有属性名称
}
}
}
class Car{
public String brand="宝马";
public int price=100;
public String color="白色";
@Override
public String toString() {
return "Car{" +
"brand='" + brand + '\'' +
", price=" + price +
", color='" + color + '\'' +
'}';
}
}
获取Class类对象,com.GetClass_.java
-
前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException,
实例:Class cls1=Class.forName(“java.lang.Cat”)
应用场景:多用于配置文件,读取类全路径,加载类
-
前提:若已知具体的类,通过类.class获取,该方式最为安全可靠,程序性能最高,
实例:Class cls2=Cat.class
应用场景:多用于参数传递,比如通过反射得到对应构造器对象
-
前提:已知某个类的实例,调用该实例的getClass()方法获取Class对象
实例:Class cls3=对象.getClass();//运行类型
应用场景:通过创建好的对象,获取Class对象
-
其他方式
ClassLoader cl = 对象.getClass().getClassLoader();
Class cls4=cl.loadClass(“类的全类名”)
-
基本数据(int、chart、boolean、float、double、byte、long、short)按如下方式得到Class类对象
Class cls=基本数据类型.class
-
基本数据类型对应的包装类,可以通过.type得到Class类对象
Class cls=包装类.TYPE
package com;
public class GetClass_ {
public static void main(String[] args) throws ClassNotFoundException {
//1、Class.forName
String classAllPath="com.Cat";
Class<?> cls1 = Class.forName(classAllPath);
System.out.println(cls1);
//2、类名.class,应用场景:用于参数传递
Class<Cat> cls2 = Cat.class;
System.out.println(cls2);
//3、对象.getClass(),应用场景:有对象实例
Cat cat = new Cat();
Class<? extends Cat> cls3 = cat.getClass();
System.out.println(cls3);
//4、通过类加载器来获得类的Class对象
//(1)先得到类加载器 cat
ClassLoader classLoader = cat.getClass().getClassLoader();
//(2)通过类加载器得到Class对象
Class<?> cls4 = classLoader.loadClass(classAllPath);
System.out.println(cls4);
//cls1\2\3\4是同一个对象
//5、基本数据(int、chart、boolean、float、double、byte、long、short)按如下方式得到Class类对象
Class<Integer> integerClass = int.class;
Class<Character> characterClass = char.class;
Class<Boolean> booleanClass = boolean.class;
System.out.println(integerClass); //int
//6、基本数据类型对应的包装类,可以通过.type得到Class类对象
Class<Integer> type1 = Integer.TYPE;
Class<Character> type2 = Character.TYPE;
System.out.println(type1); // int
System.out.println(integerClass.hashCode());//1769597131
System.out.println(type1.hashCode());//1769597131
}
}
哪些对象有Class对象,com.AllTypeClass.java
- 外部类、成员内部类、静态内部类、局部内部类、匿名内部类
- interface:接口
- 数组
- enum:枚举
- annotation:注解
- 基本数据类型
- void
package com;
import java.io.Serializable;
public class AllTypeClass {
public static void main(String[] args) {
//1. 外部类、成员内部类、静态内部类、局部内部类、匿名内部类
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数据类型
Class<Class> cls9 = Class.class;//外部类
System.out.println(cls1);//class java.lang.String
System.out.println(cls2);//interface java.io.Serializable
System.out.println(cls3);//class [Ljava.lang.Integer;
System.out.println(cls4);//class [[F
System.out.println(cls5);//interface java.lang.Deprecated
System.out.println(cls6);//class java.lang.Thread$State
System.out.println(cls7);//long
System.out.println(cls8);//void
System.out.println(cls9);//class java.lang.Class
}
}
类加载
基本说明,com.ClassLoad_java.java
反射机制是java实现动态语言的关键,也就是通过反射实现类动态加载
- 静态加载:编译时就加载相关的类,如果没有则报错,依赖性太强
- 动态加载:运行时加载需要的类,如果运行时不用该类,即使不存在该类也不报错,降低依赖性
package com;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Scanner;
public class ClassLoad_ {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Scanner scanner = new Scanner(System.in);
System.out.println("输入key");
String key = scanner.next();
switch (key){
case "1":
//静态加载必须编写Notexist类
// Notexist no = new Notexist();//静态加载
// no.hi();
break;
case "2":
//反射:动态加载
//动态加载不编写Notexist类也不会报错,只有当动态加载该类时才会报错
Class<?> cls = Class.forName("Notexist");
Object o = cls.newInstance();
Method m = cls.getMethod("nohi");
m.invoke(o);
break;
}
}
}
类加载时机
- 当创建对象时(new)
- 当子类被加载时
- 调用类中的静态成员时
- 通过反射
类加载过程
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1vp9ldPJ-1661650781638)(https://secure2.wostatic.cn/static/2ZQzprDgKiqZ8VHian3ZFu/image.png)]
一、加载阶段
JVM在该阶段的主要目的是将字节码从不同的数据源(可能是class文件,也可能是jar包,甚至网络)转换为二进制字节流加载到内存中,并生成一个代表该类的java.lang.Class对象
二、连接阶段-验证
- 目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全
- 包括:文件格式验证,元数据验证,字节吗验证和富豪引用验证
- 可以考虑使用-Xverify:none参数来关闭大部分的类验证措施,缩短虚拟机类加载的时间
二、连接阶段-准备
- JVM会在该阶段对静态变量,分配内存并初始化(对应数据类型的默认初始值,如0、null、false等)。这些变量所使用的内存都将在方法区中进行分配
二、连接阶段-解析
- 虚拟机将常量池内的符号引用替换为直接引用的过程
三、初始化阶段
- 到初始化阶段,才真正开始执行类中定义的Java程序代码,此阶段是执行()方法的过程
- ()方法是由编译器按语句在源文件中出现的顺序,依次自动收集类中的所有 静态变量的赋值动作和静态代码块中的语句,并进行合并
- 虚拟机会保证一个类的()方法在多线程换几个闹钟功能被正确的加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的()方法,其他线程都需要阻塞等待,直到活动线程执行()方法完毕
通过反射获取类的结构信息
第一组:java.lang.Class类,com.ReflectionUtils.java
- getName:获取全类名
- getSimpleName:获取简单类名
- getFields:获取所有public修饰的属性,包含本类以及父类的
- getDeclaredFields:获取本类中所有属性
- getMethods:获取所有public修饰的方法,包含本类以及父类的
- getDeclaredMethods:获取本类中所有方法
- getConstructors:获取本类中所有public修饰的构造器
- getDeclaredConstructors获取本类中所有构造器
- getPackage:以Package形式返回包信息
- getSuperClass:以Class形式返回父类信息
- getlnterfaces:以Class[形式返回接口信息
- getAnnotations:以Annotation形式返回注解信息
package com;
import org.junit.Test;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
public class ReflectionUtils {
public static void main(String[] args) {
}
//第一组方法API
@Test
public void api_01() throws ClassNotFoundException {
//得到Class对象
Class<?> personCls = Class.forName("com.Person");
//1. getName:获取全类名
System.out.println(personCls.getName());
//2. getSimpleName:获取简单类名
System.out.println(personCls.getSimpleName());
//3. getFields:获取所有public修饰的属性,包含本类以及父类的
Field[] fields = personCls.getFields();
for (Field field : fields) {
System.out.println("本类及父类的属性:"+field.getName());
}
//4. getDeclaredFields:获取本类中所有属性
Field[] declaredFields = personCls.getDeclaredFields();
for (Field declaredField : declaredFields) {
System.out.println("获取本类中所有属性:"+declaredField);
}
//5. getMethods:获取所有public修饰的方法,包含本类以及父类的
Method[] methods = personCls.getMethods();
for (Method method : methods) {
System.out.println("本类以及父类的"+method);
}
//6. getDeclaredMethods:获取本类中所有方法
Method[] declaredMethods = personCls.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
System.out.println("本类中所有方法"+declaredMethod);
}
//7. getConstructors:获取所有public修饰的构造器,包含本类以及父类的构造器
Constructor<?>[] constructors = personCls.getConstructors();
for (Constructor<?> constructor : constructors) {
System.out.println("本类以及父类的构造器"+constructor);
}
//8. getDeclaredConstructors获取本类中所有构造器
Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
for (Constructor<?> declaredConstructor : declaredConstructors) {
System.out.println("本类中所有构造器"+declaredConstructor);
}
//9. getPackage:以Package形式返回包信息
System.out.println(personCls.getPackage());
//10. getSuperClass:以Class形式返回父类信息
Class<?> superclass = personCls.getSuperclass();
System.out.println("返回父类的class对象:"+superclass);
//11. getlnterfaces:以Class[形式返回接口信息
Class<?>[] interfaces = personCls.getInterfaces();
for (Class<?> anInterface : interfaces) {
System.out.println("接口信息"+anInterface);
}
//12. getAnnotations:以Annotation形式返回注解信息
Annotation[] annotations = personCls.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println("返回注解信息"+annotation);
}
}
}
class A{
public String hobby;
public A() {}
public void hi(){}
}
interface IA{}
interface IB{}
@Deprecated
class Person extends A implements IA,IB{
//属性
public String name;
protected int age;
String job;
private double sal;
//构造函数
public Person(String name) {
this.name = name;
}
private Person(String name, int age) {
this.name = name;
this.age = age;
}
//方法
public void m1(){}
protected void m2(){}
void m3(){}
private void m4(){}
}
第二组:java.lang.reflect.Field类
-
getModifiers:以int形式返回修饰符
默认修饰符是0,public是1,private时2,protectes是4,static是8,final是16。如果是public static,就是1+8=9
-
getType:以Class形式返回类型
-
getName:返回属性名
第三组:java.lang.reflect.Method类
- getModifiers:以int形式返回修饰符
[说明:默认修饰符是o,public是1,private是2,protected是4,static是8,final是16] - getReturnType:以Class形式获取返回类型
- getName:返回方法名
- getParameterTypes:以Class返回参数类型数组
第四组:java.lang.reflect.Constructor类
- getModifiers:以int形式返回修饰符
- getName:返回构造器名(全类名)
- getParameterTypes:以Class[返回参数类型数组]
通过反射创建对象,com.ReflectCreateInstance.java
-
方法1:调用类中public修饰的无参构造器
-
方法2:调用类中指定构造器
-
Class类相关方法
newInstance:调用类中的无参构造器,获取对应类的对象
getConstructor(Class cls):根据参数列表,获取对应的public构造器对象
getDecalaredConstructor(Class cls):根据参数列表,获取对应的所有的构造器对象
-
Constructor类相关方法
setAccessible:暴破,使用反射可以访问private构造器
newInstance(Object obj):调用构造器
package com;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectCreateInstance {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//通过反射创建某类的对象,要求该类中必须有public的无参构造器
//1、先获取User类的Class对象
Class<?> userClass = Class.forName("com.User");
//2、通过public的无参构造器创建实例
Object o = userClass.newInstance();
System.out.println(o);
//3、通过public的有参构造器创建实例
//constructor就是
// public User(String name) {//public有参构造器
// this.name = name;}
Constructor<?> constructor = userClass.getConstructor(String.class);
Object zhangsan = constructor.newInstance("zhangsan");
System.out.println(zhangsan);
//4、通过非private的构造器创建实例
Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
constructor1.setAccessible(true);//暴破,使用反射可以访问private构造器
Object lisi = constructor1.newInstance(18, "lisi");
System.out.println(lisi);
}
}
class User {
private int age;
private String name;
public User() {}
public User(String name) {//public有参构造器
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 + '\'' + '}';
}
}
通过反射访问类中的成员,com.ReflectAccessProperty.java
-
根据属性名获取Field对象
Field f=cls对象.getDeclaredField(属性名);
-
暴破:f.setAccessible(true);
-
访问:
f.set(o,值);
syso(f.get(o));
-
如果是静态属性,则set和get中的o,可以写成null
package com;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class ReflectAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
//通过反射创建某类的对象,要求该类中必须有public的无参构造器
//1、先获取Student类的Class对象
Class<?> stuclass = Class.forName("com.Student");
//2、创建对象
Object o = stuclass.newInstance();
System.out.println(o.getClass());//运行类型是Student
//3.使用反射得到age属性对象
Field age = stuclass.getField("age");
age.set(o,88);//通过反射来操作属性
System.out.println(age.get(o));
//4、使用反射操作name属性 private static
Field name = stuclass.getDeclaredField("name");
name.setAccessible(true);
// name.set(o,"zhangsan");
name.set(null,"zhangsan");//name是static,因此 o 也可以写成null
System.out.println(name.get(o));
System.out.println(name.get(null));//获取属性值,要求name是静态的
}
}
class Student {
public int age;
private static String name;
public Student() {}
@Override
public String toString() {
return "Student{" +"age=" + age +'}';
}
}
通过反射访问类中方法,com.ReflectAccessMethod.java
-
根据方法名和参数列表获取Method方法对象:
Method m=cls.getDeclaredMethod(方法名,xx.class);
-
获取对象:Object o=cls.newInstance();
-
暴破:m.setAccessible(true);
-
访问:Object returnValue = m.invoke(o,实参列表);
-
注意:如果是静态方法,则invoke的参数o可以写成null
package com;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//1、得到Boss类对应Class对象
Class<?> bossCls = Class.forName("com.Boss");
//2、创建对象
Object o = bossCls.newInstance();
//3.1、调用public的方法
Method hi = bossCls.getMethod("hi", String.class);
//3.2、调用
hi.invoke(o, "nihao");
//4、调用private static 方法
Method say = bossCls.getDeclaredMethod("say",int.class,String.class,char.class);
say.setAccessible(true);
// System.out.println(say.invoke(o,100,"zhangsan","男"));
System.out.println(say.invoke(null,100,"zhangsan","男"));
//5、在反射中,如果方法有返回值,返回Object,
// 但是运行类型和方法定义返回类型一致
Object invoke = say.invoke(null, 300, "王武", "男");
System.out.println(invoke.getClass());//String
}
}
class Boss {
public int age;
private static String name;
public Boss() {}
public void hi(String s) {
System.out.println(s);
}
private static String say(int n, String s, char c) {
return n + " " + s + " " + c;
}
}