Java基础 | 反射机制
文章目录
什么是反射？
反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息（比如成员变量，构造器，成员方法等等)，并能操作对象的属性及方法，反射在设计模式和框架底层都会用到**；
加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息，通过这个对象得到类的结构，就称之为反射。
正常创建对象的方式就是new，每创建一个对象就要new一次
public class Main {
public static void main(String[] args) {
I a = create("A");
a.test();
I b = create("B");
b.test();
}
public static I create(String name){
if (name.equals("A")) {
return new A();
} else if(name.equals("B")){
return new B();
}
return null;
}
}
interface I {
public void test();
}
class A implements I {
@Override
public void test() {
System.out.println("A");
}
}
class B implements I {
@Override
public void test() {
System.out.println("B");
}
}
使用反射来创建对象
// 使用反射机制
public static I create2(String name) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Class<?> aClass = Class.forName(name);
I i = (I) aClass.newInstance();
return i;
}
I a1 = create2("A");
只需要将类名传入到creat2方法中就可以动态加载该类，并且实例化该对象
反射的作用
- 在运行时（动态编译）获知任意一个对象所属的类。
- 在运行时构造任意一个类的对象。
- 在运行时获知任意一个类所具有的成员变量和方法。
- 在运行时调用任意一个对象的方法和属性。
- 生成动态代理
反射主要的类
-
java.lang.Class:代表一个类，Class对象表示某个类加载后在堆中的对象 -
java.lang.reflect.Method:代表类的方法，Method对象表示某个类的方法 -
java.lang.reflect.Field:代表类的成员变量，Field对象表示某个类的成员变量 -
java.lang.reflect.Constructor:代表类的构造方法，Constructor对象表示构造器
类加载机制
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8bilDR0y-1666164795200)(Java基础 反射机制.assets/image-20221019143036788.png)]](https://img-blog.csdnimg.cn/c4a61ed2c101412b9709dcf166cffc79.png)
当程序经过编译之后会生成一个.class文件，然后被类加载器（Class Loader）加载进 JVM 的内存中，同时会创建一个 A 类的 Class 对象存到堆中（注意这个不是 new 出来的对象，而是类的类型对象）。JVM 在创建 A 对象前，会先检查其类是否加载，寻找类对应的 Class 对象，若加载好，则为其分配内存，然后再进行初始化.
每一个类只会拥有一个class对象，继续执行new语句也只会指向一个class对象
当一个类加载完毕之后，就会在堆内存中产生一个class对象，这个对象包含了类的完整信息，我们可以之后通过对象来看见类的完整信息，也就是反射
获取class类对象的四种方式
第一种：已知一个类的全类名
可通过Class类的静态方法forName(获取，可能抛出ClassNotFoundException
Class a = Class.forName("com.xxx.a");
应用场景：多用于配置文件，读取类全路径，加载类.
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6ZTgLob-1666164795201)(Java基础 反射机制.assets/image-20221019144536489.png)]](https://img-blog.csdnimg.cn/21b9f61e4667465ba3ff57a4eda599c7.png)
boolean 参数表示类是否需要初始化，默认是需要初始化。一旦初始化，就会触发目标对象的 static 块代码执行，static 参数也会被再次初始化。
第二种：知道具体类的情况下可以使用：
通过类的class获取，该方式最为安全可靠，程序性能最高
Class a = A.class;
应用场景：多用于参数传递，比如通过反射得到对应构造器对象.
第三种：已知某个实例对象
调用该实例的getClass()方法获取Classj对象
Class a = a.getClass();
应用场景：通过创建好的对象，获取Class对象
第四种:通过类加载器 xxxClassLoader.loadClass() 传入类路径获取
class a = ClassLoader.LoadClass("com.xxx.A");
通过类加载器获取 Class 对象不会进行初始化，意味着不进行包括初始化等一些列步骤，静态块和静态对象不会得到执行。和forName方法有所不同
通过反射构造一个类的实例
第一种：使用 Class.newInstance
A a = new A();
Class<? extends A> aClass = a.getClass();
A a2 = aClass.newInstance();//这里a 和 a2 是具有相同类型的实例
第二种： 通过反射先获取构造方法再调用
由于不是所有的类都有无参构造函数又或者类构造器是 private 的，在这样的情况下，如果我们还想通过反射来实例化对象，Class.newInstance 是无法满足的。
此时，我们可以使用 Constructor 的 newInstance 方法来实现，先获取构造函数，再执行构造函数。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8nn1Xauo-1666164795201)(Java基础 反射机制.assets/image-20221019145746903.png)]](https://img-blog.csdnimg.cn/4bc3b53d7cf1424fa1a30bc8861e7a85.png)
第三种：使用开源库 Objenesis
Objenesis 是一个开源库，和上述第二种方法一样，可以调用任意的构造函数
反射机制的优缺点
优点： 比较灵活，能够在运行时动态获取类的实例。
缺点：
1）性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的 Java 代码要慢很多。
2）安全问题：反射机制破坏了封装性，因为通过反射可以获取并调用类的私有方法和字段
通过反射获得类的结构信息
java.lang.Class类包含的
-
getName:获取全类名 -
getSimpleName:获取简单类名 -
getFields:获取所有public修饰的属性，包含本类以及父类的 -
getDeclaredFields:获取本类中所有属性 -
getMethods:获取所有oublicf修饰的方法，包含本类以及父类的 -
getDeclaredMethods:获取本类中所有方法 -
getConstructors:获取本类所有public修饰的构造器 -
getDeclaredConstructors:获取本类中所有构造器 -
getPackage:以Package形式返回包信息 -
getSuperClass:以Class形式返回父类信息 -
getInterfaces:以Class[]形式返回接口信息 -
getAnnotations:以Annotation]形式返回注解信息
java.lang.reflect.Constructor 类包含的
-
getModifiers:以int形式返回修饰符 -
getName:返回构造器名（全类名） -
getParameterTypes:以Class[]返回参数类型数组
public class ReflectionUtils {
public static void main(String[] args) {
}
@Test
public void api_02() throws ClassNotFoundException, NoSuchMethodException {
//得到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 ClassNotFoundException, NoSuchMethodException {
//得到Class对象
Class<?> personCls = Class.forName("com.hspedu.reflection.Person");
//getName:获取全类名
System.out.println(personCls.getName());//com.hspedu.reflection.Person
//getSimpleName:获取简单类名
System.out.println(personCls.getSimpleName());//Person
//getFields:获取所有public修饰的属性，包含本类以及父类的
Field[] fields = personCls.getFields();
for (Field field : fields) {//增强for
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());//com.hspedu.reflection
//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);//注解
}
}
}
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() {
}
}
通过反射调用成员方法
public class ReflecAccessMethod {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//1. 得到Boss类对应的Class对象
Class<?> bossCls = Class.forName("com.hspedu.reflection.Boss");
//2. 创建对象
Object o = bossCls.newInstance();
//3. 调用public的hi方法
Method hi = bossCls.getMethod("hi", String.class);//OK
//3.1 得到hi方法对象
Method hi2 = bossCls.getDeclaredMethod("hi", String.class);//OK
//3.2 调用
hi.invoke(o, "韩顺平教育~");
hi2.invoke(o,"123");
//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);
}
}
通过反射操作成员属性
public class ReflecAccessProperty {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
//1. 得到Student类对应的 Class对象
Class<?> stuClass = Class.forName("com.hspedu.reflection.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是static
}
}
class Student {//类
public int age;
private static String name;
public Student() {//构造器
}
public String toString() {
return "Student [age=" + age + ", name=" + name + "]";
}
}
反射的应用
- 动态代理机制
- 使用 JDBC 连接数据库
- Spring
连接数据库
在 JDBC 的操作中，如果要想进行数据库的连接，则必须按照以下几步完成：
- 通过
Class.forName()加载数据库的驱动程序 （通过反射加载） - 通过
DriverManager类连接数据库，参数包含数据库的连接地址、用户名、密码 - 通过
Connection接口接收连接 - 关闭连接
public static void main(String[] args) throws Exception {
Connection con = null; // 数据库的连接对象
// 1. 通过反射加载驱动程序
Class.forName("com.mysql.jdbc.Driver");
// 2. 连接数据库
con = DriverManager.getConnection(
"jdbc:mysql://localhost:3306/test","root","root");
// 3. 关闭数据库连接
con.close();
}
Spring
通过xml文件来转载Bean对象，IOC过程：
- 加载配置文件，获取 Spring 容器
- 使用反射机制，根据传入的字符串获得某个类的 Class 实例
// 获取 Spring 的 IoC 容器，并根据 id 获取对象
public static void main(String[] args) {
// 1.使用 ApplicationContext 接口加载配置文件，获取 spring 容器
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
// 2. 使用反射机制，根据这个字符串获得某个类的 Class 实例
AService aService = (IAccountService) ac.getBean("AServiceImpl");
System.out.println(aService);
}
代码部分来自于：韩顺平老师的反射课程
https://www.bilibili.com/video/BV1g84y1F7df/?p=20&spm_id_from=333.880.my_history.page.click
65
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
